From 05048e46c22764dc495f9751e21ae8ff0369d0e0 Mon Sep 17 00:00:00 2001
From: Cameron <cameron@pfiffer.org>
Date: Sun, 5 Jul 2026 21:22:23 -0700
Subject: [PATCH] Run cargo fmt across the codebase

---
 src/bin/bevy.rs           | 373 +++++++++++++++++++----------
 src/bin/terminal/input.rs |   9 +-
 src/bin/terminal/mod.rs   |  11 +-
 src/bin/terminal/ui.rs    | 489 ++++++++++++++++++++++++++++----------
 src/build.rs              |  28 ++-
 src/combat.rs             | 456 +++++++++++++++++++++++++----------
 src/entities/agent.rs     | 169 ++++++++++---
 src/entities/core.rs      |   6 +-
 src/entities/henchman.rs  |  15 +-
 src/entities/minion.rs    |  28 ++-
 src/entities/mod.rs       |  12 +-
 src/entities/player.rs    |  21 +-
 src/events.rs             |  40 +++-
 src/lib.rs                |  10 +-
 src/map.rs                |  38 ++-
 src/save.rs               | 180 ++++++++------
 src/sim.rs                |  52 +++-
 src/superpowers.rs        |  42 +++-
 src/tiles.rs              | 243 ++++++++++++++++---
 19 files changed, 1596 insertions(+), 626 deletions(-)

diff --git a/src/bin/bevy.rs b/src/bin/bevy.rs
index 5873ef6..c20ce02 100644
--- a/src/bin/bevy.rs
+++ b/src/bin/bevy.rs
@@ -4,7 +4,7 @@
 
 use bevy::prelude::*;
 use bevy::window::WindowResolution;
-use supervillain::{entities, map, tiles, combat, build};
+use supervillain::{build, combat, entities, map, tiles};
 
 // ─── Constants ───────────────────────────────────────────────────────────────
 
@@ -169,13 +169,16 @@ fn main() {
         .insert_resource(ClearColor(Color::srgb(0.02, 0.02, 0.04)))
         .insert_resource(GameState::placeholder())
         .add_systems(Startup, (setup, setup_ui))
-        .add_systems(Update, (
-            handle_input,
-            update_defend_phase,
-            render_map_tiles,
-            render_entities,
-            render_ui,
-        ))
+        .add_systems(
+            Update,
+            (
+                handle_input,
+                update_defend_phase,
+                render_map_tiles,
+                render_entities,
+                render_ui,
+            ),
+        )
         .run();
 }
 
@@ -195,14 +198,26 @@ fn setup(mut commands: Commands, mut game_state: ResMut<GameState>) {
         let mx = throne.0 + dx;
         let my = throne.1 + dy;
         if game_map.is_walkable(mx, my) {
-            minions.push(entities::Minion::new(mx, my, entities::MinionClass::Worker, 0, 0));
+            minions.push(entities::Minion::new(
+                mx,
+                my,
+                entities::MinionClass::Worker,
+                0,
+                0,
+            ));
         }
     }
 
     // Spawn minions at guard posts
     let guard_posts = game_map.tiles_of_type(tiles::TileType::GuardPost);
     for &(gx, gy) in &guard_posts {
-        minions.push(entities::Minion::new(gx, gy, entities::MinionClass::Guard, 0, 0));
+        minions.push(entities::Minion::new(
+            gx,
+            gy,
+            entities::MinionClass::Guard,
+            0,
+            0,
+        ));
     }
 
     *game_state = GameState {
@@ -349,8 +364,10 @@ fn handle_input(
         }
         // Update cursor to player position when in research menu
         if let Ok(mut transform) = cursor_query.single_mut() {
-            transform.translation.x = game_state.player.entity.x as f32 * TILE_SIZE + TILE_SIZE / 2.0;
-            transform.translation.y = -(game_state.player.entity.y as f32 * TILE_SIZE + TILE_SIZE / 2.0);
+            transform.translation.x =
+                game_state.player.entity.x as f32 * TILE_SIZE + TILE_SIZE / 2.0;
+            transform.translation.y =
+                -(game_state.player.entity.y as f32 * TILE_SIZE + TILE_SIZE / 2.0);
         }
         return;
     }
@@ -374,13 +391,20 @@ fn handle_input(
                 let class = classes[game_state.hire_selected];
                 let unlock_key = class.unlock_key();
                 if !game_state.player.unlocked.contains(unlock_key) {
-                    game_state.log.push(format!("{} not researched yet!", class.name()));
+                    game_state
+                        .log
+                        .push(format!("{} not researched yet!", class.name()));
                 } else {
                     let cost = class.hire_cost();
                     if game_state.player.gold < cost {
-                        game_state.log.push(format!("Need {} gold to hire {}!", cost, class.name()));
+                        game_state.log.push(format!(
+                            "Need {} gold to hire {}!",
+                            cost,
+                            class.name()
+                        ));
                     } else {
-                        let alive_minions = game_state.minions.iter().filter(|m| m.entity.alive).count() as i32;
+                        let alive_minions =
+                            game_state.minions.iter().filter(|m| m.entity.alive).count() as i32;
                         let minion_cap = game_state.player.minion_cap;
                         if alive_minions >= minion_cap {
                             game_state.log.push(format!(
@@ -399,17 +423,27 @@ fn handle_input(
                                         game_state.player.gold -= cost;
                                         let dmg_bonus = game_state.player.minion_damage_bonus;
                                         let hp_bonus = game_state.player.minion_hp_bonus;
-                                        let minion = entities::Minion::new(mx, my, class, dmg_bonus, hp_bonus);
+                                        let minion = entities::Minion::new(
+                                            mx, my, class, dmg_bonus, hp_bonus,
+                                        );
                                         game_state.minions.push(minion);
-                                        game_state.log.push(format!("Hired {} for {} gold!", class.name(), cost));
+                                        game_state.log.push(format!(
+                                            "Hired {} for {} gold!",
+                                            class.name(),
+                                            cost
+                                        ));
                                         placed = true;
                                         break;
                                     }
                                 }
-                                if placed { break; }
+                                if placed {
+                                    break;
+                                }
                             }
                             if !placed {
-                                game_state.log.push("No room near throne to place minion!".to_string());
+                                game_state
+                                    .log
+                                    .push("No room near throne to place minion!".to_string());
                             }
                         }
                     }
@@ -421,8 +455,10 @@ fn handle_input(
         }
         // Update cursor to player position when in hire menu
         if let Ok(mut transform) = cursor_query.single_mut() {
-            transform.translation.x = game_state.player.entity.x as f32 * TILE_SIZE + TILE_SIZE / 2.0;
-            transform.translation.y = -(game_state.player.entity.y as f32 * TILE_SIZE + TILE_SIZE / 2.0);
+            transform.translation.x =
+                game_state.player.entity.x as f32 * TILE_SIZE + TILE_SIZE / 2.0;
+            transform.translation.y =
+                -(game_state.player.entity.y as f32 * TILE_SIZE + TILE_SIZE / 2.0);
         }
         return;
     }
@@ -445,15 +481,21 @@ fn handle_input(
             let schemes = tiles::available_schemes();
             if idx < schemes.len() {
                 let scheme = &schemes[idx];
-                let alive_minions = game_state.minions.iter().filter(|m| m.entity.alive).count() as i32;
+                let alive_minions =
+                    game_state.minions.iter().filter(|m| m.entity.alive).count() as i32;
                 if alive_minions < scheme.minion_cost {
-                    game_state.log.push(format!("Need {} minions for this scheme!", scheme.minion_cost));
+                    game_state.log.push(format!(
+                        "Need {} minions for this scheme!",
+                        scheme.minion_cost
+                    ));
                 } else {
                     // Remove minions (send them on the mission)
                     let mut removed = 0i32;
                     let cost = scheme.minion_cost;
                     game_state.minions.retain(|m| {
-                        if removed >= cost { return true; }
+                        if removed >= cost {
+                            return true;
+                        }
                         if m.entity.alive && m.class == entities::MinionClass::Worker {
                             removed += 1;
                             false
@@ -463,7 +505,9 @@ fn handle_input(
                     });
                     if removed < cost {
                         game_state.minions.retain(|m| {
-                            if removed >= cost { return true; }
+                            if removed >= cost {
+                                return true;
+                            }
                             if m.entity.alive {
                                 removed += 1;
                                 false
@@ -473,16 +517,21 @@ fn handle_input(
                         });
                     }
 
-                    game_state.player.active_schemes.push(entities::ActiveScheme {
-                        name: scheme.name.to_string(),
-                        turns_remaining: scheme.duration_turns,
-                        gold_reward: scheme.gold_reward,
-                        heat_cost: scheme.heat_cost,
-                        notoriety_reward: scheme.notoriety_reward,
-                        minion_cost: scheme.minion_cost,
-                        loot: scheme.loot.map(|s| s.to_string()),
-                    });
-                    game_state.log.push(format!("Launched scheme: {}!", scheme.name));
+                    game_state
+                        .player
+                        .active_schemes
+                        .push(entities::ActiveScheme {
+                            name: scheme.name.to_string(),
+                            turns_remaining: scheme.duration_turns,
+                            gold_reward: scheme.gold_reward,
+                            heat_cost: scheme.heat_cost,
+                            notoriety_reward: scheme.notoriety_reward,
+                            minion_cost: scheme.minion_cost,
+                            loot: scheme.loot.map(|s| s.to_string()),
+                        });
+                    game_state
+                        .log
+                        .push(format!("Launched scheme: {}!", scheme.name));
                     game_state.log.push(format!(
                         "  {} minions deployed, {} turns",
                         scheme.minion_cost, scheme.duration_turns
@@ -496,15 +545,21 @@ fn handle_input(
         }
         // Update cursor to player position when in world map
         if let Ok(mut transform) = cursor_query.single_mut() {
-            transform.translation.x = game_state.player.entity.x as f32 * TILE_SIZE + TILE_SIZE / 2.0;
-            transform.translation.y = -(game_state.player.entity.y as f32 * TILE_SIZE + TILE_SIZE / 2.0);
+            transform.translation.x =
+                game_state.player.entity.x as f32 * TILE_SIZE + TILE_SIZE / 2.0;
+            transform.translation.y =
+                -(game_state.player.entity.y as f32 * TILE_SIZE + TILE_SIZE / 2.0);
         }
         return;
     }
 
     // ── Build mode ─────────────────────────────────────────────────────────
     if game_state.build_mode.is_some() {
-        let speed = if keyboard.pressed(KeyCode::ShiftLeft) { 2 } else { 1 };
+        let speed = if keyboard.pressed(KeyCode::ShiftLeft) {
+            2
+        } else {
+            1
+        };
 
         // Cursor movement in build mode — take build_mode out, move, put back
         if keyboard.just_pressed(KeyCode::KeyH)
@@ -517,11 +572,17 @@ fn handle_input(
             || keyboard.just_pressed(KeyCode::ArrowDown)
         {
             let mut bm = game_state.build_mode.take().unwrap();
-            let (dx, dy) = if keyboard.just_pressed(KeyCode::KeyH) || keyboard.just_pressed(KeyCode::ArrowLeft) {
+            let (dx, dy) = if keyboard.just_pressed(KeyCode::KeyH)
+                || keyboard.just_pressed(KeyCode::ArrowLeft)
+            {
                 (-speed, 0)
-            } else if keyboard.just_pressed(KeyCode::KeyL) || keyboard.just_pressed(KeyCode::ArrowRight) {
+            } else if keyboard.just_pressed(KeyCode::KeyL)
+                || keyboard.just_pressed(KeyCode::ArrowRight)
+            {
                 (speed, 0)
-            } else if keyboard.just_pressed(KeyCode::KeyK) || keyboard.just_pressed(KeyCode::ArrowUp) {
+            } else if keyboard.just_pressed(KeyCode::KeyK)
+                || keyboard.just_pressed(KeyCode::ArrowUp)
+            {
                 (0, -speed)
             } else {
                 (0, speed)
@@ -581,7 +642,13 @@ fn handle_input(
                     if alive_minions < minion_cap {
                         let dmg_bonus = player.minion_damage_bonus;
                         let hp_bonus = player.minion_hp_bonus;
-                        let minion = entities::Minion::new(cx, cy, entities::MinionClass::Guard, dmg_bonus, hp_bonus);
+                        let minion = entities::Minion::new(
+                            cx,
+                            cy,
+                            entities::MinionClass::Guard,
+                            dmg_bonus,
+                            hp_bonus,
+                        );
                         minions.push(minion);
                         log.push("Minion deployed at guard post!".to_string());
                     } else {
@@ -639,7 +706,11 @@ fn handle_input(
     }
 
     // ── Normal Build phase movement ───────────────────────────────────────
-    let speed = if keyboard.pressed(KeyCode::ShiftLeft) { 2 } else { 1 };
+    let speed = if keyboard.pressed(KeyCode::ShiftLeft) {
+        2
+    } else {
+        1
+    };
 
     if keyboard.just_pressed(KeyCode::KeyH) || keyboard.just_pressed(KeyCode::ArrowLeft) {
         game_state.player.entity.x -= speed;
@@ -722,9 +793,15 @@ fn handle_input(
 
         // Superpower activation (number keys 1-9)
         let power_keys = [
-            KeyCode::Digit1, KeyCode::Digit2, KeyCode::Digit3,
-            KeyCode::Digit4, KeyCode::Digit5, KeyCode::Digit6,
-            KeyCode::Digit7, KeyCode::Digit8, KeyCode::Digit9,
+            KeyCode::Digit1,
+            KeyCode::Digit2,
+            KeyCode::Digit3,
+            KeyCode::Digit4,
+            KeyCode::Digit5,
+            KeyCode::Digit6,
+            KeyCode::Digit7,
+            KeyCode::Digit8,
+            KeyCode::Digit9,
         ];
         for (i, key) in power_keys.iter().enumerate() {
             if keyboard.just_pressed(*key) {
@@ -736,7 +813,8 @@ fn handle_input(
     // Update cursor position to follow player (when not in build mode)
     if let Ok(mut transform) = cursor_query.single_mut() {
         transform.translation.x = game_state.player.entity.x as f32 * TILE_SIZE + TILE_SIZE / 2.0;
-        transform.translation.y = -(game_state.player.entity.y as f32 * TILE_SIZE + TILE_SIZE / 2.0);
+        transform.translation.y =
+            -(game_state.player.entity.y as f32 * TILE_SIZE + TILE_SIZE / 2.0);
     }
 }
 
@@ -750,21 +828,19 @@ fn start_wave(game_state: &mut ResMut<GameState>) {
 
     let entries = gs.game_map.entry_positions();
     let heat = gs.player.heat;
-    let new_agents = entities::generate_agent_wave(
-        wave,
-        heat,
-        &entries,
-    );
+    let new_agents = entities::generate_agent_wave(wave, heat, &entries);
     gs.agents = new_agents;
 
     // Calculate initial paths — collect positions first, then iterate mutably
     let throne = gs.game_map.throne_pos().unwrap_or((40, 20));
-    let agent_positions: Vec<(i32, i32)> = gs.agents.iter().map(|a| (a.entity.x, a.entity.y)).collect();
+    let agent_positions: Vec<(i32, i32)> =
+        gs.agents.iter().map(|a| (a.entity.x, a.entity.y)).collect();
     let game_map = &gs.game_map;
     for (i, agent) in gs.agents.iter_mut().enumerate() {
         let target = agent.preferred_target(game_map, throne);
         let avoid: std::collections::HashSet<(i32, i32)> = agent_positions
-            .iter().enumerate()
+            .iter()
+            .enumerate()
             .filter(|(j, _)| *j != i)
             .map(|(_, pos)| *pos)
             .collect();
@@ -776,9 +852,14 @@ fn start_wave(game_state: &mut ResMut<GameState>) {
 
 fn activate_power(game_state: &mut ResMut<GameState>, index: usize) {
     let gs = &mut **game_state;
-    if index >= gs.player.powers.len() { return; }
+    if index >= gs.player.powers.len() {
+        return;
+    }
     if !gs.player.powers[index].is_ready() {
-        gs.log.push(format!("{} is on cooldown ({}t)", gs.player.powers[index].name, gs.player.powers[index].current_cooldown));
+        gs.log.push(format!(
+            "{} is on cooldown ({}t)",
+            gs.player.powers[index].name, gs.player.powers[index].current_cooldown
+        ));
         return;
     }
 
@@ -806,10 +887,7 @@ fn activate_power(game_state: &mut ResMut<GameState>, index: usize) {
 
 // ─── Defend Phase ────────────────────────────────────────────────────────────
 
-fn update_defend_phase(
-    time: Res<Time>,
-    mut game_state: ResMut<GameState>,
-) {
+fn update_defend_phase(time: Res<Time>, mut game_state: ResMut<GameState>) {
     if game_state.phase != Phase::Defend || game_state.defend_paused {
         return;
     }
@@ -843,14 +921,8 @@ fn update_defend_phase(
         } = &mut *game_state;
 
         // Process agent turn
-        let player_died = combat.process_agent_turn(
-            game_map,
-            player,
-            agents,
-            minions,
-            henchmen,
-            throne,
-        );
+        let player_died =
+            combat.process_agent_turn(game_map, player, agents, minions, henchmen, throne);
 
         // Apply kill events
         for kill in combat.kill_events.clone() {
@@ -894,15 +966,11 @@ fn update_defend_phase(
         player.tick_power_cooldowns();
 
         // Check for mid-wave events
-        if let Some(event_type) = supervillain::events::check_for_event(current_wave, current_turn) {
+        if let Some(event_type) = supervillain::events::check_for_event(current_wave, current_turn)
+        {
             let entries = game_map.entry_positions();
             let event = supervillain::events::process_event(
-                event_type,
-                player,
-                agents,
-                minions,
-                game_map,
-                &entries,
+                event_type, player, agents, minions, game_map, &entries,
             );
             log.push(format!("⚡ EVENT: {}", event.name));
             log.push(event.description);
@@ -955,7 +1023,10 @@ fn tick_schemes(game_state: &mut ResMut<GameState>) {
         gs.player.add_heat(scheme.heat_cost);
         gs.player.add_notoriety(scheme.notoriety_reward);
         let loot = scheme.loot.clone();
-        gs.log.push(format!("Scheme '{}' completed! +{} gold", scheme.name, scheme.gold_reward));
+        gs.log.push(format!(
+            "Scheme '{}' completed! +{} gold",
+            scheme.name, scheme.gold_reward
+        ));
         if let Some(loot_item) = loot {
             gs.player.loot.push(loot_item);
         }
@@ -971,7 +1042,8 @@ fn update_resources(game_state: &mut ResMut<GameState>) {
     let mut research_gen = 0i32;
 
     for &(_x, _y) in &cores {
-        power_gen += tiles::TileType::PowerCore.power_gen(gs.player.power_core_mk2) + gs.player.power_bonus;
+        power_gen +=
+            tiles::TileType::PowerCore.power_gen(gs.player.power_core_mk2) + gs.player.power_bonus;
     }
 
     for y in 0..gs.game_map.height {
@@ -987,7 +1059,9 @@ fn update_resources(game_state: &mut ResMut<GameState>) {
         research_gen += minion.research_bonus();
     }
 
-    let worker_count = gs.minions.iter()
+    let worker_count = gs
+        .minions
+        .iter()
         .filter(|m| m.entity.alive && m.class == entities::MinionClass::Worker)
         .count() as i32;
     let vault_count = gs.game_map.tiles_of_type(tiles::TileType::Vault).len() as i32;
@@ -1012,7 +1086,11 @@ fn render_map_tiles(
             let mut color = tile_color(tile);
 
             // Powered glow: brighten tiles that are powered
-            if game_state.game_map.powered.contains(&(tile_pos.x, tile_pos.y)) {
+            if game_state
+                .game_map
+                .powered
+                .contains(&(tile_pos.x, tile_pos.y))
+            {
                 color = brighten(color, 0.08);
             }
 
@@ -1041,7 +1119,9 @@ fn render_entities(
 
     // Spawn minions
     for minion in &game_state.minions {
-        if !minion.entity.alive { continue; }
+        if !minion.entity.alive {
+            continue;
+        }
         let color = match minion.class {
             entities::MinionClass::Worker => Color::srgb(0.8, 0.8, 0.2),
             entities::MinionClass::Guard => Color::srgb(0.8, 0.3, 0.1),
@@ -1061,7 +1141,9 @@ fn render_entities(
 
     // Spawn agents
     for agent in &game_state.agents {
-        if !agent.entity.alive { continue; }
+        if !agent.entity.alive {
+            continue;
+        }
         let color = Color::srgb(0.9, 0.2, 0.2);
         commands.spawn((
             Sprite::from_color(color, Vec2::splat(TILE_SIZE * 0.8)),
@@ -1076,7 +1158,9 @@ fn render_entities(
 
     // Spawn henchmen
     for henchman in &game_state.henchmen {
-        if !henchman.entity.alive { continue; }
+        if !henchman.entity.alive {
+            continue;
+        }
         commands.spawn((
             Sprite::from_color(Color::srgb(0.8, 0.2, 0.8), Vec2::splat(TILE_SIZE * 0.9)),
             Transform::from_translation(Vec3::new(
@@ -1097,49 +1181,48 @@ struct UiText;
 
 fn setup_ui(mut commands: Commands) {
     // Root UI node — right sidebar
-    commands.spawn((
-        Node {
-            position_type: PositionType::Absolute,
-            right: Val::Px(0.0),
-            top: Val::Px(0.0),
-            width: Val::Px(SIDEBAR_WIDTH),
-            height: Val::Percent(100.0),
-            flex_direction: FlexDirection::Column,
-            padding: UiRect::all(Val::Px(10.0)),
-            ..default()
-        },
-        BackgroundColor(Color::srgba(0.0, 0.0, 0.05, 0.85)),
-        UiRoot,
-    )).with_children(|parent| {
-        parent.spawn((
-            Text::new("SUPERVILLAIN"),
-            TextFont {
-                font_size: 24.0,
-                ..default()
-            },
-            TextColor(Color::srgb(0.8, 0.2, 0.8)),
+    commands
+        .spawn((
             Node {
-                margin: UiRect::bottom(Val::Px(10.0)),
+                position_type: PositionType::Absolute,
+                right: Val::Px(0.0),
+                top: Val::Px(0.0),
+                width: Val::Px(SIDEBAR_WIDTH),
+                height: Val::Percent(100.0),
+                flex_direction: FlexDirection::Column,
+                padding: UiRect::all(Val::Px(10.0)),
                 ..default()
             },
-        ));
+            BackgroundColor(Color::srgba(0.0, 0.0, 0.05, 0.85)),
+            UiRoot,
+        ))
+        .with_children(|parent| {
+            parent.spawn((
+                Text::new("SUPERVILLAIN"),
+                TextFont {
+                    font_size: 24.0,
+                    ..default()
+                },
+                TextColor(Color::srgb(0.8, 0.2, 0.8)),
+                Node {
+                    margin: UiRect::bottom(Val::Px(10.0)),
+                    ..default()
+                },
+            ));
 
-        parent.spawn((
-            Text::new("Loading..."),
-            TextFont {
-                font_size: 14.0,
-                ..default()
-            },
-            TextColor(Color::srgb(0.8, 0.8, 0.8)),
-            UiText,
-        ));
-    });
+            parent.spawn((
+                Text::new("Loading..."),
+                TextFont {
+                    font_size: 14.0,
+                    ..default()
+                },
+                TextColor(Color::srgb(0.8, 0.8, 0.8)),
+                UiText,
+            ));
+        });
 }
 
-fn render_ui(
-    game_state: Res<GameState>,
-    mut query: Query<&mut Text, With<UiText>>,
-) {
+fn render_ui(game_state: Res<GameState>, mut query: Query<&mut Text, With<UiText>>) {
     if game_state.is_changed() {
         let gs = &*game_state;
         let phase_name = match gs.phase {
@@ -1152,10 +1235,26 @@ fn render_ui(
 
         let alive_minions = gs.minions.iter().filter(|m| m.entity.alive).count();
         let alive_agents = gs.agents.iter().filter(|a| a.entity.alive).count();
-        let workers = gs.minions.iter().filter(|m| m.entity.alive && m.class == entities::MinionClass::Worker).count();
-        let guards = gs.minions.iter().filter(|m| m.entity.alive && m.class == entities::MinionClass::Guard).count();
-        let techs = gs.minions.iter().filter(|m| m.entity.alive && m.class == entities::MinionClass::Technician).count();
-        let scis = gs.minions.iter().filter(|m| m.entity.alive && m.class == entities::MinionClass::Scientist).count();
+        let workers = gs
+            .minions
+            .iter()
+            .filter(|m| m.entity.alive && m.class == entities::MinionClass::Worker)
+            .count();
+        let guards = gs
+            .minions
+            .iter()
+            .filter(|m| m.entity.alive && m.class == entities::MinionClass::Guard)
+            .count();
+        let techs = gs
+            .minions
+            .iter()
+            .filter(|m| m.entity.alive && m.class == entities::MinionClass::Technician)
+            .count();
+        let scis = gs
+            .minions
+            .iter()
+            .filter(|m| m.entity.alive && m.class == entities::MinionClass::Scientist)
+            .count();
 
         let mut text = format!(
             "Phase: {phase_name}\n\
@@ -1254,7 +1353,10 @@ fn render_ui(
             // Hire menu contextual help
             let classes = entities::MinionClass::all();
             text.push_str("HIRE MINIONS\n");
-            text.push_str(&format!("Gold: {}  Cap: {}/{}\n", gs.player.gold, alive_minions, gs.player.minion_cap));
+            text.push_str(&format!(
+                "Gold: {}  Cap: {}/{}\n",
+                gs.player.gold, alive_minions, gs.player.minion_cap
+            ));
             for (i, &class) in classes.iter().enumerate() {
                 let cost = class.hire_cost();
                 let key = class.unlock_key();
@@ -1262,7 +1364,11 @@ fn render_ui(
                 let affordable = gs.player.gold >= cost;
                 let prefix = if i == gs.hire_selected { ">" } else { " " };
                 if !unlocked {
-                    text.push_str(&format!("{prefix} [LOCKED] {} (need {})\n", class.name(), key));
+                    text.push_str(&format!(
+                        "{prefix} [LOCKED] {} (need {})\n",
+                        class.name(),
+                        key
+                    ));
                 } else if affordable {
                     text.push_str(&format!("{prefix} {} ({}g)\n", class.name(), cost));
                 } else {
@@ -1276,14 +1382,20 @@ fn render_ui(
             // World map contextual help
             let schemes = tiles::available_schemes();
             text.push_str("WORLD MAP - EVIL SCHEMES\n");
-            text.push_str(&format!("Gold: {}  Heat: {}  Notoriety: {}\n", gs.player.gold, gs.player.heat, gs.player.notoriety));
+            text.push_str(&format!(
+                "Gold: {}  Heat: {}  Notoriety: {}\n",
+                gs.player.gold, gs.player.heat, gs.player.notoriety
+            ));
             for (i, scheme) in schemes.iter().enumerate() {
                 let prefix = if i == gs.world_map_selected { ">" } else { " " };
                 text.push_str(&format!("{prefix} {} [{}]\n", scheme.name, scheme.region));
                 if i == gs.world_map_selected {
                     text.push_str(&format!(
                         "   Gold:{} Heat:+{} Minions:{} Turns:{}\n",
-                        scheme.gold_reward, scheme.heat_cost, scheme.minion_cost, scheme.duration_turns
+                        scheme.gold_reward,
+                        scheme.heat_cost,
+                        scheme.minion_cost,
+                        scheme.duration_turns
                     ));
                 }
             }
@@ -1298,7 +1410,12 @@ fn render_ui(
                     if power.is_ready() {
                         text.push_str(&format!("[{}] {} READY\n", i + 1, power.name));
                     } else {
-                        text.push_str(&format!("[{}] {} ({}t)\n", i + 1, power.name, power.current_cooldown));
+                        text.push_str(&format!(
+                            "[{}] {} ({}t)\n",
+                            i + 1,
+                            power.name,
+                            power.current_cooldown
+                        ));
                     }
                 }
                 if gs.player.is_invulnerable() {
diff --git a/src/bin/terminal/input.rs b/src/bin/terminal/input.rs
index c1762cc..4bd0910 100644
--- a/src/bin/terminal/input.rs
+++ b/src/bin/terminal/input.rs
@@ -110,7 +110,10 @@ pub fn handle_key(
     }
 
     // Save/load with Ctrl
-    if key.modifiers.contains(crossterm::event::KeyModifiers::CONTROL) {
+    if key
+        .modifiers
+        .contains(crossterm::event::KeyModifiers::CONTROL)
+    {
         return match key.code {
             KeyCode::Char('s') => Some(Command::SaveGame),
             KeyCode::Char('l') => Some(Command::LoadGame),
@@ -132,9 +135,7 @@ pub fn handle_key(
         KeyCode::Char(' ') | KeyCode::Char('p') => Some(Command::TogglePause),
         KeyCode::Char('+') | KeyCode::Char('=') => Some(Command::SpeedUp),
         KeyCode::Char('-') => Some(Command::SpeedDown),
-        KeyCode::Char(c @ '1'..='9') => {
-            Some(Command::ActivatePower(c as usize - '1' as usize))
-        }
+        KeyCode::Char(c @ '1'..='9') => Some(Command::ActivatePower(c as usize - '1' as usize)),
         KeyCode::Char('q') => Some(Command::Quit),
         _ => Some(Command::AnyKey),
     }
diff --git a/src/bin/terminal/mod.rs b/src/bin/terminal/mod.rs
index fdcb971..bb84c74 100644
--- a/src/bin/terminal/mod.rs
+++ b/src/bin/terminal/mod.rs
@@ -103,8 +103,11 @@ impl App {
             // Time controls
             Command::TogglePause => {
                 self.paused = !self.paused;
-                self.ui
-                    .add_log(if self.paused { "TIME PAUSED" } else { "Time resumes." });
+                self.ui.add_log(if self.paused {
+                    "TIME PAUSED"
+                } else {
+                    "Time resumes."
+                });
                 self.last_tick = Instant::now();
             }
             Command::SpeedUp => {
@@ -236,7 +239,9 @@ impl App {
     }
 
     fn place_build_tile(&mut self) {
-        let Some(bm) = &mut self.build_mode else { return };
+        let Some(bm) = &mut self.build_mode else {
+            return;
+        };
         let result = bm.place_tile(&mut self.sim.map, &mut self.sim.player);
         let msg = bm.message.clone();
         let (cx, cy) = (bm.cursor_x, bm.cursor_y);
diff --git a/src/bin/terminal/ui.rs b/src/bin/terminal/ui.rs
index 1c34268..023d927 100644
--- a/src/bin/terminal/ui.rs
+++ b/src/bin/terminal/ui.rs
@@ -1,8 +1,7 @@
 use std::io::Write;
 
 use crossterm::{
-    cursor,
-    queue,
+    cursor, queue,
     style::{self, Attribute, Color, SetBackgroundColor, SetForegroundColor},
     terminal::{self, ClearType},
 };
@@ -79,23 +78,31 @@ impl UI {
                     color = Color::DarkGrey;
                 }
 
-                let is_cursor = build_mode.is_some_and(|bm| {
-                    mx == bm.cursor_x && my == bm.cursor_y
-                });
+                let is_cursor = build_mode.is_some_and(|bm| mx == bm.cursor_x && my == bm.cursor_y);
 
                 queue!(
                     stdout,
                     cursor::MoveTo(vx as u16, vy as u16),
                     SetForegroundColor(if is_cursor { Color::White } else { color }),
-                    SetBackgroundColor(if is_cursor { Color::DarkBlue } else { Color::Black }),
-                    style::Print(if is_cursor && ch == ' ' { '\u{2588}' } else { ch }),
+                    SetBackgroundColor(if is_cursor {
+                        Color::DarkBlue
+                    } else {
+                        Color::Black
+                    }),
+                    style::Print(if is_cursor && ch == ' ' {
+                        '\u{2588}'
+                    } else {
+                        ch
+                    }),
                 )?;
             }
         }
 
         // Render minions
         for minion in minions {
-            if !minion.entity.alive { continue; }
+            if !minion.entity.alive {
+                continue;
+            }
             let sx = minion.entity.x - self.viewport_x;
             let sy = minion.entity.y - self.viewport_y;
             if sx >= 0 && sx < view_w && sy >= 0 && sy < view_h {
@@ -111,7 +118,9 @@ impl UI {
 
         // Render henchmen
         for henchman in henchmen {
-            if !henchman.entity.alive { continue; }
+            if !henchman.entity.alive {
+                continue;
+            }
             let sx = henchman.entity.x - self.viewport_x;
             let sy = henchman.entity.y - self.viewport_y;
             if sx >= 0 && sx < view_w && sy >= 0 && sy < view_h {
@@ -127,7 +136,9 @@ impl UI {
 
         // Render agents
         for agent in agents {
-            if !agent.entity.alive { continue; }
+            if !agent.entity.alive {
+                continue;
+            }
             let sx = agent.entity.x - self.viewport_x;
             let sy = agent.entity.y - self.viewport_y;
             if sx >= 0 && sx < view_w && sy >= 0 && sy < view_h {
@@ -188,8 +199,17 @@ impl UI {
         }
 
         let mut row: i32 = 0;
-        let write = |stdout: &mut std::io::Stdout, row: &mut i32, text: &str, color: Color, bold: bool| -> std::io::Result<()> {
-            let attr = if bold { Attribute::Bold } else { Attribute::Reset };
+        let write = |stdout: &mut std::io::Stdout,
+                     row: &mut i32,
+                     text: &str,
+                     color: Color,
+                     bold: bool|
+         -> std::io::Result<()> {
+            let attr = if bold {
+                Attribute::Bold
+            } else {
+                Attribute::Reset
+            };
             queue!(
                 stdout,
                 cursor::MoveTo(sidebar_x as u16, *row as u16),
@@ -205,7 +225,11 @@ impl UI {
 
         write(stdout, &mut row, "EVIL GENIUS", Color::Magenta, true)?;
         row += 1;
-        let status_color = if status.contains("PAUSED") { Color::DarkGrey } else { Color::Yellow };
+        let status_color = if status.contains("PAUSED") {
+            Color::DarkGrey
+        } else {
+            Color::Yellow
+        };
         write(stdout, &mut row, status, status_color, true)?;
         let threat_color = if threat.starts_with("RAID") {
             Color::Red
@@ -218,17 +242,65 @@ impl UI {
         row += 1;
 
         write(stdout, &mut row, "--- Resources ---", Color::Yellow, false)?;
-        write(stdout, &mut row, &format!("Gold:     {} (+{})", player.gold, player.gold_income), Color::Yellow, false)?;
-        write(stdout, &mut row, &format!("Power:    {}/{}", player.power, player.power_cap), Color::Cyan, false)?;
-        write(stdout, &mut row, &format!("Research: {}", player.research), Color::Blue, false)?;
+        write(
+            stdout,
+            &mut row,
+            &format!("Gold:     {} (+{})", player.gold, player.gold_income),
+            Color::Yellow,
+            false,
+        )?;
+        write(
+            stdout,
+            &mut row,
+            &format!("Power:    {}/{}", player.power, player.power_cap),
+            Color::Cyan,
+            false,
+        )?;
+        write(
+            stdout,
+            &mut row,
+            &format!("Research: {}", player.research),
+            Color::Blue,
+            false,
+        )?;
         row += 1;
 
-        write(stdout, &mut row, "--- Supervillain ---", Color::Yellow, false)?;
-        write(stdout, &mut row, &format!("HP: {}/{}", player.entity.hp, player.entity.max_hp), Color::Magenta, false)?;
+        write(
+            stdout,
+            &mut row,
+            "--- Supervillain ---",
+            Color::Yellow,
+            false,
+        )?;
+        write(
+            stdout,
+            &mut row,
+            &format!("HP: {}/{}", player.entity.hp, player.entity.max_hp),
+            Color::Magenta,
+            false,
+        )?;
         // Heat bar
-        let heat_color = if player.heat >= 60 { Color::Red } else if player.heat >= 30 { Color::Yellow } else { Color::Green };
-        write(stdout, &mut row, &format!("Heat:     {}", player.heat), heat_color, false)?;
-        write(stdout, &mut row, &format!("Notoriety:{}", player.notoriety), Color::Magenta, false)?;
+        let heat_color = if player.heat >= 60 {
+            Color::Red
+        } else if player.heat >= 30 {
+            Color::Yellow
+        } else {
+            Color::Green
+        };
+        write(
+            stdout,
+            &mut row,
+            &format!("Heat:     {}", player.heat),
+            heat_color,
+            false,
+        )?;
+        write(
+            stdout,
+            &mut row,
+            &format!("Notoriety:{}", player.notoriety),
+            Color::Magenta,
+            false,
+        )?;
         row += 1;
 
         let alive_minions = minions.iter().filter(|m| m.entity.alive).count();
@@ -236,32 +308,91 @@ impl UI {
         let alive_henchmen = henchmen.iter().filter(|h| h.entity.alive).count();
 
         write(stdout, &mut row, "--- Forces ---", Color::Yellow, false)?;
-        write(stdout, &mut row, &format!("Minions: {}/{}", alive_minions, player.minion_cap), Color::Cyan, false)?;
+        write(
+            stdout,
+            &mut row,
+            &format!("Minions: {}/{}", alive_minions, player.minion_cap),
+            Color::Cyan,
+            false,
+        )?;
 
         // Minion class breakdown
-        let workers = minions.iter().filter(|m| m.entity.alive && m.class == supervillain::entities::MinionClass::Worker).count();
-        let guards = minions.iter().filter(|m| m.entity.alive && m.class == supervillain::entities::MinionClass::Guard).count();
-        let techs = minions.iter().filter(|m| m.entity.alive && m.class == supervillain::entities::MinionClass::Technician).count();
-        let scis = minions.iter().filter(|m| m.entity.alive && m.class == supervillain::entities::MinionClass::Scientist).count();
-        write(stdout, &mut row, &format!(" W:{workers} G:{guards} T:{techs} S:{scis}"), Color::DarkGrey, false)?;
+        let workers = minions
+            .iter()
+            .filter(|m| m.entity.alive && m.class == supervillain::entities::MinionClass::Worker)
+            .count();
+        let guards = minions
+            .iter()
+            .filter(|m| m.entity.alive && m.class == supervillain::entities::MinionClass::Guard)
+            .count();
+        let techs = minions
+            .iter()
+            .filter(|m| {
+                m.entity.alive && m.class == supervillain::entities::MinionClass::Technician
+            })
+            .count();
+        let scis = minions
+            .iter()
+            .filter(|m| m.entity.alive && m.class == supervillain::entities::MinionClass::Scientist)
+            .count();
+        write(
+            stdout,
+            &mut row,
+            &format!(" W:{workers} G:{guards} T:{techs} S:{scis}"),
+            Color::DarkGrey,
+            false,
+        )?;
 
-        write(stdout, &mut row, &format!("Henchmen: {alive_henchmen}"), Color::Magenta, false)?;
-        write(stdout, &mut row, &format!("Agents:   {alive_agents}"), Color::Red, false)?;
-        write(stdout, &mut row, &format!("Kills: {}  Score: {}", player.kills, player.score), Color::White, false)?;
+        write(
+            stdout,
+            &mut row,
+            &format!("Henchmen: {alive_henchmen}"),
+            Color::Magenta,
+            false,
+        )?;
+        write(
+            stdout,
+            &mut row,
+            &format!("Agents:   {alive_agents}"),
+            Color::Red,
+            false,
+        )?;
+        write(
+            stdout,
+            &mut row,
+            &format!("Kills: {}  Score: {}", player.kills, player.score),
+            Color::White,
+            false,
+        )?;
 
         // Henchmen details
         for h in henchmen {
-            if !h.entity.alive { continue; }
+            if !h.entity.alive {
+                continue;
+            }
             let ability_name = match h.special {
                 supervillain::entities::HenchmanAbility::Barrage => "Barrage",
                 supervillain::entities::HenchmanAbility::Shield => "Shield",
                 supervillain::entities::HenchmanAbility::Intimidate => "Intimidate",
                 supervillain::entities::HenchmanAbility::Sabotage => "Sabotage",
             };
-            let cd = if h.cooldown > 0 { format!("({})", h.cooldown) } else { "RDY".to_string() };
-            let cd_color = if h.cooldown > 0 { Color::DarkGrey } else { Color::Green };
-            write(stdout, &mut row, &format!("  {} HP:{} {}",
-                h.entity.name, h.entity.hp, ability_name), Color::Magenta, false)?;
+            let cd = if h.cooldown > 0 {
+                format!("({})", h.cooldown)
+            } else {
+                "RDY".to_string()
+            };
+            let cd_color = if h.cooldown > 0 {
+                Color::DarkGrey
+            } else {
+                Color::Green
+            };
+            write(
+                stdout,
+                &mut row,
+                &format!("  {} HP:{} {}", h.entity.name, h.entity.hp, ability_name),
+                Color::Magenta,
+                false,
+            )?;
             write(stdout, &mut row, &cd, cd_color, false)?;
         }
         row += 1;
@@ -275,20 +406,42 @@ impl UI {
                 } else {
                     format!("[{}] {} ({}t)", i + 1, power.name, power.current_cooldown)
                 };
-                let color = if power.is_ready() { Color::Magenta } else { Color::DarkGrey };
+                let color = if power.is_ready() {
+                    Color::Magenta
+                } else {
+                    Color::DarkGrey
+                };
                 write(stdout, &mut row, &status, color, false)?;
             }
             if player.is_invulnerable() {
-                write(stdout, &mut row, &format!("SHIELD: {}t", player.invulnerability_turns), Color::Cyan, false)?;
+                write(
+                    stdout,
+                    &mut row,
+                    &format!("SHIELD: {}t", player.invulnerability_turns),
+                    Color::Cyan,
+                    false,
+                )?;
             }
             row += 1;
         }
 
         // Active schemes
         if !player.active_schemes.is_empty() {
-            write(stdout, &mut row, "--- Schemes ---", Color::DarkYellow, false)?;
+            write(
+                stdout,
+                &mut row,
+                "--- Schemes ---",
+                Color::DarkYellow,
+                false,
+            )?;
             for scheme in &player.active_schemes {
-                write(stdout, &mut row, &format!("{} ({}t)", scheme.name, scheme.turns_remaining), Color::DarkYellow, false)?;
+                write(
+                    stdout,
+                    &mut row,
+                    &format!("{} ({}t)", scheme.name, scheme.turns_remaining),
+                    Color::DarkYellow,
+                    false,
+                )?;
             }
             row += 1;
         }
@@ -297,23 +450,53 @@ impl UI {
         if !player.loot.is_empty() {
             write(stdout, &mut row, "--- Loot ---", Color::DarkYellow, false)?;
             for loot_name in &player.loot {
-                write(stdout, &mut row, &format!("* {loot_name}"), Color::Yellow, false)?;
+                write(
+                    stdout,
+                    &mut row,
+                    &format!("* {loot_name}"),
+                    Color::Yellow,
+                    false,
+                )?;
             }
             row += 1;
         }
 
         if let Some(bm) = build_mode {
             write(stdout, &mut row, "--- Build Mode ---", Color::Green, true)?;
-            write(stdout, &mut row, &format!("Cursor: ({},{})", bm.cursor_x, bm.cursor_y), Color::White, false)?;
-            write(stdout, &mut row, &bm.get_build_info(player), Color::Green, false)?;
+            write(
+                stdout,
+                &mut row,
+                &format!("Cursor: ({},{})", bm.cursor_x, bm.cursor_y),
+                Color::White,
+                false,
+            )?;
+            write(
+                stdout,
+                &mut row,
+                &bm.get_build_info(player),
+                Color::Green,
+                false,
+            )?;
             // Show what's currently at the cursor position
             let cursor_tile = game_map.get_tile(bm.cursor_x, bm.cursor_y);
             let powered = game_map.powered.contains(&(bm.cursor_x, bm.cursor_y));
             let power_str = if powered { " [ON]" } else { "" };
-            write(stdout, &mut row, &format!("Tile: {}{}", cursor_tile.name(), power_str), Color::DarkGrey, false)?;
+            write(
+                stdout,
+                &mut row,
+                &format!("Tile: {}{}", cursor_tile.name(), power_str),
+                Color::DarkGrey,
+                false,
+            )?;
             row += 1;
 
-            write(stdout, &mut row, "TAB: cycle category", Color::DarkGrey, false)?;
+            write(
+                stdout,
+                &mut row,
+                "TAB: cycle category",
+                Color::DarkGrey,
+                false,
+            )?;
             write(stdout, &mut row, "n/p: cycle item", Color::DarkGrey, false)?;
             write(stdout, &mut row, "SPACE: place", Color::DarkGrey, false)?;
             write(stdout, &mut row, "x: demolish", Color::DarkGrey, false)?;
@@ -326,9 +509,21 @@ impl UI {
             write(stdout, &mut row, "r: research", Color::DarkGrey, false)?;
             write(stdout, &mut row, "f: hire minions", Color::DarkGrey, false)?;
             write(stdout, &mut row, "m: world map", Color::DarkGrey, false)?;
-            write(stdout, &mut row, "SPACE/p: pause  +/-: speed", Color::DarkGrey, false)?;
+            write(
+                stdout,
+                &mut row,
+                "SPACE/p: pause  +/-: speed",
+                Color::DarkGrey,
+                false,
+            )?;
             write(stdout, &mut row, "1-9: powers", Color::DarkGrey, false)?;
-            write(stdout, &mut row, "Ctrl+S: save  Ctrl+L: load", Color::DarkGrey, false)?;
+            write(
+                stdout,
+                &mut row,
+                "Ctrl+S: save  Ctrl+L: load",
+                Color::DarkGrey,
+                false,
+            )?;
             write(stdout, &mut row, "q: quit", Color::DarkGrey, false)?;
         }
 
@@ -379,8 +574,8 @@ impl UI {
 
         for y in oy..oy + overlay_h {
             for x in ox..ox + overlay_w {
-                let is_border = y == oy || y == oy + overlay_h - 1
-                    || x == ox || x == ox + overlay_w - 1;
+                let is_border =
+                    y == oy || y == oy + overlay_h - 1 || x == ox || x == ox + overlay_w - 1;
                 if is_border {
                     queue!(
                         stdout,
@@ -475,13 +670,21 @@ impl UI {
         // Draw border
         for y in oy..oy + overlay_h {
             for x in ox..ox + overlay_w {
-                let is_border = y == oy || y == oy + overlay_h - 1
-                    || x == ox || x == ox + overlay_w - 1;
+                let is_border =
+                    y == oy || y == oy + overlay_h - 1 || x == ox || x == ox + overlay_w - 1;
                 queue!(
                     stdout,
                     cursor::MoveTo(x, y),
-                    SetForegroundColor(if is_border { Color::DarkCyan } else { Color::White }),
-                    SetBackgroundColor(if is_border { Color::DarkBlue } else { Color::Black }),
+                    SetForegroundColor(if is_border {
+                        Color::DarkCyan
+                    } else {
+                        Color::White
+                    }),
+                    SetBackgroundColor(if is_border {
+                        Color::DarkBlue
+                    } else {
+                        Color::Black
+                    }),
                     style::Print(' '),
                 )?;
             }
@@ -504,7 +707,10 @@ impl UI {
             cursor::MoveTo(ox + 2, oy + 2),
             SetForegroundColor(Color::Cyan),
             SetBackgroundColor(Color::Black),
-            style::Print(format!("Gold: {}  Heat: {}  Notoriety: {}", player.gold, player.heat, player.notoriety)),
+            style::Print(format!(
+                "Gold: {}  Heat: {}  Notoriety: {}",
+                player.gold, player.heat, player.notoriety
+            )),
         )?;
 
         // Active schemes
@@ -523,7 +729,15 @@ impl UI {
                     cursor::MoveTo(ox + 4, sy),
                     SetForegroundColor(Color::DarkYellow),
                     SetBackgroundColor(Color::Black),
-                    style::Print(format!("{} ({}t, {} min)", scheme.name, scheme.turns_remaining, scheme.minion_cost).chars().take(44).collect::<String>()),
+                    style::Print(
+                        format!(
+                            "{} ({}t, {} min)",
+                            scheme.name, scheme.turns_remaining, scheme.minion_cost
+                        )
+                        .chars()
+                        .take(44)
+                        .collect::<String>()
+                    ),
                 )?;
             }
         }
@@ -542,15 +756,28 @@ impl UI {
 
         for (i, scheme) in schemes.iter().enumerate() {
             let is_selected = i == selected;
-            let color = if is_selected { Color::White } else { Color::DarkGrey };
+            let color = if is_selected {
+                Color::White
+            } else {
+                Color::DarkGrey
+            };
             let prefix = if is_selected { " > " } else { "   " };
 
             queue!(
                 stdout,
                 cursor::MoveTo(ox + 2, y),
                 SetForegroundColor(color),
-                SetBackgroundColor(if is_selected { Color::DarkBlue } else { Color::Black }),
-                style::Print(format!("{}{} [{}]", prefix, scheme.name, scheme.region).chars().take(46).collect::<String>()),
+                SetBackgroundColor(if is_selected {
+                    Color::DarkBlue
+                } else {
+                    Color::Black
+                }),
+                style::Print(
+                    format!("{}{} [{}]", prefix, scheme.name, scheme.region)
+                        .chars()
+                        .take(46)
+                        .collect::<String>()
+                ),
             )?;
             y += 1;
 
@@ -560,7 +787,18 @@ impl UI {
                     cursor::MoveTo(ox + 5, y),
                     SetForegroundColor(Color::Cyan),
                     SetBackgroundColor(Color::Black),
-                    style::Print(format!("Gold:{} Heat:+{} Minions:{} Turns:{}", scheme.gold_reward, scheme.heat_cost, scheme.minion_cost, scheme.duration_turns).chars().take(44).collect::<String>()),
+                    style::Print(
+                        format!(
+                            "Gold:{} Heat:+{} Minions:{} Turns:{}",
+                            scheme.gold_reward,
+                            scheme.heat_cost,
+                            scheme.minion_cost,
+                            scheme.duration_turns
+                        )
+                        .chars()
+                        .take(44)
+                        .collect::<String>()
+                    ),
                 )?;
                 y += 1;
             }
@@ -595,13 +833,17 @@ impl UI {
         // Draw border
         for y in oy..oy + overlay_h {
             for x in ox..ox + overlay_w {
-                let is_border = y == oy || y == oy + overlay_h - 1
-                    || x == ox || x == ox + overlay_w - 1;
+                let is_border =
+                    y == oy || y == oy + overlay_h - 1 || x == ox || x == ox + overlay_w - 1;
                 queue!(
                     stdout,
                     cursor::MoveTo(x, y),
                     SetForegroundColor(if is_border { Color::Cyan } else { Color::White }),
-                    SetBackgroundColor(if is_border { Color::DarkBlue } else { Color::Black }),
+                    SetBackgroundColor(if is_border {
+                        Color::DarkBlue
+                    } else {
+                        Color::Black
+                    }),
                     style::Print(' '),
                 )?;
             }
@@ -624,7 +866,10 @@ impl UI {
             cursor::MoveTo(ox + 2, oy + 2),
             SetForegroundColor(Color::Cyan),
             SetBackgroundColor(Color::Black),
-            style::Print(format!("Gold: {}  Cap: {}/{}", player.gold, alive_minions, player.minion_cap)),
+            style::Print(format!(
+                "Gold: {}  Cap: {}/{}",
+                player.gold, alive_minions, player.minion_cap
+            )),
         )?;
 
         // Minion classes
@@ -638,7 +883,10 @@ impl UI {
             let is_selected = i == selected;
 
             let (text, color) = if !unlocked {
-                (format!("  [LOCKED] {} (need {})", class.name(), key), Color::DarkGrey)
+                (
+                    format!("  [LOCKED] {} (need {})", class.name(), key),
+                    Color::DarkGrey,
+                )
             } else if is_selected {
                 if affordable {
                     (format!(" > {} ({}g)", class.name(), cost), Color::Green)
@@ -655,7 +903,11 @@ impl UI {
                 stdout,
                 cursor::MoveTo(ox + 2, y),
                 SetForegroundColor(color),
-                SetBackgroundColor(if is_selected { Color::DarkBlue } else { Color::Black }),
+                SetBackgroundColor(if is_selected {
+                    Color::DarkBlue
+                } else {
+                    Color::Black
+                }),
                 style::Print(text.chars().take(40).collect::<String>()),
             )?;
         }
@@ -673,7 +925,11 @@ impl UI {
         Ok(())
     }
 
-    pub fn render_game_over(&mut self, stdout: &mut std::io::Stdout, player: &Player) -> std::io::Result<()> {
+    pub fn render_game_over(
+        &mut self,
+        stdout: &mut std::io::Stdout,
+        player: &Player,
+    ) -> std::io::Result<()> {
         let (max_x, max_y) = terminal::size()?;
         let cx = max_x / 2;
         let cy = max_y / 2;
@@ -690,7 +946,11 @@ impl UI {
         ];
 
         for (i, (msg, color, bold)) in messages.iter().enumerate() {
-            let attr = if *bold { Attribute::Bold } else { Attribute::Reset };
+            let attr = if *bold {
+                Attribute::Bold
+            } else {
+                Attribute::Reset
+            };
             queue!(
                 stdout,
                 cursor::MoveTo(
@@ -755,49 +1015,43 @@ impl UI {
     pub fn render_title_screen(&mut self, stdout: &mut std::io::Stdout) -> std::io::Result<()> {
         let (max_x, max_y) = terminal::size()?;
         let cx = max_x / 2;
-        let cy = max_y / 2;
 
-        let skull = [
-            "     ___     ",
-            "    (o o)    ",
-            "   /  V  \\   ",
+        let art = [
+            "      ___       ",
+            "   __(o o)__    ",
+            r"  /   \_/   \   ",
+            r" /___/   \___\  ",
+            "                 ",
+            " SUPERVILLAIN    ",
         ];
-
-        let ascii_art = [
-            "  ____                       _ _           ",
-            " / ___| _ __ ___   __ _  ___| (_)_   _____ ",
-            " \\___ \\| '_ ` _ \\ / _` |/ __| | \\ \\ / / _ \\",
-            "  ___) | | | | | | (_| | (__| | |\\ V /  __/",
-            " |____/|_| |_| |_|\\__,_|\\___|_|_| \\_/ \\___|",
+        let subtitle = "A Lair-Building Roguelike";
+        let tagline = "Build. Scheme. Dominate.";
+        let prompt = "Press any key to start";
+        let controls = [
+            "Move: hjkl/arrows   Build: b   Research: r   Hire: f",
+            "Schemes: m   Pause: Space/p   Speed: +/-   Quit: q",
         ];
 
-        let total_lines = skull.len() + 2 + ascii_art.len() + 1 + 1 + 1 + 1 + 1 + 2 + 1 + 3 + 1 + 2;
-        let start_y = cy.saturating_sub(total_lines as u16 / 2);
-
-        let mut y = start_y;
-
-        for line in &skull {
-            let x = cx.saturating_sub(line.len() as u16 / 2);
-            queue!(
-                stdout,
-                cursor::MoveTo(x, y),
-                SetForegroundColor(Color::Red),
-                SetBackgroundColor(Color::Black),
-                style::Print(*line),
-            )?;
-            y += 1;
-        }
-
-        y += 2;
+        let min_lines = art.len() as u16 + 9;
+        let mut y = if max_y > min_lines {
+            (max_y - min_lines) / 2
+        } else {
+            1
+        };
 
-        for line in &ascii_art {
-            let x = cx.saturating_sub(line.len() as u16 / 2);
+        for (i, line) in art.iter().enumerate() {
+            let color = if i < 4 { Color::Red } else { Color::Magenta };
+            let bold = i == art.len() - 1;
             queue!(
                 stdout,
-                cursor::MoveTo(x, y),
-                SetForegroundColor(Color::Magenta),
+                cursor::MoveTo(cx.saturating_sub(line.len() as u16 / 2), y),
+                SetForegroundColor(color),
                 SetBackgroundColor(Color::Black),
-                style::SetAttribute(Attribute::Bold),
+                style::SetAttribute(if bold {
+                    Attribute::Bold
+                } else {
+                    Attribute::Reset
+                }),
                 style::Print(*line),
                 style::SetAttribute(Attribute::Reset),
             )?;
@@ -805,18 +1059,6 @@ impl UI {
         }
 
         y += 1;
-
-        let sep = "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~";
-        queue!(
-            stdout,
-            cursor::MoveTo(cx.saturating_sub(sep.len() as u16 / 2), y),
-            SetForegroundColor(Color::DarkMagenta),
-            SetBackgroundColor(Color::Black),
-            style::Print(sep),
-        )?;
-        y += 2;
-
-        let subtitle = "A Lair-Building Roguelike";
         queue!(
             stdout,
             cursor::MoveTo(cx.saturating_sub(subtitle.len() as u16 / 2), y),
@@ -826,7 +1068,6 @@ impl UI {
         )?;
         y += 1;
 
-        let tagline = "Build. Scheme. Dominate.";
         queue!(
             stdout,
             cursor::MoveTo(cx.saturating_sub(tagline.len() as u16 / 2), y),
@@ -836,7 +1077,6 @@ impl UI {
         )?;
         y += 2;
 
-        let prompt = "Press any key to start...";
         queue!(
             stdout,
             cursor::MoveTo(cx.saturating_sub(prompt.len() as u16 / 2), y),
@@ -844,23 +1084,12 @@ impl UI {
             SetBackgroundColor(Color::Black),
             style::Print(prompt),
         )?;
-        y += 3;
-
-        let ctrl_sep = "------------------------------------------";
-        queue!(
-            stdout,
-            cursor::MoveTo(cx.saturating_sub(ctrl_sep.len() as u16 / 2), y),
-            SetForegroundColor(Color::DarkGrey),
-            SetBackgroundColor(Color::Black),
-            style::Print(ctrl_sep),
-        )?;
-        y += 1;
+        y += 2;
 
-        let controls = [
-            "hjkl/arrow: Move    b: Build    r: Research    f: Hire",
-            "m: Schemes    SPACE: Pause    +/-: Speed    q: Quit",
-        ];
         for line in &controls {
+            if y >= max_y.saturating_sub(1) {
+                break;
+            }
             queue!(
                 stdout,
                 cursor::MoveTo(cx.saturating_sub(line.len() as u16 / 2), y),
diff --git a/src/build.rs b/src/build.rs
index 6190da8..610f340 100644
--- a/src/build.rs
+++ b/src/build.rs
@@ -1,6 +1,6 @@
 use crate::entities::Player;
 use crate::map::GameMap;
-use crate::tiles::{build_categories, TileType};
+use crate::tiles::{TileType, build_categories};
 
 pub struct BuildMode {
     pub cursor_x: i32,
@@ -54,7 +54,8 @@ impl BuildMode {
 
     pub fn select_category(&mut self, direction: i32, player: &Player) {
         let cats = build_categories();
-        self.category_index = (self.category_index as i32 + direction).rem_euclid(cats.len() as i32) as usize;
+        self.category_index =
+            (self.category_index as i32 + direction).rem_euclid(cats.len() as i32) as usize;
         self.item_index = 0;
         self.update_selected(player);
     }
@@ -64,7 +65,8 @@ impl BuildMode {
         if items.is_empty() {
             return;
         }
-        self.item_index = (self.item_index as i32 + direction).rem_euclid(items.len() as i32) as usize;
+        self.item_index =
+            (self.item_index as i32 + direction).rem_euclid(items.len() as i32) as usize;
         self.selected_tile = items[self.item_index].0;
     }
 
@@ -99,9 +101,7 @@ impl BuildMode {
         }
 
         // Can only build on walls or floor (or replace existing buildable tiles)
-        if !matches!(current, TileType::Wall | TileType::Floor)
-            && !current.is_walkable()
-        {
+        if !matches!(current, TileType::Wall | TileType::Floor) && !current.is_walkable() {
             self.message = "Can't build here!".to_string();
             return BuildResult::None;
         }
@@ -122,11 +122,7 @@ impl BuildMode {
         // Place the tile
         player.gold -= cost;
         game_map.set_tile(x, y, self.selected_tile);
-        self.message = format!(
-            "Built {} for {} gold",
-            self.selected_tile.name(),
-            cost
-        );
+        self.message = format!("Built {} for {} gold", self.selected_tile.name(), cost);
 
         if self.selected_tile == TileType::GuardPost {
             return BuildResult::GuardPostPlaced;
@@ -140,7 +136,10 @@ impl BuildMode {
         let y = self.cursor_y;
         let current = game_map.get_tile(x, y);
 
-        if matches!(current, TileType::Rock | TileType::Wall | TileType::Throne | TileType::Entry) {
+        if matches!(
+            current,
+            TileType::Rock | TileType::Wall | TileType::Throne | TileType::Entry
+        ) {
             return "Can't demolish that!".to_string();
         }
 
@@ -200,7 +199,10 @@ impl BuildMode {
         }
 
         if self.selected_tile.is_door() {
-            info.push_str(&format!(" | Security L{}", self.selected_tile.security_level()));
+            info.push_str(&format!(
+                " | Security L{}",
+                self.selected_tile.security_level()
+            ));
         }
 
         if self.selected_tile == TileType::FakeEntry {
diff --git a/src/combat.rs b/src/combat.rs
index 8b53ab6..b6ce6ec 100644
--- a/src/combat.rs
+++ b/src/combat.rs
@@ -104,46 +104,66 @@ impl CombatSystem {
                 .map(|(_, a)| (a.entity.x, a.entity.y, a.entity.alive))
                 .collect();
             let prev_pos = (agents[i].entity.x, agents[i].entity.y);
-            let move_msgs = agents[i].move_along_path(game_map, &other_positions, player.trap_damage_bonus);
+            let move_msgs =
+                agents[i].move_along_path(game_map, &other_positions, player.trap_damage_bonus);
             self.log.extend(move_msgs);
 
             // Apply splash damage from fire traps
             if agents[i].entity.alive
-                && let Some((splash_dmg, (cx, cy))) = agents[i].get_splash_info(game_map) {
-                    for (j, agent) in agents.iter_mut().enumerate() {
-                        if j == i || !agent.entity.alive { continue; }
-                        if agent.entity.is_adjacent_to(cx, cy) {
-                            agent.entity.take_damage(splash_dmg);
-                            self.log_msg(&format!("{} takes {} splash damage!", agent.entity.name, splash_dmg));
-                            if !agent.entity.alive {
-                                self.kill_events.push(KillEvent { gold_value: agent.gold_value, agent_type: agent.agent_type });
-                                splash_killed.push(j);
-                            }
-                        }
+                && let Some((splash_dmg, (cx, cy))) = agents[i].get_splash_info(game_map)
+            {
+                for (j, agent) in agents.iter_mut().enumerate() {
+                    if j == i || !agent.entity.alive {
+                        continue;
                     }
-                    for minion in minions.iter_mut() {
-                        if !minion.entity.alive { continue; }
-                        if minion.entity.is_adjacent_to(cx, cy) {
-                            minion.take_damage(splash_dmg);
-                            self.log_msg(&format!("{} takes {} splash damage!", minion.entity.name, splash_dmg));
+                    if agent.entity.is_adjacent_to(cx, cy) {
+                        agent.entity.take_damage(splash_dmg);
+                        self.log_msg(&format!(
+                            "{} takes {} splash damage!",
+                            agent.entity.name, splash_dmg
+                        ));
+                        if !agent.entity.alive {
+                            self.kill_events.push(KillEvent {
+                                gold_value: agent.gold_value,
+                                agent_type: agent.agent_type,
+                            });
+                            splash_killed.push(j);
                         }
                     }
                 }
+                for minion in minions.iter_mut() {
+                    if !minion.entity.alive {
+                        continue;
+                    }
+                    if minion.entity.is_adjacent_to(cx, cy) {
+                        minion.take_damage(splash_dmg);
+                        self.log_msg(&format!(
+                            "{} takes {} splash damage!",
+                            minion.entity.name, splash_dmg
+                        ));
+                    }
+                }
+            }
 
             // Apply pushback from wind traps
             if agents[i].entity.alive
-                && let Some((_px, _py)) = agents[i].get_pushback_info(game_map) {
-                    // Push agent back to their previous position
-                    if game_map.is_walkable(prev_pos.0, prev_pos.1) {
-                        agents[i].entity.x = prev_pos.0;
-                        agents[i].entity.y = prev_pos.1;
-                        self.log_msg(&format!("{} is blown back!", agents[i].entity.name));
-                    }
+                && let Some((_px, _py)) = agents[i].get_pushback_info(game_map)
+            {
+                // Push agent back to their previous position
+                if game_map.is_walkable(prev_pos.0, prev_pos.1) {
+                    agents[i].entity.x = prev_pos.0;
+                    agents[i].entity.y = prev_pos.1;
+                    self.log_msg(&format!("{} is blown back!", agents[i].entity.name));
                 }
+            }
 
             // Track trap combos
             let tile = game_map.get_tile(agents[i].entity.x, agents[i].entity.y);
-            if tile.is_trap() && game_map.powered.contains(&(agents[i].entity.x, agents[i].entity.y)) {
+            if tile.is_trap()
+                && game_map
+                    .powered
+                    .contains(&(agents[i].entity.x, agents[i].entity.y))
+            {
                 self.trap_combo_count += 1;
             }
 
@@ -158,20 +178,28 @@ impl CombatSystem {
             // Check if agent reached throne
             if (agents[i].entity.x, agents[i].entity.y) == throne {
                 if player.is_invulnerable() {
-                    self.log_msg(&format!("{} is repelled by the Supervillain's shield!", agents[i].entity.name));
+                    self.log_msg(&format!(
+                        "{} is repelled by the Supervillain's shield!",
+                        agents[i].entity.name
+                    ));
                     // Push agent back
                     let dx = agents[i].entity.x - throne.0;
                     let dy = agents[i].entity.y - throne.1;
                     let push = 3;
-                    let new_x = (agents[i].entity.x + dx.signum() * push).clamp(0, game_map.width - 1);
-                    let new_y = (agents[i].entity.y + dy.signum() * push).clamp(0, game_map.height - 1);
+                    let new_x =
+                        (agents[i].entity.x + dx.signum() * push).clamp(0, game_map.width - 1);
+                    let new_y =
+                        (agents[i].entity.y + dy.signum() * push).clamp(0, game_map.height - 1);
                     if game_map.is_walkable(new_x, new_y) {
                         agents[i].entity.x = new_x;
                         agents[i].entity.y = new_y;
                     }
                     agents[i].entity.stun_turns = agents[i].entity.stun_turns.max(1);
                 } else {
-                    self.log_msg(&format!("{} reaches the throne room!", agents[i].entity.name));
+                    self.log_msg(&format!(
+                        "{} reaches the throne room!",
+                        agents[i].entity.name
+                    ));
                     agents[i].entity.alive = false;
                     return true; // throne reached
                 }
@@ -184,7 +212,10 @@ impl CombatSystem {
                     agents[i].has_stolen = true;
                     let stolen = std::cmp::min(player.gold, 50 + player.wave * 10);
                     player.gold -= stolen;
-                    self.log_msg(&format!("{} steals {} gold!", agents[i].entity.name, stolen));
+                    self.log_msg(&format!(
+                        "{} steals {} gold!",
+                        agents[i].entity.name, stolen
+                    ));
                     self.heat_events.push(HeatEvent {
                         heat_change: 5,
                         reason: "theft reported".to_string(),
@@ -200,7 +231,11 @@ impl CombatSystem {
                     let adj = game_map.get_tile(nx, ny);
                     if adj.is_trap() && game_map.powered.contains(&(nx, ny)) {
                         game_map.set_tile(nx, ny, TileType::Floor);
-                        self.log_msg(&format!("{} sabotages a {}!", agents[i].entity.name, adj.name()));
+                        self.log_msg(&format!(
+                            "{} sabotages a {}!",
+                            agents[i].entity.name,
+                            adj.name()
+                        ));
                         break;
                     }
                     if adj == TileType::PowerCore {
@@ -234,20 +269,30 @@ impl CombatSystem {
             let admg = agents[i].entity.damage;
             let aname = agents[i].entity.name.clone();
             for minion in minions.iter_mut() {
-                if !minion.entity.alive { continue; }
+                if !minion.entity.alive {
+                    continue;
+                }
                 if minion.entity.is_adjacent_to(ax, ay) {
                     minion.take_damage(admg);
-                    self.log_msg(&format!("{} hits {} for {}!", aname, minion.entity.name, admg));
+                    self.log_msg(&format!(
+                        "{} hits {} for {}!",
+                        aname, minion.entity.name, admg
+                    ));
                     if !minion.entity.alive {
                         self.log_msg(&format!("{} is defeated!", minion.entity.name));
                     }
                 }
             }
             for henchman in henchmen.iter_mut() {
-                if !henchman.entity.alive { continue; }
+                if !henchman.entity.alive {
+                    continue;
+                }
                 if henchman.entity.is_adjacent_to(ax, ay) {
                     henchman.entity.take_damage(admg);
-                    self.log_msg(&format!("{} hits {} for {}!", aname, henchman.entity.name, admg));
+                    self.log_msg(&format!(
+                        "{} hits {} for {}!",
+                        aname, henchman.entity.name, admg
+                    ));
                 }
             }
         }
@@ -268,7 +313,9 @@ impl CombatSystem {
         self.kill_events.clear();
 
         for i in 0..minions.len() {
-            if !minions[i].entity.alive { continue; }
+            if !minions[i].entity.alive {
+                continue;
+            }
 
             let effect_msgs = minions[i].entity.process_effects();
             self.log.extend(effect_msgs);
@@ -277,14 +324,20 @@ impl CombatSystem {
                 continue;
             }
 
-            if minions[i].entity.stun_turns > 0 { continue; }
+            if minions[i].entity.stun_turns > 0 {
+                continue;
+            }
 
             // Find nearest agent
             let mut nearest_idx: Option<usize> = None;
             let mut nearest_dist = i32::MAX;
             for (j, agent) in agents.iter().enumerate() {
-                if !agent.entity.alive { continue; }
-                let dist = minions[i].entity.distance_to(agent.entity.x, agent.entity.y);
+                if !agent.entity.alive {
+                    continue;
+                }
+                let dist = minions[i]
+                    .entity
+                    .distance_to(agent.entity.x, agent.entity.y);
                 if dist < nearest_dist {
                     nearest_dist = dist;
                     nearest_idx = Some(j);
@@ -294,16 +347,18 @@ impl CombatSystem {
             match nearest_idx {
                 None => {
                     // Return to guard post
-                    if (minions[i].entity.x, minions[i].entity.y) != (minions[i].home_x, minions[i].home_y)
+                    if (minions[i].entity.x, minions[i].entity.y)
+                        != (minions[i].home_x, minions[i].home_y)
                         && let Some(path) = game_map.find_path(
                             (minions[i].entity.x, minions[i].entity.y),
                             (minions[i].home_x, minions[i].home_y),
                             &std::collections::HashSet::new(),
                         )
-                            && path.len() >= 2 {
-                                minions[i].entity.x = path[1].0;
-                                minions[i].entity.y = path[1].1;
-                            }
+                        && path.len() >= 2
+                    {
+                        minions[i].entity.x = path[1].0;
+                        minions[i].entity.y = path[1].1;
+                    }
                 }
                 Some(j) => {
                     // Class-specific behavior
@@ -322,16 +377,18 @@ impl CombatSystem {
                                 continue;
                             }
                             // Workers too far from agents just return home
-                            if (minions[i].entity.x, minions[i].entity.y) != (minions[i].home_x, minions[i].home_y)
+                            if (minions[i].entity.x, minions[i].entity.y)
+                                != (minions[i].home_x, minions[i].home_y)
                                 && let Some(path) = game_map.find_path(
                                     (minions[i].entity.x, minions[i].entity.y),
                                     (minions[i].home_x, minions[i].home_y),
                                     &std::collections::HashSet::new(),
                                 )
-                                    && path.len() >= 2 {
-                                        minions[i].entity.x = path[1].0;
-                                        minions[i].entity.y = path[1].1;
-                                    }
+                                && path.len() >= 2
+                            {
+                                minions[i].entity.x = path[1].0;
+                                minions[i].entity.y = path[1].1;
+                            }
                             continue;
                         }
                         MinionClass::Scientist => {
@@ -348,16 +405,18 @@ impl CombatSystem {
                                 continue;
                             }
                             // Return to home (lab)
-                            if (minions[i].entity.x, minions[i].entity.y) != (minions[i].home_x, minions[i].home_y)
+                            if (minions[i].entity.x, minions[i].entity.y)
+                                != (minions[i].home_x, minions[i].home_y)
                                 && let Some(path) = game_map.find_path(
                                     (minions[i].entity.x, minions[i].entity.y),
                                     (minions[i].home_x, minions[i].home_y),
                                     &std::collections::HashSet::new(),
                                 )
-                                    && path.len() >= 2 {
-                                        minions[i].entity.x = path[1].0;
-                                        minions[i].entity.y = path[1].1;
-                                    }
+                                && path.len() >= 2
+                            {
+                                minions[i].entity.x = path[1].0;
+                                minions[i].entity.y = path[1].1;
+                            }
                             continue;
                         }
                         _ => {} // Guards and Technicians fight normally
@@ -366,9 +425,15 @@ impl CombatSystem {
                     if nearest_dist == 1 {
                         let dmg = minions[i].entity.damage;
                         agents[j].entity.take_damage(dmg);
-                        self.log_msg(&format!("{} hits {} for {}!", minions[i].entity.name, agents[j].entity.name, dmg));
+                        self.log_msg(&format!(
+                            "{} hits {} for {}!",
+                            minions[i].entity.name, agents[j].entity.name, dmg
+                        ));
                         if !agents[j].entity.alive {
-                            self.kill_events.push(KillEvent { gold_value: agents[j].gold_value, agent_type: agents[j].agent_type });
+                            self.kill_events.push(KillEvent {
+                                gold_value: agents[j].gold_value,
+                                agent_type: agents[j].agent_type,
+                            });
                         }
                         continue;
                     }
@@ -385,11 +450,11 @@ impl CombatSystem {
                         (minions[i].entity.x, minions[i].entity.y),
                         (agents[j].entity.x, agents[j].entity.y),
                         &occupied,
-                    )
-                        && path.len() >= 2 {
-                            minions[i].entity.x = path[1].0;
-                            minions[i].entity.y = path[1].1;
-                        }
+                    ) && path.len() >= 2
+                    {
+                        minions[i].entity.x = path[1].0;
+                        minions[i].entity.y = path[1].1;
+                    }
                 }
             }
         }
@@ -406,17 +471,23 @@ impl CombatSystem {
         self.kill_events.clear();
 
         for henchman in henchmen.iter_mut() {
-            if !henchman.entity.alive { continue; }
+            if !henchman.entity.alive {
+                continue;
+            }
 
             let effect_msgs = henchman.entity.process_effects();
             self.log.extend(effect_msgs);
-            if !henchman.entity.alive { continue; }
+            if !henchman.entity.alive {
+                continue;
+            }
 
             // Find nearest agent
             let mut nearest_idx: Option<usize> = None;
             let mut nearest_dist = i32::MAX;
             for (j, agent) in agents.iter().enumerate() {
-                if !agent.entity.alive { continue; }
+                if !agent.entity.alive {
+                    continue;
+                }
                 let dist = henchman.entity.distance_to(agent.entity.x, agent.entity.y);
                 if dist < nearest_dist {
                     nearest_dist = dist;
@@ -430,12 +501,24 @@ impl CombatSystem {
                     HenchmanAbility::Barrage => {
                         // Damage all nearby agents
                         for agent in agents.iter_mut() {
-                            if !agent.entity.alive { continue; }
-                            if agent.entity.distance_to(henchman.entity.x, henchman.entity.y) <= 2 {
+                            if !agent.entity.alive {
+                                continue;
+                            }
+                            if agent
+                                .entity
+                                .distance_to(henchman.entity.x, henchman.entity.y)
+                                <= 2
+                            {
                                 agent.entity.take_damage(henchman.entity.damage);
-                                self.log_msg(&format!("{} BARRAGES {} for {}!", henchman.entity.name, agent.entity.name, henchman.entity.damage));
+                                self.log_msg(&format!(
+                                    "{} BARRAGES {} for {}!",
+                                    henchman.entity.name, agent.entity.name, henchman.entity.damage
+                                ));
                                 if !agent.entity.alive {
-                                    self.kill_events.push(KillEvent { gold_value: agent.gold_value, agent_type: agent.agent_type });
+                                    self.kill_events.push(KillEvent {
+                                        gold_value: agent.gold_value,
+                                        agent_type: agent.agent_type,
+                                    });
                                 }
                             }
                         }
@@ -443,18 +526,33 @@ impl CombatSystem {
                     HenchmanAbility::Intimidate => {
                         // Stun and push back nearby agents
                         for agent in agents.iter_mut() {
-                            if !agent.entity.alive { continue; }
-                            if agent.entity.distance_to(henchman.entity.x, henchman.entity.y) <= 2 {
+                            if !agent.entity.alive {
+                                continue;
+                            }
+                            if agent
+                                .entity
+                                .distance_to(henchman.entity.x, henchman.entity.y)
+                                <= 2
+                            {
                                 agent.entity.stun_turns = 3;
-                                self.log_msg(&format!("{} INTIMIDATES {}!", henchman.entity.name, agent.entity.name));
+                                self.log_msg(&format!(
+                                    "{} INTIMIDATES {}!",
+                                    henchman.entity.name, agent.entity.name
+                                ));
                             }
                         }
                     }
                     HenchmanAbility::Shield => {
                         // Heal nearby minions
                         for minion in minions.iter_mut() {
-                            if !minion.entity.alive { continue; }
-                            if minion.entity.distance_to(henchman.entity.x, henchman.entity.y) <= 3 {
+                            if !minion.entity.alive {
+                                continue;
+                            }
+                            if minion
+                                .entity
+                                .distance_to(henchman.entity.x, henchman.entity.y)
+                                <= 3
+                            {
                                 minion.entity.heal(10);
                             }
                         }
@@ -463,13 +561,27 @@ impl CombatSystem {
                     HenchmanAbility::Sabotage => {
                         // Stun and damage nearby agents (disrupt their equipment)
                         for agent in agents.iter_mut() {
-                            if !agent.entity.alive { continue; }
-                            if agent.entity.distance_to(henchman.entity.x, henchman.entity.y) <= 2 {
+                            if !agent.entity.alive {
+                                continue;
+                            }
+                            if agent
+                                .entity
+                                .distance_to(henchman.entity.x, henchman.entity.y)
+                                <= 2
+                            {
                                 agent.entity.stun_turns = 2;
                                 agent.entity.take_damage(henchman.entity.damage / 2);
-                                self.log_msg(&format!("{} SABOTAGES {}! (stun + {} dmg)", henchman.entity.name, agent.entity.name, henchman.entity.damage / 2));
+                                self.log_msg(&format!(
+                                    "{} SABOTAGES {}! (stun + {} dmg)",
+                                    henchman.entity.name,
+                                    agent.entity.name,
+                                    henchman.entity.damage / 2
+                                ));
                                 if !agent.entity.alive {
-                                    self.kill_events.push(KillEvent { gold_value: agent.gold_value, agent_type: agent.agent_type });
+                                    self.kill_events.push(KillEvent {
+                                        gold_value: agent.gold_value,
+                                        agent_type: agent.agent_type,
+                                    });
                                 }
                             }
                         }
@@ -482,9 +594,15 @@ impl CombatSystem {
                 if nearest_dist == 1 {
                     let dmg = henchman.entity.damage;
                     agents[j].entity.take_damage(dmg);
-                    self.log_msg(&format!("{} hits {} for {}!", henchman.entity.name, agents[j].entity.name, dmg));
+                    self.log_msg(&format!(
+                        "{} hits {} for {}!",
+                        henchman.entity.name, agents[j].entity.name, dmg
+                    ));
                     if !agents[j].entity.alive {
-                        self.kill_events.push(KillEvent { gold_value: agents[j].gold_value, agent_type: agents[j].agent_type });
+                        self.kill_events.push(KillEvent {
+                            gold_value: agents[j].gold_value,
+                            agent_type: agents[j].agent_type,
+                        });
                     }
                 } else if nearest_dist > 1
                     && let Some(path) = game_map.find_path(
@@ -492,10 +610,11 @@ impl CombatSystem {
                         (agents[j].entity.x, agents[j].entity.y),
                         &std::collections::HashSet::new(),
                     )
-                        && path.len() >= 2 {
-                            henchman.entity.x = path[1].0;
-                            henchman.entity.y = path[1].1;
-                        }
+                    && path.len() >= 2
+                {
+                    henchman.entity.x = path[1].0;
+                    henchman.entity.y = path[1].1;
+                }
             }
         }
     }
@@ -512,10 +631,14 @@ impl CombatSystem {
             }
         }
 
-        if broken_traps.is_empty() { return; }
+        if broken_traps.is_empty() {
+            return;
+        }
 
         for minion in minions.iter_mut() {
-            if !minion.entity.alive || !minion.can_repair() { continue; }
+            if !minion.entity.alive || !minion.can_repair() {
+                continue;
+            }
 
             // First check adjacent tiles for unpowered traps
             let mut repaired = false;
@@ -525,13 +648,19 @@ impl CombatSystem {
                 let tile = game_map.get_tile(nx, ny);
                 if tile.is_trap() && !game_map.powered.contains(&(nx, ny)) {
                     game_map.powered.insert((nx, ny));
-                    self.log_msg(&format!("{} repairs a {}!", minion.entity.name, tile.name()));
+                    self.log_msg(&format!(
+                        "{} repairs a {}!",
+                        minion.entity.name,
+                        tile.name()
+                    ));
                     repaired = true;
                     break; // One repair per turn
                 }
             }
 
-            if repaired { continue; }
+            if repaired {
+                continue;
+            }
 
             // If no adjacent broken trap, move toward nearest one
             let mut nearest_dist = i32::MAX;
@@ -561,7 +690,9 @@ impl CombatSystem {
     pub fn process_medbay_healing(&mut self, game_map: &GameMap, minions: &mut [Minion]) {
         let medbays = game_map.tiles_of_type(TileType::Medbay);
         for (mx, my) in medbays {
-            if !game_map.powered.contains(&(mx, my)) { continue; }
+            if !game_map.powered.contains(&(mx, my)) {
+                continue;
+            }
             for minion in minions.iter_mut() {
                 if minion.entity.alive && minion.entity.distance_to(mx, my) <= 3 {
                     minion.entity.heal(3);
@@ -573,7 +704,9 @@ impl CombatSystem {
     pub fn process_training_room(&mut self, game_map: &GameMap, minions: &mut [Minion]) {
         let training_rooms = game_map.tiles_of_type(TileType::TrainingRoom);
         for (tx, ty) in training_rooms {
-            if !game_map.powered.contains(&(tx, ty)) { continue; }
+            if !game_map.powered.contains(&(tx, ty)) {
+                continue;
+            }
             for minion in minions.iter_mut() {
                 if minion.entity.alive && minion.entity.distance_to(tx, ty) <= 1 {
                     // Small chance to level up minion stats
@@ -581,7 +714,8 @@ impl CombatSystem {
                     if rng.random_range(0.0..1.0) < 0.05 {
                         minion.entity.damage += 1;
                         minion.entity.max_hp += 3;
-                        minion.entity.hp = std::cmp::min(minion.entity.hp + 3, minion.entity.max_hp);
+                        minion.entity.hp =
+                            std::cmp::min(minion.entity.hp + 3, minion.entity.max_hp);
                     }
                 }
             }
@@ -592,7 +726,12 @@ impl CombatSystem {
         agents.iter().all(|a| !a.entity.alive)
     }
 
-    pub fn cleanup_dead(&self, minions: &mut Vec<Minion>, agents: &mut Vec<Agent>, henchmen: &mut Vec<Henchman>) {
+    pub fn cleanup_dead(
+        &self,
+        minions: &mut Vec<Minion>,
+        agents: &mut Vec<Agent>,
+        henchmen: &mut Vec<Henchman>,
+    ) {
         minions.retain(|m| m.entity.alive);
         agents.retain(|a| a.entity.alive);
         henchmen.retain(|h| h.entity.alive);
@@ -600,9 +739,13 @@ impl CombatSystem {
 
     /// Calculate trap combo bonus
     pub fn combo_bonus(&self) -> i32 {
-        if self.trap_combo_count >= 3 { 50 }
-        else if self.trap_combo_count >= 2 { 25 }
-        else { 0 }
+        if self.trap_combo_count >= 3 {
+            50
+        } else if self.trap_combo_count >= 2 {
+            25
+        } else {
+            0
+        }
     }
 
     /// Activate a superpower. Returns log messages for the action.
@@ -623,7 +766,9 @@ impl CombatSystem {
                 let range = power.range;
                 let mut hit_count = 0;
                 for agent in agents.iter_mut() {
-                    if !agent.entity.alive { continue; }
+                    if !agent.entity.alive {
+                        continue;
+                    }
                     if agent.entity.distance_to(px, py) <= range {
                         agent.entity.hp -= damage;
                         hit_count += 1;
@@ -636,7 +781,10 @@ impl CombatSystem {
                         }
                     }
                 }
-                messages.push(format!("{} hits {} agents for {} damage!", power.name, hit_count, damage));
+                messages.push(format!(
+                    "{} hits {} agents for {} damage!",
+                    power.name, hit_count, damage
+                ));
             }
 
             crate::superpowers::SuperpowerEffect::AoeStun { turns } => {
@@ -645,13 +793,18 @@ impl CombatSystem {
                 let range = power.range;
                 let mut hit_count = 0;
                 for agent in agents.iter_mut() {
-                    if !agent.entity.alive { continue; }
+                    if !agent.entity.alive {
+                        continue;
+                    }
                     if agent.entity.distance_to(px, py) <= range {
                         agent.entity.stun_turns = agent.entity.stun_turns.max(turns);
                         hit_count += 1;
                     }
                 }
-                messages.push(format!("{} stuns {} agents for {} turns!", power.name, hit_count, turns));
+                messages.push(format!(
+                    "{} stuns {} agents for {} turns!",
+                    power.name, hit_count, turns
+                ));
             }
 
             crate::superpowers::SuperpowerEffect::AoePoison { turns, damage } => {
@@ -660,20 +813,28 @@ impl CombatSystem {
                 let range = power.range;
                 let mut hit_count = 0;
                 for agent in agents.iter_mut() {
-                    if !agent.entity.alive { continue; }
+                    if !agent.entity.alive {
+                        continue;
+                    }
                     if agent.entity.distance_to(px, py) <= range {
                         agent.entity.poison_turns = agent.entity.poison_turns.max(turns);
                         agent.entity.poison_dmg = agent.entity.poison_dmg.max(damage);
                         hit_count += 1;
                     }
                 }
-                messages.push(format!("{} poisons {} agents for {} dmg/turn!", power.name, hit_count, damage));
+                messages.push(format!(
+                    "{} poisons {} agents for {} dmg/turn!",
+                    power.name, hit_count, damage
+                ));
             }
 
             crate::superpowers::SuperpowerEffect::SelfHeal { amount } => {
                 let healed = amount.min(player.entity.max_hp - player.entity.hp);
                 player.entity.hp += healed;
-                messages.push(format!("{} heals for {} HP! ({} HP now)", power.name, healed, player.entity.hp));
+                messages.push(format!(
+                    "{} heals for {} HP! ({} HP now)",
+                    power.name, healed, player.entity.hp
+                ));
             }
 
             crate::superpowers::SuperpowerEffect::SummonGuards { count } => {
@@ -682,13 +843,18 @@ impl CombatSystem {
                 let mut spawned = 0;
                 for dx in -1..=1 {
                     for dy in -1..=1 {
-                        if spawned >= count { break; }
-                        if dx == 0 && dy == 0 { continue; }
+                        if spawned >= count {
+                            break;
+                        }
+                        if dx == 0 && dy == 0 {
+                            continue;
+                        }
                         let nx = px + dx;
                         let ny = py + dy;
                         if game_map.is_walkable(nx, ny) {
                             minions.push(crate::entities::Minion::new(
-                                nx, ny,
+                                nx,
+                                ny,
                                 crate::entities::MinionClass::Guard,
                                 player.minion_hp_bonus,
                                 player.minion_damage_bonus,
@@ -711,7 +877,9 @@ impl CombatSystem {
                         let tx = px + dx * i;
                         let ty = py + dy * i;
                         for agent in agents.iter_mut() {
-                            if !agent.entity.alive { continue; }
+                            if !agent.entity.alive {
+                                continue;
+                            }
                             if agent.entity.x == tx && agent.entity.y == ty {
                                 agent.entity.hp -= damage;
                                 hit_count += 1;
@@ -726,7 +894,10 @@ impl CombatSystem {
                         }
                     }
                 }
-                messages.push(format!("{} hits {} agents for {} damage!", power.name, hit_count, damage));
+                messages.push(format!(
+                    "{} hits {} agents for {} damage!",
+                    power.name, hit_count, damage
+                ));
             }
 
             crate::superpowers::SuperpowerEffect::Repulsion { distance } => {
@@ -735,11 +906,17 @@ impl CombatSystem {
                 let range = power.range;
                 let mut pushed_count = 0;
                 for agent in agents.iter_mut() {
-                    if !agent.entity.alive { continue; }
-                    if agent.entity.distance_to(px, py) > range { continue; }
+                    if !agent.entity.alive {
+                        continue;
+                    }
+                    if agent.entity.distance_to(px, py) > range {
+                        continue;
+                    }
                     let dx = agent.entity.x - px;
                     let dy = agent.entity.y - py;
-                    if dx == 0 && dy == 0 { continue; }
+                    if dx == 0 && dy == 0 {
+                        continue;
+                    }
                     let len = (dx.abs() + dy.abs()).max(1);
                     let push_x = (dx * distance / len).signum() * distance;
                     let push_y = (dy * distance / len).signum() * distance;
@@ -751,16 +928,24 @@ impl CombatSystem {
                     }
                     pushed_count += 1;
                 }
-                messages.push(format!("{} pushes {} agents away!", power.name, pushed_count));
+                messages.push(format!(
+                    "{} pushes {} agents away!",
+                    power.name, pushed_count
+                ));
             }
 
-            crate::superpowers::SuperpowerEffect::DrainLife { damage_per_enemy, heal_per_enemy } => {
+            crate::superpowers::SuperpowerEffect::DrainLife {
+                damage_per_enemy,
+                heal_per_enemy,
+            } => {
                 let px = player.entity.x;
                 let py = player.entity.y;
                 let range = power.range;
                 let mut hit_count = 0;
                 for agent in agents.iter_mut() {
-                    if !agent.entity.alive { continue; }
+                    if !agent.entity.alive {
+                        continue;
+                    }
                     if agent.entity.distance_to(px, py) <= range {
                         agent.entity.hp -= damage_per_enemy;
                         hit_count += 1;
@@ -776,12 +961,18 @@ impl CombatSystem {
                 let total_heal = hit_count * heal_per_enemy;
                 let healed = total_heal.min(player.entity.max_hp - player.entity.hp);
                 player.entity.hp += healed;
-                messages.push(format!("{} drains {} enemies, healing {} HP!", power.name, hit_count, healed));
+                messages.push(format!(
+                    "{} drains {} enemies, healing {} HP!",
+                    power.name, hit_count, healed
+                ));
             }
 
             crate::superpowers::SuperpowerEffect::Invulnerability { turns } => {
                 player.invulnerability_turns = turns;
-                messages.push(format!("{} — invulnerable for {} turns!", power.name, turns));
+                messages.push(format!(
+                    "{} — invulnerable for {} turns!",
+                    power.name, turns
+                ));
             }
 
             crate::superpowers::SuperpowerEffect::Teleport => {
@@ -874,7 +1065,8 @@ mod tests {
         map.powered.insert(medbay_pos);
 
         // Create a damaged minion near the medbay
-        let mut minion = crate::entities::Minion::new(41, 20, crate::entities::MinionClass::Worker, 0, 0);
+        let mut minion =
+            crate::entities::Minion::new(41, 20, crate::entities::MinionClass::Worker, 0, 0);
         minion.entity.hp = 5; // damage it
 
         let mut minions = vec![minion];
@@ -892,7 +1084,8 @@ mod tests {
         map.set_tile(medbay_pos.0, medbay_pos.1, crate::tiles::TileType::Medbay);
         map.powered.insert(medbay_pos);
 
-        let mut minion = crate::entities::Minion::new(50, 50, crate::entities::MinionClass::Worker, 0, 0);
+        let mut minion =
+            crate::entities::Minion::new(50, 50, crate::entities::MinionClass::Worker, 0, 0);
         minion.entity.hp = 5;
 
         let mut minions = vec![minion];
@@ -910,7 +1103,8 @@ mod tests {
         map.set_tile(medbay_pos.0, medbay_pos.1, crate::tiles::TileType::Medbay);
         // NOT powered
 
-        let mut minion = crate::entities::Minion::new(41, 20, crate::entities::MinionClass::Worker, 0, 0);
+        let mut minion =
+            crate::entities::Minion::new(41, 20, crate::entities::MinionClass::Worker, 0, 0);
         minion.entity.hp = 5;
 
         let mut minions = vec![minion];
@@ -927,7 +1121,8 @@ mod tests {
         map.set_tile(11, 10, crate::tiles::TileType::TrapSpike);
         // Trap is NOT in powered set
 
-        let tech = crate::entities::Minion::new(10, 10, crate::entities::MinionClass::Technician, 0, 0);
+        let tech =
+            crate::entities::Minion::new(10, 10, crate::entities::MinionClass::Technician, 0, 0);
         let mut minions = vec![tech];
 
         cs.process_technician_repairs(&mut map, &mut minions);
@@ -942,7 +1137,8 @@ mod tests {
         let mut map = crate::map::GameMap::new(80, 40);
         map.set_tile(11, 10, crate::tiles::TileType::TrapSpike);
 
-        let worker = crate::entities::Minion::new(10, 10, crate::entities::MinionClass::Worker, 0, 0);
+        let worker =
+            crate::entities::Minion::new(10, 10, crate::entities::MinionClass::Worker, 0, 0);
         let mut minions = vec![worker];
 
         cs.process_technician_repairs(&mut map, &mut minions);
@@ -983,9 +1179,7 @@ mod tests {
     fn superpower_death_ray_kills_agents() {
         let mut cs = CombatSystem::new();
         let mut player = Player::new(40, 20);
-        let mut agents = vec![
-            Agent::new(41, 20, "investigator", 0),
-        ];
+        let mut agents = vec![Agent::new(41, 20, "investigator", 0)];
         let mut minions = Vec::new();
         let map = GameMap::new(80, 40);
 
@@ -997,7 +1191,10 @@ mod tests {
             unlock_key: "test",
             unlock_notoriety: 0,
             range: 8,
-            effect: crate::superpowers::SuperpowerEffect::LineDamage { damage: 25, length: 8 },
+            effect: crate::superpowers::SuperpowerEffect::LineDamage {
+                damage: 25,
+                length: 8,
+            },
         };
 
         cs.activate_power(&power, &mut player, &mut agents, &mut minions, &map);
@@ -1033,14 +1230,19 @@ mod tests {
         let mut cs = CombatSystem::new();
         let mut player = Player::new(40, 20);
         player.invulnerability_turns = 3;
-        let mut agents = vec![
-            Agent::new(40, 20, "soldier", 0),
-        ];
+        let mut agents = vec![Agent::new(40, 20, "soldier", 0)];
         let mut minions = Vec::new();
         let mut henchmen = Vec::new();
         let mut map = GameMap::new(80, 40);
 
-        let died = cs.process_agent_turn(&mut map, &mut player, &mut agents, &mut minions, &mut henchmen, (40, 20));
+        let died = cs.process_agent_turn(
+            &mut map,
+            &mut player,
+            &mut agents,
+            &mut minions,
+            &mut henchmen,
+            (40, 20),
+        );
         assert!(!died); // Should be blocked by invulnerability
     }
 }
diff --git a/src/entities/agent.rs b/src/entities/agent.rs
index 19b2dff..43c0f8d 100644
--- a/src/entities/agent.rs
+++ b/src/entities/agent.rs
@@ -3,9 +3,9 @@
 
 use rand::Rng;
 
+use super::core::Entity;
 use crate::map::GameMap;
 use crate::tiles::{TileType, TrapEffect};
-use super::core::Entity;
 
 // ─── Agent Types ────────────────────────────────────────────────
 
@@ -37,50 +37,80 @@ pub const AGENT_TYPES: &[(&str, AgentConfig)] = &[
     (
         "investigator",
         AgentConfig {
-            name: "Investigator", hp: 25, damage: 5, char: 'i',
+            name: "Investigator",
+            hp: 25,
+            damage: 5,
+            char: 'i',
             color: crossterm::style::Color::Blue,
-            speed: 1, trap_resist: 0.1, can_detect_traps: true,
-            security_bypass: 1, agent_type: AgentType::Investigator,
+            speed: 1,
+            trap_resist: 0.1,
+            can_detect_traps: true,
+            security_bypass: 1,
+            agent_type: AgentType::Investigator,
             heat_to_spawn: 0,
         },
     ),
     (
         "thief",
         AgentConfig {
-            name: "Thief", hp: 20, damage: 8, char: 't',
+            name: "Thief",
+            hp: 20,
+            damage: 8,
+            char: 't',
             color: crossterm::style::Color::Green,
-            speed: 2, trap_resist: 0.3, can_detect_traps: true,
-            security_bypass: 1, agent_type: AgentType::Thief,
+            speed: 2,
+            trap_resist: 0.3,
+            can_detect_traps: true,
+            security_bypass: 1,
+            agent_type: AgentType::Thief,
             heat_to_spawn: 20,
         },
     ),
     (
         "saboteur",
         AgentConfig {
-            name: "Saboteur", hp: 30, damage: 12, char: 's',
+            name: "Saboteur",
+            hp: 30,
+            damage: 12,
+            char: 's',
             color: crossterm::style::Color::Yellow,
-            speed: 1, trap_resist: 0.2, can_detect_traps: true,
-            security_bypass: 2, agent_type: AgentType::Saboteur,
+            speed: 1,
+            trap_resist: 0.2,
+            can_detect_traps: true,
+            security_bypass: 2,
+            agent_type: AgentType::Saboteur,
             heat_to_spawn: 40,
         },
     ),
     (
         "soldier",
         AgentConfig {
-            name: "Soldier", hp: 50, damage: 15, char: 'S',
+            name: "Soldier",
+            hp: 50,
+            damage: 15,
+            char: 'S',
             color: crossterm::style::Color::Red,
-            speed: 1, trap_resist: 0.1, can_detect_traps: false,
-            security_bypass: 2, agent_type: AgentType::Soldier,
+            speed: 1,
+            trap_resist: 0.1,
+            can_detect_traps: false,
+            security_bypass: 2,
+            agent_type: AgentType::Soldier,
             heat_to_spawn: 30,
         },
     ),
     (
         "super_agent",
         AgentConfig {
-            name: "Super Agent", hp: 150, damage: 25, char: 'X',
+            name: "Super Agent",
+            hp: 150,
+            damage: 25,
+            char: 'X',
             color: crossterm::style::Color::Magenta,
-            speed: 1, trap_resist: 0.5, can_detect_traps: true,
-            security_bypass: 3, agent_type: AgentType::SuperAgent,
+            speed: 1,
+            trap_resist: 0.5,
+            can_detect_traps: true,
+            security_bypass: 3,
+            agent_type: AgentType::SuperAgent,
             heat_to_spawn: 80,
         },
     ),
@@ -132,14 +162,18 @@ impl Agent {
 
         Self {
             entity: Entity {
-                x, y,
+                x,
+                y,
                 name: config.name.to_string(),
-                max_hp: hp, hp,
+                max_hp: hp,
+                hp,
                 damage,
                 char: config.char,
                 color: config.color,
                 alive: true,
-                stun_turns: 0, poison_turns: 0, poison_dmg: 0,
+                stun_turns: 0,
+                poison_turns: 0,
+                poison_dmg: 0,
             },
             agent_type: config.agent_type,
             speed: config.speed,
@@ -166,7 +200,12 @@ impl Agent {
         avoid: &std::collections::HashSet<(i32, i32)>,
     ) -> bool {
         self.path = game_map
-            .find_path_with_security((self.entity.x, self.entity.y), target, avoid, self.security_bypass)
+            .find_path_with_security(
+                (self.entity.x, self.entity.y),
+                target,
+                avoid,
+                self.security_bypass,
+            )
             .unwrap_or_default();
         !self.path.is_empty()
     }
@@ -192,7 +231,11 @@ impl Agent {
                 let vaults = game_map.tiles_of_type(TileType::Vault);
                 let loot_rooms = game_map.tiles_of_type(TileType::LootRoom);
                 let targets = [&vaults[..], &loot_rooms[..]].concat();
-                if targets.is_empty() { throne } else { targets[0] }
+                if targets.is_empty() {
+                    throne
+                } else {
+                    targets[0]
+                }
             }
             AgentType::Saboteur => {
                 let cores = game_map.tiles_of_type(TileType::PowerCore);
@@ -211,7 +254,11 @@ impl Agent {
 
             // Agents with trap detection can avoid traps 50% of the time
             if self.can_detect_traps && rng.random_range(0.0..1.0) < 0.5 {
-                messages.push(format!("{} detects and avoids the {}!", self.entity.name, tile.name()));
+                messages.push(format!(
+                    "{} detects and avoids the {}!",
+                    self.entity.name,
+                    tile.name()
+                ));
                 // Remember this trap location for future pathing
                 self.known_traps.insert((self.entity.x, self.entity.y));
                 return messages;
@@ -232,7 +279,9 @@ impl Agent {
             self.entity.take_damage(dmg);
             messages.push(format!(
                 "{} triggers {}! ({} dmg)",
-                self.entity.name, tile.name(), dmg
+                self.entity.name,
+                tile.name(),
+                dmg
             ));
 
             if let Some(effect) = tile.trap_effect() {
@@ -270,7 +319,8 @@ impl Agent {
     /// Called after an agent triggers or detects a trap.
     pub fn share_trap_knowledge(agents: &mut [Agent]) {
         // Collect all known traps from agents that have seen traps
-        let all_known: std::collections::HashSet<(i32, i32)> = agents.iter()
+        let all_known: std::collections::HashSet<(i32, i32)> = agents
+            .iter()
             .filter(|a| a.entity.alive)
             .flat_map(|a| a.known_traps.iter())
             .copied()
@@ -286,7 +336,8 @@ impl Agent {
 
     pub fn get_splash_info(&self, game_map: &GameMap) -> Option<(i32, (i32, i32))> {
         let tile = game_map.get_tile(self.entity.x, self.entity.y);
-        if tile == TileType::TrapFire && game_map.powered.contains(&(self.entity.x, self.entity.y)) {
+        if tile == TileType::TrapFire && game_map.powered.contains(&(self.entity.x, self.entity.y))
+        {
             Some((tile.trap_damage() / 2, (self.entity.x, self.entity.y)))
         } else {
             None
@@ -295,7 +346,8 @@ impl Agent {
 
     pub fn get_pushback_info(&self, game_map: &GameMap) -> Option<(i32, i32)> {
         let tile = game_map.get_tile(self.entity.x, self.entity.y);
-        if tile == TileType::TrapWind && game_map.powered.contains(&(self.entity.x, self.entity.y)) {
+        if tile == TileType::TrapWind && game_map.powered.contains(&(self.entity.x, self.entity.y))
+        {
             Some((self.entity.x, self.entity.y))
         } else {
             None
@@ -337,12 +389,20 @@ impl Agent {
             if next_tile.is_door() {
                 let sec_level = next_tile.security_level();
                 if sec_level > self.security_bypass {
-                    messages.push(format!("{} can't breach {}!", self.entity.name, next_tile.name()));
+                    messages.push(format!(
+                        "{} can't breach {}!",
+                        self.entity.name,
+                        next_tile.name()
+                    ));
                     self.moves_left = 0;
                     break;
                 }
                 game_map.set_tile(next_pos.0, next_pos.1, TileType::Floor);
-                messages.push(format!("{} breaches {}!", self.entity.name, next_tile.name()));
+                messages.push(format!(
+                    "{} breaches {}!",
+                    self.entity.name,
+                    next_tile.name()
+                ));
                 self.moves_left = 0;
                 break;
             }
@@ -350,7 +410,9 @@ impl Agent {
             // Saboteurs destroy traps they stand on
             if self.agent_type == AgentType::Saboteur {
                 let current_tile = game_map.get_tile(self.entity.x, self.entity.y);
-                if current_tile.is_trap() && game_map.powered.contains(&(self.entity.x, self.entity.y)) {
+                if current_tile.is_trap()
+                    && game_map.powered.contains(&(self.entity.x, self.entity.y))
+                {
                     game_map.set_tile(self.entity.x, self.entity.y, TileType::Floor);
                     messages.push(format!("{} sabotages a trap!", self.entity.name));
                 }
@@ -470,30 +532,51 @@ mod tests {
     #[test]
     fn agent_configs_have_positive_hp() {
         for (_, config) in AGENT_TYPES {
-            assert!(config.hp > 0, "Agent {} should have positive HP", config.name);
+            assert!(
+                config.hp > 0,
+                "Agent {} should have positive HP",
+                config.name
+            );
         }
     }
 
     #[test]
     fn agent_configs_have_positive_damage() {
         for (_, config) in AGENT_TYPES {
-            assert!(config.damage > 0, "Agent {} should have positive damage", config.name);
+            assert!(
+                config.damage > 0,
+                "Agent {} should have positive damage",
+                config.name
+            );
         }
     }
 
     #[test]
     fn super_agent_is_strongest() {
-        let sa = AGENT_TYPES.iter().find(|(_, c)| c.agent_type == AgentType::SuperAgent).unwrap().1;
+        let sa = AGENT_TYPES
+            .iter()
+            .find(|(_, c)| c.agent_type == AgentType::SuperAgent)
+            .unwrap()
+            .1;
         for (_, config) in AGENT_TYPES {
-            if config.agent_type == AgentType::SuperAgent { continue; }
+            if config.agent_type == AgentType::SuperAgent {
+                continue;
+            }
             assert!(sa.hp >= config.hp, "Super Agent should have most HP");
-            assert!(sa.damage >= config.damage, "Super Agent should have most damage");
+            assert!(
+                sa.damage >= config.damage,
+                "Super Agent should have most damage"
+            );
         }
     }
 
     #[test]
     fn investigator_has_security_bypass_1() {
-        let inv = AGENT_TYPES.iter().find(|(_, c)| c.agent_type == AgentType::Investigator).unwrap().1;
+        let inv = AGENT_TYPES
+            .iter()
+            .find(|(_, c)| c.agent_type == AgentType::Investigator)
+            .unwrap()
+            .1;
         assert_eq!(inv.security_bypass, 1);
     }
 
@@ -524,7 +607,10 @@ mod tests {
         let entries = vec![(5, 0)];
         let low = generate_agent_wave(1, 5, &entries);
         let high = generate_agent_wave(1, 50, &entries);
-        assert!(high.len() >= low.len(), "Higher heat should produce at least as many agents");
+        assert!(
+            high.len() >= low.len(),
+            "Higher heat should produce at least as many agents"
+        );
     }
 
     #[test]
@@ -575,14 +661,19 @@ mod tests {
         let entries = vec![(0, 0), (79, 0)];
         let wave1 = generate_agent_wave(1, 10, &entries);
         let wave5 = generate_agent_wave(5, 10, &entries);
-        assert!(wave5.len() >= wave1.len(), "Higher waves should have more agents");
+        assert!(
+            wave5.len() >= wave1.len(),
+            "Higher waves should have more agents"
+        );
     }
 
     #[test]
     fn agent_hp_scales_with_wave() {
         let wave1_agent = Agent::new(5, 5, "investigator", 1);
         let wave5_agent = Agent::new(5, 5, "investigator", 5);
-        assert!(wave5_agent.entity.max_hp > wave1_agent.entity.max_hp,
-            "Higher wave agents should have more HP");
+        assert!(
+            wave5_agent.entity.max_hp > wave1_agent.entity.max_hp,
+            "Higher wave agents should have more HP"
+        );
     }
 }
diff --git a/src/entities/core.rs b/src/entities/core.rs
index 52f894a..f3f5500 100644
--- a/src/entities/core.rs
+++ b/src/entities/core.rs
@@ -70,9 +70,11 @@ mod tests {
 
     fn test_entity() -> Entity {
         Entity {
-            x: 5, y: 5,
+            x: 5,
+            y: 5,
             name: "Test".to_string(),
-            max_hp: 100, hp: 100,
+            max_hp: 100,
+            hp: 100,
             damage: 10,
             char: '@',
             color: Color::White,
diff --git a/src/entities/henchman.rs b/src/entities/henchman.rs
index 6720d83..b04aa86 100644
--- a/src/entities/henchman.rs
+++ b/src/entities/henchman.rs
@@ -21,7 +21,8 @@ pub struct Henchman {
 impl Henchman {
     #[allow(clippy::too_many_arguments)]
     pub fn new(
-        x: i32, y: i32,
+        x: i32,
+        y: i32,
         name: &str,
         char: char,
         ability: HenchmanAbility,
@@ -31,14 +32,18 @@ impl Henchman {
     ) -> Self {
         Self {
             entity: Entity {
-                x, y,
+                x,
+                y,
                 name: name.to_string(),
-                max_hp: hp, hp,
+                max_hp: hp,
+                hp,
                 damage,
                 char,
                 color: crossterm::style::Color::Magenta,
                 alive: true,
-                stun_turns: 0, poison_turns: 0, poison_dmg: 0,
+                stun_turns: 0,
+                poison_turns: 0,
+                poison_dmg: 0,
             },
             special: ability,
             cooldown: 0,
@@ -120,7 +125,7 @@ mod tests {
         let roster = Henchman::starting_roster(10, 10);
         let names: Vec<&str> = roster.iter().map(|h| h.entity.name.as_str()).collect();
         for i in 0..names.len() {
-            for j in (i+1)..names.len() {
+            for j in (i + 1)..names.len() {
                 assert_ne!(names[i], names[j], "Duplicate henchman name: {}", names[i]);
             }
         }
diff --git a/src/entities/minion.rs b/src/entities/minion.rs
index 02e9bbe..20bab72 100644
--- a/src/entities/minion.rs
+++ b/src/entities/minion.rs
@@ -77,7 +77,12 @@ impl MinionClass {
     }
 
     pub fn all() -> &'static [MinionClass] {
-        &[MinionClass::Worker, MinionClass::Guard, MinionClass::Technician, MinionClass::Scientist]
+        &[
+            MinionClass::Worker,
+            MinionClass::Guard,
+            MinionClass::Technician,
+            MinionClass::Scientist,
+        ]
     }
 }
 
@@ -96,17 +101,22 @@ impl Minion {
         let base_dmg = class.base_damage() + damage_bonus;
         Self {
             entity: Entity {
-                x, y,
+                x,
+                y,
                 name: class.name().to_string(),
-                max_hp: base_hp, hp: base_hp,
+                max_hp: base_hp,
+                hp: base_hp,
                 damage: base_dmg,
                 char: class.char(),
                 color: class.color(),
                 alive: true,
-                stun_turns: 0, poison_turns: 0, poison_dmg: 0,
+                stun_turns: 0,
+                poison_turns: 0,
+                poison_dmg: 0,
             },
             class,
-            home_x: x, home_y: y,
+            home_x: x,
+            home_y: y,
             armor: if class == MinionClass::Guard { 3 } else { 0 },
         }
     }
@@ -121,7 +131,11 @@ impl Minion {
     }
 
     pub fn research_bonus(&self) -> i32 {
-        if self.class == MinionClass::Scientist && self.entity.alive { 1 } else { 0 }
+        if self.class == MinionClass::Scientist && self.entity.alive {
+            1
+        } else {
+            0
+        }
     }
 }
 
@@ -197,7 +211,7 @@ mod tests {
     fn unlock_keys_unique() {
         let keys: Vec<&str> = MinionClass::all().iter().map(|c| c.unlock_key()).collect();
         for i in 0..keys.len() {
-            for j in (i+1)..keys.len() {
+            for j in (i + 1)..keys.len() {
                 assert_ne!(keys[i], keys[j], "Duplicate unlock key: {}", keys[i]);
             }
         }
diff --git a/src/entities/mod.rs b/src/entities/mod.rs
index b278942..63a04a4 100644
--- a/src/entities/mod.rs
+++ b/src/entities/mod.rs
@@ -7,14 +7,14 @@
 //! - `henchman` — Named lieutenants with special abilities
 //! - `agent`     — Enemy agents (Investigator/Thief/Saboteur/Soldier/Super Agent)
 
+pub mod agent;
 pub mod core;
-pub mod player;
-pub mod minion;
 pub mod henchman;
-pub mod agent;
+pub mod minion;
+pub mod player;
 
 // Re-export everything for convenience
-pub use player::{Player, ActiveScheme};
-pub use minion::{Minion, MinionClass};
-pub use henchman::{Henchman, HenchmanAbility};
 pub use agent::{Agent, AgentType, generate_agent_wave};
+pub use henchman::{Henchman, HenchmanAbility};
+pub use minion::{Minion, MinionClass};
+pub use player::{ActiveScheme, Player};
diff --git a/src/entities/player.rs b/src/entities/player.rs
index a923e55..79d73e6 100644
--- a/src/entities/player.rs
+++ b/src/entities/player.rs
@@ -69,17 +69,22 @@ impl Player {
 
         Self {
             entity: Entity {
-                x, y,
+                x,
+                y,
                 name: "The Supervillain".to_string(),
-                max_hp: 100, hp: 100,
+                max_hp: 100,
+                hp: 100,
                 damage: 15,
                 char: '@',
                 color: crossterm::style::Color::Magenta,
                 alive: true,
-                stun_turns: 0, poison_turns: 0, poison_dmg: 0,
+                stun_turns: 0,
+                poison_turns: 0,
+                poison_dmg: 0,
             },
             gold: 500,
-            power: 0, power_cap: 0,
+            power: 0,
+            power_cap: 0,
             research: 0,
             minion_cap: 5,
             minion_damage_bonus: 0,
@@ -90,8 +95,12 @@ impl Player {
             power_bonus: 0,
             power_core_mk2: false,
             unlocked,
-            wave: 0, score: 0, kills: 0,
-            heat: 0, notoriety: 0, gold_income: 0,
+            wave: 0,
+            score: 0,
+            kills: 0,
+            heat: 0,
+            notoriety: 0,
+            gold_income: 0,
             loot: Vec::new(),
             active_schemes: Vec::new(),
             powers: Vec::new(),
diff --git a/src/events.rs b/src/events.rs
index 7fd5321..26b9d15 100644
--- a/src/events.rs
+++ b/src/events.rs
@@ -3,10 +3,10 @@
 //! Events add unpredictability and excitement. They fire based on wave number
 //! and turn count, with increasing probability as waves progress.
 
-use rand::Rng;
-use rand::seq::IndexedRandom;
 use crate::entities::{Agent, Minion, Player};
 use crate::map::GameMap;
+use rand::Rng;
+use rand::seq::IndexedRandom;
 
 /// A mid-wave event that can occur during the defend phase.
 #[derive(Debug, Clone)]
@@ -40,10 +40,14 @@ pub enum WaveEventType {
 /// Probability increases with wave number.
 pub fn check_for_event(wave: i32, turn: i32) -> Option<WaveEventType> {
     // Events start at wave 3
-    if wave < 3 { return None; }
+    if wave < 3 {
+        return None;
+    }
 
     // Don't fire on turn 0 (wave announcement)
-    if turn == 0 { return None; }
+    if turn == 0 {
+        return None;
+    }
 
     let mut rng = rand::rng();
 
@@ -51,7 +55,9 @@ pub fn check_for_event(wave: i32, turn: i32) -> Option<WaveEventType> {
     let base_prob = 0.05 + (wave - 3) as f32 * 0.02;
     let prob = base_prob.min(0.25); // Cap at 25%
 
-    if rng.random::<f32>() > prob { return None; }
+    if rng.random::<f32>() > prob {
+        return None;
+    }
 
     // Choose event type based on wave
     let events = available_events(wave);
@@ -111,7 +117,9 @@ pub fn process_event(
         }
 
         WaveEventType::TrapMalfunction => {
-            let traps: Vec<(i32, i32)> = game_map.powered.iter()
+            let traps: Vec<(i32, i32)> = game_map
+                .powered
+                .iter()
                 .filter(|&&(x, y)| game_map.get_tile(x, y).is_trap())
                 .copied()
                 .collect();
@@ -162,7 +170,8 @@ pub fn process_event(
         }
 
         WaveEventType::AgentRetreat => {
-            let alive_agents: Vec<usize> = agents.iter()
+            let alive_agents: Vec<usize> = agents
+                .iter()
                 .enumerate()
                 .filter(|(_, a)| a.entity.alive)
                 .map(|(i, _)| i)
@@ -183,7 +192,8 @@ pub fn process_event(
         }
 
         WaveEventType::MinionDefection => {
-            let alive_minions: Vec<usize> = minions.iter()
+            let alive_minions: Vec<usize> = minions
+                .iter()
                 .enumerate()
                 .filter(|(_, m)| m.entity.alive && m.class != crate::entities::MinionClass::Guard)
                 .map(|(i, _)| i)
@@ -217,7 +227,9 @@ pub fn process_event(
                     let missing = minion.entity.max_hp - minion.entity.hp;
                     let heal = missing.min(10);
                     minion.entity.hp += heal;
-                    if heal > 0 { healed += 1; }
+                    if heal > 0 {
+                        healed += 1;
+                    }
                 }
             }
             WaveEvent {
@@ -311,9 +323,13 @@ mod tests {
     fn minion_inspiration_boosts_damage() {
         let mut player = Player::new(40, 20);
         let mut agents: Vec<Agent> = Vec::new();
-        let mut minions = vec![
-            Minion::new(40, 21, crate::entities::MinionClass::Guard, 0, 0),
-        ];
+        let mut minions = vec![Minion::new(
+            40,
+            21,
+            crate::entities::MinionClass::Guard,
+            0,
+            0,
+        )];
         let dmg_before = minions[0].entity.damage;
         let mut map = GameMap::new(80, 40);
         let entries = map.entry_positions();
diff --git a/src/lib.rs b/src/lib.rs
index cd303e8..cfb25a2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,12 +2,12 @@
 //!
 //! Shared game logic library used by both the terminal and Bevy frontends.
 
-pub mod entities;
-pub mod tiles;
-pub mod map;
-pub mod combat;
 pub mod build;
-pub mod superpowers;
+pub mod combat;
+pub mod entities;
 pub mod events;
+pub mod map;
 pub mod save;
 pub mod sim;
+pub mod superpowers;
+pub mod tiles;
diff --git a/src/map.rs b/src/map.rs
index 7baef57..09ce588 100644
--- a/src/map.rs
+++ b/src/map.rs
@@ -39,7 +39,12 @@ impl GameMap {
                 }
             }
         }
-        Self { width, height, tiles, powered }
+        Self {
+            width,
+            height,
+            tiles,
+            powered,
+        }
     }
 
     fn generate_initial_lair(&mut self) {
@@ -230,7 +235,12 @@ impl GameMap {
 
     /// Adjacent walkable tiles, considering security bypass level.
     /// Security doors above the bypass level are treated as impassable.
-    pub fn adjacent_walkable_with_security(&self, x: i32, y: i32, security_bypass: i32) -> Vec<(i32, i32)> {
+    pub fn adjacent_walkable_with_security(
+        &self,
+        x: i32,
+        y: i32,
+        security_bypass: i32,
+    ) -> Vec<(i32, i32)> {
         let dirs = [(0, -1), (0, 1), (-1, 0), (1, 0)];
         dirs.iter()
             .filter_map(|&(dx, dy)| {
@@ -274,7 +284,9 @@ impl GameMap {
         came_from.insert(start, None);
 
         while let Some(current) = queue.pop_front() {
-            for neighbor in self.adjacent_walkable_with_security(current.0, current.1, security_bypass) {
+            for neighbor in
+                self.adjacent_walkable_with_security(current.0, current.1, security_bypass)
+            {
                 if came_from.contains_key(&neighbor) || avoid.contains(&neighbor) {
                     continue;
                 }
@@ -398,11 +410,17 @@ mod tests {
 
         // Agent with bypass 3 can path through
         let path_high = map.find_path_with_security((35, 20), (45, 20), &avoid, 3);
-        assert!(path_high.is_some(), "Agent with bypass 3 should path through sec door 3");
+        assert!(
+            path_high.is_some(),
+            "Agent with bypass 3 should path through sec door 3"
+        );
 
         // Agent with bypass 1 cannot path through directly, but can go around
         let path_low = map.find_path_with_security((35, 20), (45, 20), &avoid, 1);
-        assert!(path_low.is_some(), "Agent with bypass 1 should find alternate route around door");
+        assert!(
+            path_low.is_some(),
+            "Agent with bypass 1 should find alternate route around door"
+        );
     }
 
     #[test]
@@ -419,7 +437,10 @@ mod tests {
     fn new_map_has_guard_post() {
         let map = GameMap::new(80, 40);
         let guard_posts = map.tiles_of_type(TileType::GuardPost);
-        assert!(!guard_posts.is_empty(), "Map should have a starting guard post");
+        assert!(
+            !guard_posts.is_empty(),
+            "Map should have a starting guard post"
+        );
     }
 
     #[test]
@@ -446,6 +467,9 @@ mod tests {
         let cores = map.tiles_of_type(TileType::PowerCore);
         map.update_power(&cores);
         assert!(map.powered.contains(&(10, 10)));
-        assert!(!map.powered.contains(&(12, 10)), "Power should not propagate through walls");
+        assert!(
+            !map.powered.contains(&(12, 10)),
+            "Power should not propagate through walls"
+        );
     }
 }
diff --git a/src/save.rs b/src/save.rs
index 7cd7756..2c02de2 100644
--- a/src/save.rs
+++ b/src/save.rs
@@ -63,7 +63,8 @@ pub fn save_game(state: &SaveState) -> Result<(), String> {
     lines.push("SUPERVILLAIN_SAVE_v1".to_string());
 
     // Player
-    lines.push(format!("PLAYER {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}",
+    lines.push(format!(
+        "PLAYER {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}",
         state.player.entity.x,
         state.player.entity.y,
         state.player.entity.hp,
@@ -84,7 +85,8 @@ pub fn save_game(state: &SaveState) -> Result<(), String> {
         state.player.score,
         state.player.kills,
     ));
-    lines.push(format!("PLAYER_EXTRA {} {} {} {}",
+    lines.push(format!(
+        "PLAYER_EXTRA {} {} {} {}",
         state.player.heat,
         state.player.notoriety,
         state.player.gold_income,
@@ -100,7 +102,8 @@ pub fn save_game(state: &SaveState) -> Result<(), String> {
 
     // Active schemes
     for scheme in &state.player.active_schemes {
-        lines.push(format!("SCHEME {} {} {} {} {} {}",
+        lines.push(format!(
+            "SCHEME {} {} {} {} {} {}",
             scheme.name,
             scheme.turns_remaining,
             scheme.gold_reward,
@@ -112,24 +115,23 @@ pub fn save_game(state: &SaveState) -> Result<(), String> {
 
     // Powers
     for power in &state.player.powers {
-        lines.push(format!("POWER {} {} {}",
-            power.unlock_key,
-            power.current_cooldown,
-            power.cooldown,
+        lines.push(format!(
+            "POWER {} {} {}",
+            power.unlock_key, power.current_cooldown, power.cooldown,
         ));
     }
     lines.push(format!("INVULN {}", state.player.invulnerability_turns));
 
     // Map
-    lines.push(format!("MAP {} {} {} {}",
-        state.map_width,
-        state.map_height,
-        state.map_throne.0,
-        state.map_throne.1,
+    lines.push(format!(
+        "MAP {} {} {} {}",
+        state.map_width, state.map_height, state.map_throne.0, state.map_throne.1,
     ));
 
     // Entries
-    let entries: Vec<String> = state.map_entries.iter()
+    let entries: Vec<String> = state
+        .map_entries
+        .iter()
         .map(|(x, y)| format!("{}:{}", x, y))
         .collect();
     lines.push(format!("ENTRIES {}", entries.join(",")));
@@ -146,14 +148,17 @@ pub fn save_game(state: &SaveState) -> Result<(), String> {
     }
 
     // Powered tiles
-    let powered: Vec<String> = state.map_powered.iter()
+    let powered: Vec<String> = state
+        .map_powered
+        .iter()
         .map(|(x, y)| format!("{}:{}", x, y))
         .collect();
     lines.push(format!("POWERED {}", powered.join(",")));
 
     // Minions
     for m in &state.minions {
-        lines.push(format!("MINION {} {} {} {} {} {} {}",
+        lines.push(format!(
+            "MINION {} {} {} {} {} {} {}",
             m.entity.x,
             m.entity.y,
             m.entity.hp,
@@ -166,7 +171,8 @@ pub fn save_game(state: &SaveState) -> Result<(), String> {
 
     // Henchmen
     for h in &state.henchmen {
-        lines.push(format!("HENCHMAN {} {} {} {} {} {}",
+        lines.push(format!(
+            "HENCHMAN {} {} {} {} {} {}",
             h.entity.x,
             h.entity.y,
             h.entity.hp,
@@ -190,8 +196,8 @@ pub fn save_game(state: &SaveState) -> Result<(), String> {
 
 /// Load game state from disk.
 pub fn load_game() -> Result<SaveState, String> {
-    let content = fs::read_to_string(save_path())
-        .map_err(|e| format!("Failed to read save: {}", e))?;
+    let content =
+        fs::read_to_string(save_path()).map_err(|e| format!("Failed to read save: {}", e))?;
 
     let lines: Vec<&str> = content.lines().collect();
 
@@ -242,51 +248,66 @@ pub fn load_game() -> Result<SaveState, String> {
 
     for line in &lines[1..] {
         let parts: Vec<&str> = line.splitn(2, ' ').collect();
-        if parts.is_empty() { continue; }
+        if parts.is_empty() {
+            continue;
+        }
         let key = parts[0];
         let value = if parts.len() > 1 { parts[1] } else { "" };
 
         match key {
             "PLAYER" => {
-                let v: Vec<i32> = value.split_whitespace()
+                let v: Vec<i32> = value
+                    .split_whitespace()
                     .filter_map(|s| s.parse().ok())
                     .collect();
                 if v.len() >= 19 {
-                    player_x = v[0]; player_y = v[1];
-                    player_hp = v[2]; player_max_hp = v[3]; player_damage = v[4];
-                    player_gold = v[5]; player_power = v[6]; player_power_cap = v[7];
-                    player_research = v[8]; player_minion_cap = v[9];
-                    player_minion_dmg_bonus = v[10]; player_minion_hp_bonus = v[11];
-                    player_trap_dmg_bonus = v[12]; player_research_bonus = v[13];
-                    player_heat_red_bonus = v[14]; player_power_bonus = v[15];
-                    player_wave = v[16]; player_score = v[17]; player_kills = v[18];
+                    player_x = v[0];
+                    player_y = v[1];
+                    player_hp = v[2];
+                    player_max_hp = v[3];
+                    player_damage = v[4];
+                    player_gold = v[5];
+                    player_power = v[6];
+                    player_power_cap = v[7];
+                    player_research = v[8];
+                    player_minion_cap = v[9];
+                    player_minion_dmg_bonus = v[10];
+                    player_minion_hp_bonus = v[11];
+                    player_trap_dmg_bonus = v[12];
+                    player_research_bonus = v[13];
+                    player_heat_red_bonus = v[14];
+                    player_power_bonus = v[15];
+                    player_wave = v[16];
+                    player_score = v[17];
+                    player_kills = v[18];
                 }
             }
             "PLAYER_EXTRA" => {
-                let v: Vec<i32> = value.split_whitespace()
+                let v: Vec<i32> = value
+                    .split_whitespace()
                     .filter_map(|s| s.parse().ok())
                     .collect();
                 if v.len() >= 4 {
-                    player_heat = v[0]; player_notoriety = v[1];
-                    player_gold_income = v[2]; player_core_mk2 = v[3] != 0;
+                    player_heat = v[0];
+                    player_notoriety = v[1];
+                    player_gold_income = v[2];
+                    player_core_mk2 = v[3] != 0;
                 }
             }
-            "UNLOCKS"
-                if !value.is_empty() => {
-                    for u in value.split(',') {
-                        if !u.is_empty() {
-                            unlocks.insert(u.to_string());
-                        }
+            "UNLOCKS" if !value.is_empty() => {
+                for u in value.split(',') {
+                    if !u.is_empty() {
+                        unlocks.insert(u.to_string());
                     }
                 }
-            "LOOT"
-                if !value.is_empty() => {
-                    for l in value.split(',') {
-                        if !l.is_empty() {
-                            loot.push(l.to_string());
-                        }
+            }
+            "LOOT" if !value.is_empty() => {
+                for l in value.split(',') {
+                    if !l.is_empty() {
+                        loot.push(l.to_string());
                     }
                 }
+            }
             "SCHEME" => {
                 let v: Vec<&str> = value.split_whitespace().collect();
                 if v.len() >= 6 {
@@ -317,39 +338,35 @@ pub fn load_game() -> Result<SaveState, String> {
                 invulnerability_turns = value.parse().unwrap_or(0);
             }
             "MAP" => {
-                let v: Vec<i32> = value.split_whitespace()
+                let v: Vec<i32> = value
+                    .split_whitespace()
                     .filter_map(|s| s.parse().ok())
                     .collect();
                 if v.len() >= 4 {
-                    map_width = v[0]; map_height = v[1];
+                    map_width = v[0];
+                    map_height = v[1];
                     map_throne = (v[2], v[3]);
                 }
             }
-            "ENTRIES"
-                if !value.is_empty() => {
-                    for e in value.split(',') {
-                        let parts: Vec<i32> = e.split(':')
-                            .filter_map(|s| s.parse().ok())
-                            .collect();
-                        if parts.len() == 2 {
-                            map_entries.push((parts[0], parts[1]));
-                        }
+            "ENTRIES" if !value.is_empty() => {
+                for e in value.split(',') {
+                    let parts: Vec<i32> = e.split(':').filter_map(|s| s.parse().ok()).collect();
+                    if parts.len() == 2 {
+                        map_entries.push((parts[0], parts[1]));
                     }
                 }
+            }
             "TILES" => {
                 tile_rows.push(value.to_string());
             }
-            "POWERED"
-                if !value.is_empty() => {
-                    for p in value.split(',') {
-                        let parts: Vec<i32> = p.split(':')
-                            .filter_map(|s| s.parse().ok())
-                            .collect();
-                        if parts.len() == 2 {
-                            map_powered.insert((parts[0], parts[1]));
-                        }
+            "POWERED" if !value.is_empty() => {
+                for p in value.split(',') {
+                    let parts: Vec<i32> = p.split(':').filter_map(|s| s.parse().ok()).collect();
+                    if parts.len() == 2 {
+                        map_powered.insert((parts[0], parts[1]));
                     }
                 }
+            }
             "MINION" => {
                 let v: Vec<&str> = value.split_whitespace().collect();
                 if v.len() >= 7 {
@@ -550,15 +567,34 @@ mod tests {
     #[test]
     fn tile_char_roundtrip() {
         let tiles = [
-            TileType::Floor, TileType::Wall, TileType::Rock, TileType::Throne,
-            TileType::Entry, TileType::PowerCore, TileType::Lab, TileType::Vault,
-            TileType::Barracks, TileType::GuardPost, TileType::Medbay,
-            TileType::TrainingRoom, TileType::Hotel, TileType::Freezer,
-            TileType::FakeEntry, TileType::Door, TileType::SecurityDoor1,
-            TileType::SecurityDoor2, TileType::SecurityDoor3,
-            TileType::TrapSpike, TileType::TrapFire, TileType::TrapElec,
-            TileType::TrapGas, TileType::TrapLaser, TileType::TrapWind,
-            TileType::Armory, TileType::ControlRoom, TileType::LootRoom,
+            TileType::Floor,
+            TileType::Wall,
+            TileType::Rock,
+            TileType::Throne,
+            TileType::Entry,
+            TileType::PowerCore,
+            TileType::Lab,
+            TileType::Vault,
+            TileType::Barracks,
+            TileType::GuardPost,
+            TileType::Medbay,
+            TileType::TrainingRoom,
+            TileType::Hotel,
+            TileType::Freezer,
+            TileType::FakeEntry,
+            TileType::Door,
+            TileType::SecurityDoor1,
+            TileType::SecurityDoor2,
+            TileType::SecurityDoor3,
+            TileType::TrapSpike,
+            TileType::TrapFire,
+            TileType::TrapElec,
+            TileType::TrapGas,
+            TileType::TrapLaser,
+            TileType::TrapWind,
+            TileType::Armory,
+            TileType::ControlRoom,
+            TileType::LootRoom,
         ];
         for tile in &tiles {
             let ch = tile_to_char(*tile);
diff --git a/src/sim.rs b/src/sim.rs
index 1d6b4b1..37063af 100644
--- a/src/sim.rs
+++ b/src/sim.rs
@@ -12,7 +12,7 @@
 //! countdown toward the next agency raid, and notoriety scales its strength.
 
 use crate::combat::CombatSystem;
-use crate::entities::{self, generate_agent_wave, Agent, Henchman, Minion, MinionClass, Player};
+use crate::entities::{self, Agent, Henchman, Minion, MinionClass, Player, generate_agent_wave};
 use crate::map::GameMap;
 use crate::save::SaveState;
 use crate::tiles::{self, TileType};
@@ -167,11 +167,16 @@ impl Sim {
 
     pub fn threat(&self) -> Threat {
         if let Some(raid) = &self.raid {
-            Threat::Raid { number: raid.number, turn: raid.turn }
+            Threat::Raid {
+                number: raid.number,
+                turn: raid.turn,
+            }
         } else if self.player.heat < RAID_HEAT_THRESHOLD {
             Threat::Cold
         } else {
-            Threat::Watched { ticks_left: self.next_raid_in.max(0) }
+            Threat::Watched {
+                ticks_left: self.next_raid_in.max(0),
+            }
         }
     }
 
@@ -265,8 +270,8 @@ impl Sim {
 
     fn start_raid(&mut self) {
         self.player.wave += 1;
-        let strength = (1 + self.player.notoriety / 25 + self.player.heat / 30)
-            .min(RAID_STRENGTH_CAP);
+        let strength =
+            (1 + self.player.notoriety / 25 + self.player.heat / 30).min(RAID_STRENGTH_CAP);
 
         let entries = self.map.entry_positions();
         let throne = self.map.throne_pos().unwrap_or((40, 20));
@@ -293,7 +298,10 @@ impl Sim {
             strength,
         });
 
-        self.push_log(format!("=== RAID {} — AGENCY FORCES INBOUND! ===", self.player.wave));
+        self.push_log(format!(
+            "=== RAID {} — AGENCY FORCES INBOUND! ===",
+            self.player.wave
+        ));
         self.push_log(format!("{count} agents are breaching the lair!"));
 
         // Staff empty guard posts.
@@ -533,7 +541,10 @@ impl Sim {
 
         let alive = self.minions.iter().filter(|m| m.entity.alive).count() as i32;
         if alive < scheme.minion_cost {
-            self.push_log(format!("Need {} minions for this scheme!", scheme.minion_cost));
+            self.push_log(format!(
+                "Need {} minions for this scheme!",
+                scheme.minion_cost
+            ));
             return false;
         }
 
@@ -744,7 +755,12 @@ impl Sim {
             map_throne: self.map.throne_pos().unwrap_or((40, 20)),
             map_entries: self.map.entry_positions(),
             wave: self.player.wave,
-            phase: if self.game_over { "GameOver" } else { "Running" }.to_string(),
+            phase: if self.game_over {
+                "GameOver"
+            } else {
+                "Running"
+            }
+            .to_string(),
             sim_tick: self.tick,
             next_raid_in: self.next_raid_in,
         }
@@ -838,7 +854,10 @@ mod tests {
         sim.player.notoriety = 50;
         sim.next_raid_in = 5;
         run(&mut sim, 5);
-        assert!(sim.raid_active(), "countdown at high heat must trigger a raid");
+        assert!(
+            sim.raid_active(),
+            "countdown at high heat must trigger a raid"
+        );
         assert!(!sim.agents.is_empty(), "raid should spawn agents");
         assert_eq!(sim.player.wave, 1);
     }
@@ -874,7 +893,10 @@ mod tests {
         // Let the announcement pass and one combat turn resolve.
         run(&mut sim, 10);
         assert!(!sim.raid_active(), "raid should end when all agents die");
-        assert!(sim.next_raid_in >= RAID_COUNTDOWN_MIN, "next raid rescheduled");
+        assert!(
+            sim.next_raid_in >= RAID_COUNTDOWN_MIN,
+            "next raid rescheduled"
+        );
     }
 
     #[test]
@@ -887,7 +909,10 @@ mod tests {
         let duration = schemes[0].duration_turns as u64;
 
         run(&mut sim, SLOW_INTERVAL * duration);
-        assert!(sim.player.active_schemes.is_empty(), "scheme should complete");
+        assert!(
+            sim.player.active_schemes.is_empty(),
+            "scheme should complete"
+        );
         assert!(
             sim.player.gold >= gold + schemes[0].gold_reward,
             "scheme gold should be paid"
@@ -918,7 +943,10 @@ mod tests {
         let mut sim = Sim::new();
         sim.player.heat = 50;
         run(&mut sim, SLOW_INTERVAL * 3);
-        assert!(sim.player.heat < 50, "heat should decay on the slow cadence");
+        assert!(
+            sim.player.heat < 50,
+            "heat should decay on the slow cadence"
+        );
     }
 
     #[test]
diff --git a/src/superpowers.rs b/src/superpowers.rs
index 1477520..b5a37a1 100644
--- a/src/superpowers.rs
+++ b/src/superpowers.rs
@@ -34,7 +34,10 @@ pub enum SuperpowerEffect {
     /// Push all enemies away from the Supervillain
     Repulsion { distance: i32 },
     /// Drain HP from nearby enemies, healing self
-    DrainLife { damage_per_enemy: i32, heal_per_enemy: i32 },
+    DrainLife {
+        damage_per_enemy: i32,
+        heal_per_enemy: i32,
+    },
     /// Become invulnerable for N turns
     Invulnerability { turns: i32 },
     /// Teleport to any visible tile
@@ -78,7 +81,10 @@ pub fn all_superpowers() -> Vec<Superpower> {
             unlock_key: "power_death_ray",
             unlock_notoriety: 30,
             range: 8,
-            effect: SuperpowerEffect::LineDamage { damage: 25, length: 8 },
+            effect: SuperpowerEffect::LineDamage {
+                damage: 25,
+                length: 8,
+            },
         },
         Superpower {
             name: "Dark Regeneration",
@@ -118,7 +124,10 @@ pub fn all_superpowers() -> Vec<Superpower> {
             unlock_key: "power_drain",
             unlock_notoriety: 35,
             range: 4,
-            effect: SuperpowerEffect::DrainLife { damage_per_enemy: 10, heal_per_enemy: 5 },
+            effect: SuperpowerEffect::DrainLife {
+                damage_per_enemy: 10,
+                heal_per_enemy: 5,
+            },
         },
         Superpower {
             name: "Impenetrable Shield",
@@ -148,7 +157,10 @@ pub fn all_superpowers() -> Vec<Superpower> {
             unlock_key: "power_plague",
             unlock_notoriety: 45,
             range: 6,
-            effect: SuperpowerEffect::AoePoison { turns: 3, damage: 5 },
+            effect: SuperpowerEffect::AoePoison {
+                turns: 3,
+                damage: 5,
+            },
         },
     ]
 }
@@ -157,9 +169,7 @@ pub fn all_superpowers() -> Vec<Superpower> {
 pub fn get_unlocked_powers(player_unlocks: &HashSet<String>, notoriety: i32) -> Vec<Superpower> {
     all_superpowers()
         .into_iter()
-        .filter(|p| {
-            player_unlocks.contains(p.unlock_key) && notoriety >= p.unlock_notoriety
-        })
+        .filter(|p| player_unlocks.contains(p.unlock_key) && notoriety >= p.unlock_notoriety)
         .collect()
 }
 
@@ -169,7 +179,11 @@ pub fn power_research_unlocks() -> Vec<(&'static str, i32, &'static str)> {
         ("power_evil_laugh", 50, "Evil Laugh (Stun power)"),
         ("power_regen", 80, "Dark Regeneration (Self-heal)"),
         ("power_force_wave", 120, "Force Wave (Repulsion)"),
-        ("power_summon", 150, "Emergency Reinforcements (Summon guards)"),
+        (
+            "power_summon",
+            150,
+            "Emergency Reinforcements (Summon guards)",
+        ),
         ("power_death_ray", 200, "Death Ray (Line damage)"),
         ("power_drain", 180, "Soul Drain (Life steal)"),
         ("power_blink", 220, "Blink (Teleport)"),
@@ -264,7 +278,11 @@ mod tests {
         let unlocks = power_research_unlocks();
         for power in &powers {
             let found = unlocks.iter().any(|(key, _, _)| *key == power.unlock_key);
-            assert!(found, "Power '{}' has unlock_key '{}' but no matching research entry", power.name, power.unlock_key);
+            assert!(
+                found,
+                "Power '{}' has unlock_key '{}' but no matching research entry",
+                power.name, power.unlock_key
+            );
         }
     }
 
@@ -273,7 +291,11 @@ mod tests {
         let powers = all_superpowers();
         let mut keys = std::collections::HashSet::new();
         for power in &powers {
-            assert!(keys.insert(power.unlock_key), "Duplicate unlock_key: {}", power.unlock_key);
+            assert!(
+                keys.insert(power.unlock_key),
+                "Duplicate unlock_key: {}",
+                power.unlock_key
+            );
         }
     }
 
diff --git a/src/tiles.rs b/src/tiles.rs
index 35bba17..9865f15 100644
--- a/src/tiles.rs
+++ b/src/tiles.rs
@@ -12,8 +12,8 @@ pub enum TileType {
     TrapFire,
     TrapElec,
     TrapGas,
-    TrapLaser,    // New: high damage, single target
-    TrapWind,     // New: pushes agents back
+    TrapLaser, // New: high damage, single target
+    TrapWind,  // New: pushes agents back
 
     // Rooms
     GuardPost,
@@ -36,7 +36,7 @@ pub enum TileType {
     SecurityDoor3, // Level 3 security (only Super Agents can breach)
 
     // Deception
-    FakeEntry,    // New: misleads agents into dead ends
+    FakeEntry, // New: misleads agents into dead ends
 }
 
 impl TileType {
@@ -155,7 +155,13 @@ impl TileType {
 
     pub fn power_gen(self, mk2: bool) -> i32 {
         match self {
-            Self::PowerCore => if mk2 { 20 } else { 10 },
+            Self::PowerCore => {
+                if mk2 {
+                    20
+                } else {
+                    10
+                }
+            }
             _ => 0,
         }
     }
@@ -201,23 +207,44 @@ impl TileType {
     pub fn is_walkable(self) -> bool {
         matches!(
             self,
-            Self::Floor | Self::Entry | Self::Throne
-                | Self::TrapSpike | Self::TrapFire | Self::TrapElec
-                | Self::TrapGas | Self::TrapLaser | Self::TrapWind
-                | Self::GuardPost | Self::Lab | Self::Vault
-                | Self::PowerCore | Self::Barracks | Self::Armory
-                | Self::Medbay | Self::ControlRoom | Self::TrainingRoom
-                | Self::Freezer | Self::Hotel | Self::LootRoom
-                | Self::Door | Self::SecurityDoor1 | Self::SecurityDoor2
-                | Self::SecurityDoor3 | Self::FakeEntry
+            Self::Floor
+                | Self::Entry
+                | Self::Throne
+                | Self::TrapSpike
+                | Self::TrapFire
+                | Self::TrapElec
+                | Self::TrapGas
+                | Self::TrapLaser
+                | Self::TrapWind
+                | Self::GuardPost
+                | Self::Lab
+                | Self::Vault
+                | Self::PowerCore
+                | Self::Barracks
+                | Self::Armory
+                | Self::Medbay
+                | Self::ControlRoom
+                | Self::TrainingRoom
+                | Self::Freezer
+                | Self::Hotel
+                | Self::LootRoom
+                | Self::Door
+                | Self::SecurityDoor1
+                | Self::SecurityDoor2
+                | Self::SecurityDoor3
+                | Self::FakeEntry
         )
     }
 
     pub fn is_trap(self) -> bool {
         matches!(
             self,
-            Self::TrapSpike | Self::TrapFire | Self::TrapElec
-                | Self::TrapGas | Self::TrapLaser | Self::TrapWind
+            Self::TrapSpike
+                | Self::TrapFire
+                | Self::TrapElec
+                | Self::TrapGas
+                | Self::TrapLaser
+                | Self::TrapWind
         )
     }
 
@@ -314,10 +341,29 @@ pub enum TrapEffect {
 pub fn build_categories() -> Vec<(&'static str, Vec<TileType>)> {
     use TileType::*;
     vec![
-        ("Digging", vec![Floor, Door, SecurityDoor1, SecurityDoor2, SecurityDoor3, FakeEntry]),
-        ("Traps", vec![TrapSpike, TrapFire, TrapElec, TrapGas, TrapLaser, TrapWind]),
-        ("Military", vec![GuardPost, Barracks, Armory, Medbay, TrainingRoom]),
-        ("Operations", vec![ControlRoom, Lab, Vault, PowerCore, Freezer, Hotel, LootRoom]),
+        (
+            "Digging",
+            vec![
+                Floor,
+                Door,
+                SecurityDoor1,
+                SecurityDoor2,
+                SecurityDoor3,
+                FakeEntry,
+            ],
+        ),
+        (
+            "Traps",
+            vec![TrapSpike, TrapFire, TrapElec, TrapGas, TrapLaser, TrapWind],
+        ),
+        (
+            "Military",
+            vec![GuardPost, Barracks, Armory, Medbay, TrainingRoom],
+        ),
+        (
+            "Operations",
+            vec![ControlRoom, Lab, Vault, PowerCore, Freezer, Hotel, LootRoom],
+        ),
     ]
 }
 
@@ -347,7 +393,11 @@ pub fn research_unlocks() -> Vec<(&'static str, i32, &'static str)> {
         ("power_evil_laugh", 50, "Evil Laugh (Stun power)"),
         ("power_regen", 80, "Dark Regeneration (Self-heal)"),
         ("power_force_wave", 120, "Force Wave (Repulsion)"),
-        ("power_summon", 150, "Emergency Reinforcements (Summon guards)"),
+        (
+            "power_summon",
+            150,
+            "Emergency Reinforcements (Summon guards)",
+        ),
         ("power_death_ray", 200, "Death Ray (Line damage)"),
         ("power_drain", 180, "Soul Drain (Life steal)"),
         ("power_blink", 220, "Blink (Teleport)"),
@@ -370,15 +420,96 @@ pub struct Scheme {
 
 pub fn available_schemes() -> Vec<Scheme> {
     vec![
-        Scheme { name: "Bank Heist", region: "Western Europe", gold_reward: 300, heat_cost: 15, minion_cost: 2, notoriety_reward: 5, duration_turns: 3, loot: None },
-        Scheme { name: "Art Theft", region: "Southern Europe", gold_reward: 200, heat_cost: 10, minion_cost: 1, notoriety_reward: 8, duration_turns: 2, loot: Some("Renaissance Painting") },
-        Scheme { name: "Nuclear Sabotage", region: "Eastern Europe", gold_reward: 500, heat_cost: 30, minion_cost: 4, notoriety_reward: 15, duration_turns: 5, loot: None },
-        Scheme { name: "Data Heist", region: "North America", gold_reward: 400, heat_cost: 20, minion_cost: 2, notoriety_reward: 10, duration_turns: 3, loot: Some("Encrypted Drives") },
-        Scheme { name: "Jewel Smuggling", region: "South America", gold_reward: 250, heat_cost: 8, minion_cost: 2, notoriety_reward: 3, duration_turns: 2, loot: Some("Rare Gems") },
-        Scheme { name: "Propaganda Campaign", region: "Asia", gold_reward: 100, heat_cost: 5, minion_cost: 1, notoriety_reward: 20, duration_turns: 4, loot: None },
-        Scheme { name: "Weapons Deal", region: "Africa", gold_reward: 600, heat_cost: 25, minion_cost: 3, notoriety_reward: 12, duration_turns: 4, loot: Some("Military Hardware") },
-        Scheme { name: "Satellite Hack", region: "Orbit", gold_reward: 350, heat_cost: 35, minion_cost: 3, notoriety_reward: 18, duration_turns: 6, loot: Some("Satellite Codes") },
-        Scheme { name: "Medical Research", region: "North America", gold_reward: 150, heat_cost: 12, minion_cost: 2, notoriety_reward: 6, duration_turns: 3, loot: Some("Biomedical Data") },
+        Scheme {
+            name: "Bank Heist",
+            region: "Western Europe",
+            gold_reward: 300,
+            heat_cost: 15,
+            minion_cost: 2,
+            notoriety_reward: 5,
+            duration_turns: 3,
+            loot: None,
+        },
+        Scheme {
+            name: "Art Theft",
+            region: "Southern Europe",
+            gold_reward: 200,
+            heat_cost: 10,
+            minion_cost: 1,
+            notoriety_reward: 8,
+            duration_turns: 2,
+            loot: Some("Renaissance Painting"),
+        },
+        Scheme {
+            name: "Nuclear Sabotage",
+            region: "Eastern Europe",
+            gold_reward: 500,
+            heat_cost: 30,
+            minion_cost: 4,
+            notoriety_reward: 15,
+            duration_turns: 5,
+            loot: None,
+        },
+        Scheme {
+            name: "Data Heist",
+            region: "North America",
+            gold_reward: 400,
+            heat_cost: 20,
+            minion_cost: 2,
+            notoriety_reward: 10,
+            duration_turns: 3,
+            loot: Some("Encrypted Drives"),
+        },
+        Scheme {
+            name: "Jewel Smuggling",
+            region: "South America",
+            gold_reward: 250,
+            heat_cost: 8,
+            minion_cost: 2,
+            notoriety_reward: 3,
+            duration_turns: 2,
+            loot: Some("Rare Gems"),
+        },
+        Scheme {
+            name: "Propaganda Campaign",
+            region: "Asia",
+            gold_reward: 100,
+            heat_cost: 5,
+            minion_cost: 1,
+            notoriety_reward: 20,
+            duration_turns: 4,
+            loot: None,
+        },
+        Scheme {
+            name: "Weapons Deal",
+            region: "Africa",
+            gold_reward: 600,
+            heat_cost: 25,
+            minion_cost: 3,
+            notoriety_reward: 12,
+            duration_turns: 4,
+            loot: Some("Military Hardware"),
+        },
+        Scheme {
+            name: "Satellite Hack",
+            region: "Orbit",
+            gold_reward: 350,
+            heat_cost: 35,
+            minion_cost: 3,
+            notoriety_reward: 18,
+            duration_turns: 6,
+            loot: Some("Satellite Codes"),
+        },
+        Scheme {
+            name: "Medical Research",
+            region: "North America",
+            gold_reward: 150,
+            heat_cost: 12,
+            minion_cost: 2,
+            notoriety_reward: 6,
+            duration_turns: 3,
+            loot: Some("Biomedical Data"),
+        },
     ]
 }
 
@@ -400,12 +531,36 @@ pub enum LootBonus {
 
 pub fn loot_items() -> Vec<LootItem> {
     vec![
-        LootItem { name: "Renaissance Painting", bonus_type: LootBonus::HeatReduction, bonus_value: 2 },
-        LootItem { name: "Encrypted Drives", bonus_type: LootBonus::ResearchBonus, bonus_value: 2 },
-        LootItem { name: "Rare Gems", bonus_type: LootBonus::MinionDamage, bonus_value: 3 },
-        LootItem { name: "Military Hardware", bonus_type: LootBonus::TrapDamage, bonus_value: 5 },
-        LootItem { name: "Satellite Codes", bonus_type: LootBonus::PowerBonus, bonus_value: 5 },
-        LootItem { name: "Biomedical Data", bonus_type: LootBonus::MinionHP, bonus_value: 10 },
+        LootItem {
+            name: "Renaissance Painting",
+            bonus_type: LootBonus::HeatReduction,
+            bonus_value: 2,
+        },
+        LootItem {
+            name: "Encrypted Drives",
+            bonus_type: LootBonus::ResearchBonus,
+            bonus_value: 2,
+        },
+        LootItem {
+            name: "Rare Gems",
+            bonus_type: LootBonus::MinionDamage,
+            bonus_value: 3,
+        },
+        LootItem {
+            name: "Military Hardware",
+            bonus_type: LootBonus::TrapDamage,
+            bonus_value: 5,
+        },
+        LootItem {
+            name: "Satellite Codes",
+            bonus_type: LootBonus::PowerBonus,
+            bonus_value: 5,
+        },
+        LootItem {
+            name: "Biomedical Data",
+            bonus_type: LootBonus::MinionHP,
+            bonus_value: 10,
+        },
     ]
 }
 
@@ -531,7 +686,11 @@ mod tests {
         let cats = build_categories();
         for (_name, items) in &cats {
             for &tile in items {
-                assert!(tile.build_cost() >= 0, "{:?} should have non-negative build cost", tile);
+                assert!(
+                    tile.build_cost() >= 0,
+                    "{:?} should have non-negative build cost",
+                    tile
+                );
             }
         }
     }
@@ -551,7 +710,11 @@ mod tests {
     fn schemes_have_positive_minion_cost() {
         let schemes = available_schemes();
         for s in &schemes {
-            assert!(s.minion_cost >= 0, "Scheme '{}' minion cost should be non-negative", s.name);
+            assert!(
+                s.minion_cost >= 0,
+                "Scheme '{}' minion cost should be non-negative",
+                s.name
+            );
         }
     }
 
@@ -559,7 +722,11 @@ mod tests {
     fn schemes_have_regions() {
         let schemes = available_schemes();
         for s in &schemes {
-            assert!(!s.region.is_empty(), "Scheme '{}' should have a region", s.name);
+            assert!(
+                !s.region.is_empty(),
+                "Scheme '{}' should have a region",
+                s.name
+            );
         }
     }
 }
-- 
2.51.2