diff --git a/src/components.rs b/src/components.rs
index 0577976..6b02234 100644
--- a/src/components.rs
+++ b/src/components.rs
@@ -33,11 +33,20 @@ pub struct FormationTarget {
     pub position: Vec3,
 }
 
-#[derive(Component, Clone, PartialEq)]
+// 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
+    // Add more patterns later (e.g., FigureEight, Looping)
+}
+
+#[derive(Component, Clone, PartialEq, Debug)] // Added Debug derive
 pub enum EnemyState {
-    Entering,    // Flying onto the screen towards formation target
-    InFormation, // Holding position in the formation
-    Attacking,   // Diving towards the player
+    Entering,                // Flying onto the screen towards formation target
+    InFormation,             // Holding position in the formation
+    Attacking(AttackPattern), // Diving towards the player using a specific pattern
 }
 
 #[derive(Component)]
diff --git a/src/enemy.rs b/src/enemy.rs
index 145553d..5cacf51 100644
--- a/src/enemy.rs
+++ b/src/enemy.rs
@@ -2,59 +2,69 @@ use bevy::prelude::*;
 use std::time::Duration;
 
 use crate::components::{Enemy, EnemyBullet, EnemyState, EnemyType, FormationTarget};
-use crate::constants::{
+use crate::constants::{ // Added WINDOW_WIDTH
     ENEMY_BULLET_PLAYER_COLLISION_THRESHOLD, ENEMY_BULLET_SIZE, ENEMY_BULLET_SPEED,
     ENEMY_SHOOT_INTERVAL, ENEMY_SIZE, ENEMY_SPEED, FORMATION_BASE_Y, FORMATION_COLS,
-    FORMATION_ENEMY_COUNT, FORMATION_X_SPACING, FORMATION_Y_SPACING, WINDOW_HEIGHT,
+    FORMATION_ENEMY_COUNT, FORMATION_X_SPACING, FORMATION_Y_SPACING, WINDOW_HEIGHT, WINDOW_WIDTH,
 };
 use crate::resources::{
     AttackDiveTimer, CurrentStage, EnemySpawnTimer, FormationState, PlayerLives,
-    PlayerRespawnTimer,
+    PlayerRespawnTimer, StageConfigurations, // Make sure StageConfigurations is imported if not already
 };
-use crate::game_state::AppState; // Needed for check_enemy_bullet_player_collisions
+use crate::game_state::AppState;
 
 pub fn spawn_enemies(
     mut commands: Commands,
     time: Res<Time>,
     mut timer: ResMut<EnemySpawnTimer>,
     mut stage: ResMut<CurrentStage>,
-    mut formation_state: ResMut<FormationState>, // Add formation state resource
+    mut formation_state: ResMut<FormationState>,
+    stage_configs: Res<StageConfigurations>, // Use imported name
 ) {
+    // 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
     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 < FORMATION_ENEMY_COUNT
+    if formation_state.total_spawned_this_stage < stage_enemy_count
         && timer.timer.just_finished()
     {
-        // Calculate grid position
         let slot_index = formation_state.next_slot_index;
-        let row = slot_index / FORMATION_COLS;
-        let col = slot_index % FORMATION_COLS;
 
-        // Calculate target position in formation
-        let target_x = (col as f32 - (FORMATION_COLS as f32 - 1.0) / 2.0) * FORMATION_X_SPACING;
-        let target_y = FORMATION_BASE_Y - (row as f32 * FORMATION_Y_SPACING);
-        let target_pos = Vec3::new(target_x, target_y, 0.0);
+        // 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;
+        }
 
-        // Spawn position (still random at the top for now)
-        let spawn_x = (fastrand::f32() - 0.5) * (WINDOW_HEIGHT - ENEMY_SIZE.x); // Use WINDOW_HEIGHT for x spawn range? Should be WINDOW_WIDTH
-        let spawn_y = WINDOW_HEIGHT / 2.0 - ENEMY_SIZE.y / 2.0;
+        // Get target position from the stage's formation layout
+        let target_pos = current_config.formation_layout.positions[slot_index];
 
-        // Determine enemy type (currently always Grunt)
+        // 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
+
+        // Determine enemy type (can be randomized or based on stage config later)
         let enemy_type = EnemyType::Grunt;
 
         // Determine sprite color based on type
         let sprite_color = match enemy_type {
-            EnemyType::Grunt => Color::rgb(1.0, 0.2, 0.2), // Red for Grunts
-            EnemyType::Boss => Color::rgb(0.8, 0.2, 1.0),  // Purple for Bosses
+            EnemyType::Grunt => Color::rgb(1.0, 0.2, 0.2),
+            EnemyType::Boss => Color::rgb(0.8, 0.2, 1.0),
         };
 
         commands.spawn((
             SpriteBundle {
                 sprite: Sprite {
-                    color: sprite_color, // Use determined color
+                    color: sprite_color,
                     custom_size: Some(ENEMY_SIZE),
                     ..default()
                 },
@@ -62,30 +72,32 @@ pub fn spawn_enemies(
                 ..default()
             },
             Enemy {
-                enemy_type, // Use the defined type
-                // Initialize cooldown, maybe slightly randomized later
+                enemy_type,
+                // Use shoot interval from stage config
                 shoot_cooldown: Timer::new(
-                    Duration::from_secs_f32(ENEMY_SHOOT_INTERVAL),
+                    Duration::from_secs_f32(current_config.enemy_shoot_interval),
                     TimerMode::Once,
                 ),
             },
-            FormationTarget {
-                position: target_pos,
-            },
-            EnemyState::Entering, // Start in Entering state
+            FormationTarget { position: target_pos },
+            EnemyState::Entering,
         ));
 
-        formation_state.next_slot_index = (slot_index + 1) % FORMATION_ENEMY_COUNT; // Cycle through slots if needed, though we stop spawning
+        // 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 < FORMATION_ENEMY_COUNT {
+        if formation_state.total_spawned_this_stage < stage_enemy_count {
             timer.timer.reset();
         } else {
-            println!("Full formation spawned for Stage {}", stage.number);
+            println!(
+                "Full formation ({}) spawned for Stage {}",
+                current_config.formation_layout.name, stage.number
+            );
         }
     }
 }
@@ -101,11 +113,18 @@ pub fn move_enemies(
     >, // Query potential attackers
     time: Res<Time>,
     mut commands: Commands,
-    stage: Res<CurrentStage>, // Add stage resource for speed calculation
+    stage: Res<CurrentStage>,
+    stage_configs: Res<StageConfigurations>, // Add stage configurations
 ) {
-    // Increase speed based on stage number
-    let current_speed = ENEMY_SPEED + (stage.number - 1) as f32 * 10.0;
-    let arrival_threshold = current_speed * time.delta_seconds() * 1.1; // Slightly more than one frame's movement
+    // 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 base_speed = ENEMY_SPEED * speed_multiplier;
+    let attack_speed = base_speed * 1.5; // Attackers are faster
+    let arrival_threshold = base_speed * time.delta_seconds() * 1.1; // Threshold for reaching formation target
 
     // --- Handle Entering Enemies ---
     for (entity, mut transform, target, mut state) in entering_query.iter_mut() {
@@ -126,49 +145,62 @@ pub fn move_enemies(
                     entity
                 );
             } else {
-                // Move towards target
-                let move_delta = direction.normalize() * current_speed * time.delta_seconds();
+                // Move towards target using base_speed
+                let move_delta = direction.normalize() * base_speed * time.delta_seconds();
                 transform.translation += move_delta;
             }
         }
     }
 
     // --- Handle Attacking Enemies ---
-    let attack_speed = current_speed * 1.5; // Make them dive faster
-    for (entity, mut transform, state, enemy) in attacking_query.iter_mut() {
-        // Get state and enemy
-        // *** Explicitly check if the enemy is actually in the Attacking state ***
-        if *state == EnemyState::Attacking {
-            // --- Apply movement based on EnemyType ---
-            match enemy.enemy_type {
-                EnemyType::Grunt | EnemyType::Boss => { // Combine logic if it's the same
-                    // Swooping Dive Logic
-                    let delta_seconds = time.delta_seconds();
-                    let vertical_movement = attack_speed * delta_seconds;
+    // Note: attack_speed calculated above using multiplier
+    for (entity, mut transform, state, _enemy) in attacking_query.iter_mut() {
 
-                    // Horizontal movement: Move towards the center (x=0)
-                    let horizontal_speed_factor = 0.5; // Adjust this to control the swoop intensity
+        // Match on the specific attack pattern using matches! and then get the pattern
+        if matches!(state, EnemyState::Attacking(_)) {
+             if let EnemyState::Attacking(pattern) = state { // Get the pattern safely now
+            let delta_seconds = time.delta_seconds();
+
+            match pattern {
+                AttackPattern::SwoopDive => {
+                    // Original Swooping Dive Logic
+                    let vertical_movement = attack_speed * delta_seconds;
+                    let horizontal_speed_factor = 0.5;
                     let horizontal_movement = if transform.translation.x < 0.0 {
                         attack_speed * horizontal_speed_factor * delta_seconds
                     } else if transform.translation.x > 0.0 {
                         -attack_speed * horizontal_speed_factor * delta_seconds
-                    } else {
-                        0.0 // No horizontal movement if exactly at center
-                    };
+                    } else { 0.0 };
 
-                    // Apply movement
                     transform.translation.y -= vertical_movement;
                     transform.translation.x += horizontal_movement;
 
-                    // Ensure enemy doesn't overshoot the center horizontally if moving towards it
-                    if (transform.translation.x - horizontal_movement < 0.0
-                        && transform.translation.x > 0.0)
-                        || (transform.translation.x - horizontal_movement > 0.0
-                            && transform.translation.x < 0.0)
-                    {
+                    // 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;
                     }
-                } // Add cases for other enemy types later if different
+                }
+                AttackPattern::DirectDive => {
+                    // Move straight down
+                    transform.translation.y -= attack_speed * delta_seconds;
+                }
+                AttackPattern::Kamikaze(target_pos) => {
+                    // Move towards the target position
+                    let direction = *target_pos - transform.translation;
+                    let distance = direction.length();
+                    let kamikaze_threshold = attack_speed * delta_seconds * 1.1; // Threshold to stop near target
+
+                    if distance > kamikaze_threshold {
+                        let move_delta = direction.normalize() * attack_speed * delta_seconds;
+                        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
+                    }
+                }
+                // Add cases for other patterns here
+             } // Close inner if let
             } // Closes match enemy.enemy_type
         } // Closes if *state == EnemyState::Attacking
 
@@ -187,17 +219,25 @@ pub fn move_enemies(
 // 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>>, // Query states directly
-    mut attack_dive_timer: ResMut<AttackDiveTimer>, // Add timer to reset it
+    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
 ) {
     // Only run the check if the formation isn't already marked as complete
     if !formation_state.formation_complete {
-        // Check if all enemies for the stage have been spawned
-        if formation_state.total_spawned_this_stage == FORMATION_ENEMY_COUNT {
+        // 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() {
-                if *state == EnemyState::Entering {
+                // Use matches! macro for safety
+                if matches!(state, EnemyState::Entering) {
                     any_entering = true;
                     break;
                 }
@@ -205,24 +245,34 @@ pub fn check_formation_complete(
 
             // If all spawned and none are entering, formation is complete
             if !any_entering {
-                println!(
-                    "Formation complete! Resetting attack timer. (Spawned={})",
-                    formation_state.total_spawned_this_stage
+                 println!(
+                    "Formation complete for Stage {}! Setting attack timer. (Spawned={})",
+                    stage.number, formation_state.total_spawned_this_stage
                 );
                 formation_state.formation_complete = true;
-                attack_dive_timer.timer.reset(); // Reset the dive timer
-                attack_dive_timer.timer.unpause(); // Start the timer now
-                println!("Formation complete! Attack timer unpaused and reset.");
+
+                // 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);
             }
         }
     }
 }
 
+use crate::components::AttackPattern; // Import the new enum
+use crate::components::Player; // Import Player for Kamikaze target
+
 pub fn trigger_attack_dives(
     mut timer: ResMut<AttackDiveTimer>,
     time: Res<Time>,
-    mut query: Query<(Entity, &mut EnemyState), With<Enemy>>,
-    formation_state: Res<FormationState>, // Read formation state
+    mut enemy_query: Query<(Entity, &mut EnemyState), With<Enemy>>, // Renamed for clarity
+    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
 ) {
     timer.timer.tick(time.delta());
 
@@ -230,22 +280,45 @@ pub fn trigger_attack_dives(
     if timer.timer.just_finished() && formation_state.formation_complete {
         // Find all enemies currently in formation
         let mut available_enemies: Vec<Entity> = Vec::new();
-        for (entity, state) in query.iter() {
-            if *state == EnemyState::InFormation {
+        // 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];
+
+        // Find all enemies currently in formation
+        let mut available_enemies: Vec<Entity> = Vec::new();
+        for (entity, state) in enemy_query.iter() {
+            // Check the state correctly
+            if matches!(state, EnemyState::InFormation) {
                 available_enemies.push(entity);
             }
         }
 
         // If there are enemies available, pick one randomly
-        if !available_enemies.is_empty() {
+        if !available_enemies.is_empty() && !current_config.attack_patterns.is_empty() {
             let random_index = fastrand::usize(..available_enemies.len());
             let chosen_entity = available_enemies[random_index];
 
+            // Select a random attack pattern for this stage
+            let pattern_index = fastrand::usize(..current_config.attack_patterns.len());
+            let mut selected_pattern = current_config.attack_patterns[pattern_index]; // Copy the pattern
+
+            // If Kamikaze, get player position (if player exists)
+            if let AttackPattern::Kamikaze(_) = selected_pattern {
+                if let Ok(player_transform) = player_query.get_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)) = query.get_mut(chosen_entity) {
-                println!("Enemy {:?} starting attack dive!", chosen_entity);
-                *state = EnemyState::Attacking;
-                // Timer will automatically repeat due to TimerMode::Repeating
+            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)
             }
         }
     }
@@ -255,21 +328,21 @@ 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>>,
+    mut enemy_query: Query<(&Transform, &mut Enemy, &EnemyState), Without<FormationTarget>>, // Query remains the same
 ) {
     for (transform, mut enemy, state) in enemy_query.iter_mut() {
-        // Only shoot if attacking
-        if *state == EnemyState::Attacking {
+        // 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.finished() {
-                println!("Enemy {:?} firing!", transform.translation); // Placeholder for entity ID if needed
+                // 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((
                     SpriteBundle {
                         sprite: Sprite {
-                            color: Color::rgb(1.0, 0.5, 0.5), // Different color for enemy bullets
+                            color: Color::rgb(1.0, 0.5, 0.5),
                             custom_size: Some(ENEMY_BULLET_SIZE),
                             ..default()
                         },
diff --git a/src/main.rs b/src/main.rs
index 1873ef9..8a1ba75 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,9 +12,9 @@ pub mod stage;
 pub mod systems;
 
 use constants::{PLAYER_RESPAWN_DELAY, STARTING_LIVES, WINDOW_HEIGHT, WINDOW_WIDTH};
-use resources::{
+use resources::{ // Added StageConfigurations
     AttackDiveTimer, CurrentStage, EnemySpawnTimer, FormationState, PlayerLives,
-    PlayerRespawnTimer, Score,
+    PlayerRespawnTimer, Score, StageConfigurations,
 };
 use game_state::{
     cleanup_game_entities, cleanup_game_over_ui, setup_game_over_ui, AppState,
@@ -69,6 +69,14 @@ fn main() {
             total_spawned_this_stage: 0,
             formation_complete: false,
         })
+        .insert_resource(StageConfigurations::default()) // Add stage configurations
+        .insert_resource(AttackDiveTimer {
+            timer: { // Correctly assign the block expression to the timer field
+                let mut timer = Timer::new(Duration::from_secs_f32(3.0), TimerMode::Repeating); // Default duration, will be overwritten by stage config
+                timer.pause(); // Start paused
+                timer
+            }
+        })
         .insert_resource(AttackDiveTimer {
             timer: {
                 let mut timer = Timer::new(Duration::from_secs_f32(3.0), TimerMode::Repeating);
diff --git a/src/resources.rs b/src/resources.rs
index 4de5dcd..7a21d4e 100644
--- a/src/resources.rs
+++ b/src/resources.rs
@@ -42,6 +42,66 @@ impl Default for FormationLayout {
         }
     }
 }
+
+// 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
+}
+
+// Resource to hold all stage configurations
+#[derive(Resource, Debug, Clone)]
+pub struct StageConfigurations {
+    pub stages: Vec<StageConfig>,
+}
+
+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
+            enemy_count: FORMATION_ENEMY_COUNT,
+            attack_patterns: vec![AttackPattern::SwoopDive],
+            attack_dive_interval: 3.0,
+            enemy_speed_multiplier: 1.0,
+            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 = 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
+        };
+
+        // Add more stages here...
+
+        StageConfigurations {
+            stages: vec![stage1, stage2], // Add more stages as needed
+        }
+    }
+}
 #[derive(Resource)]
 pub struct Score {
     pub value: u32,