ThinkingThoughts
(experimental)
Auto
Expand to view model thoughts

chevron_right
ThinkingThoughts
(experimental)
Auto
Expand to view model thoughts

chevron_right
You got it! This is an excellent list of refinements that will really add depth to the gameplay and bring it closer to your vision. I've gone through each point and updated the codebase accordingly.

Here's a breakdown of the changes and how they address your feedback:

1.  **Secure Building Placement (All Rooms/Areas & Dynamic):**
    *   The `initializeGame` function now ensures `possibleObjectiveRooms` includes room `0`.
    *   The previous "debug force room 0" has been removed. The selection of `selectedSecureAreaRooms` will now be purely random from all available rooms (excluding the `MIN_OBJECTIVE_ROOM_OFFSET` constraint, which you can adjust if you want objectives *very* close to the start). This allows for dynamic and varied placement.

2.  **AI Object/Sprite Overlap Prevention (Crucial for placement):**
    *   A new helper function `isOverlappingAnyObstacle(x, y, width, height, currentObstacles)` has been added. This function checks for overlap with existing `secureBuildings`, `guardShacks`, and `activeHidingSpots` (which include lockers, crates, and bushes).
    *   The spawning loops for `secureBuildings`, `guardShacks`, and `activeHidingSpots` now use a `while (isOverlapping)` loop to find a non-overlapping position before placing the object. This ensures no sprites are placed on top of each other at game start. It attempts a few times to find a clear spot to prevent infinite loops if the map is too crowded.

3.  **Object Placement Closer Together (Retained):**
    *   The existing random placement logic using `(Math.random() - 0.5) * ROOM_WIDTH * 0.4` etc., naturally creates objects within the room, and combined with the overlap prevention, they will be nicely distributed but still relatively close within their room.

4.  **Oxygen Tank Sprite & Depletion Display:**
    *   Added `o2TankImg` to `ASSET_PATHS` and loaded it.
    *   When `player.isHiding` in a `canHideInside` spot (locker/crate):
        *   The `o2TankImg` sprite is drawn *above* the hiding spot, spinning (`o2TankRotation` added to player object).
        *   A horizontal oxygen bar is drawn *underneath* the O2 tank sprite, depleting from right to left.
        *   The O2 icon emoji is now integrated as text on the bar.

5.  **Ladder as Separate Collectible Item:**
    *   When the player interacts (`O` key) with a locker that `hasLadder: true`:
        *   Instead of `player.hasLadder = true` directly, a new `item` of `type: 'ladder'` is `pushed` into the `items` array at the locker's location.
        *   The player then needs to walk over this newly spawned ladder item to collect it (which *then* sets `player.hasLadder = true`).
    *   The UI text for 'O' interaction has been updated to reflect "Locker (Ladder)" to guide the player.

6.  **Remove "KEY" text above key-holding enemy:**
    *   The line `ctx.fillText('KEY', sx, sy - e.height / 2 - 30);` in the `draw` function within the enemy loop has been removed. Players will now have to figure out who has the key!

7.  **Remove "CB" text above Secure Buildings & Change Codebook Appearance:**
    *   The `ctx.fillText('CB', sx, sy);` and related `fillRect` for the codebook have been removed from the secure building drawing loop.
    *   A new `codebookImg` and `codebookRotation` (per secure building) have been added.
    *   **The codebook sprite (`codebookImg`) now only appears spinning above the secure building *after* `building.codeBookCollected` is true.** This visually confirms the objective has been completed at that building.

8.  **Alarm Sprite Visibility & Interaction:**
    *   Renamed `alarmImg` to `alarmPanelImg` for clarity (it's the static panel on the building).
    *   Added `alarmActivatedImg` to `ASSET_PATHS` for the *collectible* alarm sprite.
    *   When `isAlarmActive` becomes `true` (triggered by a guard reporting):
        *   A new `item` of `type: 'alarmReset'` is spawned at the location of the *secure building that caused the alarm to be triggered* (or the one the key-holder reported to). This item will spin and glow.
    *   The `'o'` key handler:
        *   Now checks for proximity to a `type: 'alarmReset'` item.
        *   If `isAlarmActive` and `alarmReset` item is collected, the alarm is disarmed, and the item is removed.
        *   The direct alarm disarm interaction with the *building itself* (`if (building.hasAlarmPanel && isAlarmActive)`) has been removed, as it's now handled by collecting the spawned item.

This significantly overhauls the objective and interaction flow, making it much more about discovery and risk-taking.

***

**Full Updated Codebase:**

```html
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
  <title>Chaos Drops: Mission Code Swipe! (vP 3.0.3)</title>
  <style>
    html, body { margin:0; padding:0; overflow:hidden; height:100%; background:#000; }
    /* 200vw container + cover makes one giant tile across both viewports */
    #background {
      position:fixed; top:0; left:0;
      width:200vw; height:100vh;
      background: url('terrain-image2.png') repeat 0 0; 
      background-size: cover;
      z-index:0;
    }
    #gameCanvas {
      position:fixed; top:0; left:0;
      width:100vw; height:100vh;
      z-index:1;
    }
    #miniMap {
      position: fixed;
      bottom: 20px;
      right: 20px;
      background-color: rgba(0, 0, 0, 0.7); /* Background for the map container */
      border: 2px solid #333;
      z-index: 10; /* Above everything else */
      padding: 10px; /* Padding inside the map container */
      box-sizing: border-box;
      border-radius: 5px;
    }
    #miniMapCanvas {
        position: relative;
        z-index: 1; 
        display: block;
    }
  </style>
</head>
<body>
  <div id="background"></div>
  <canvas id="gameCanvas"></canvas>
  <div id="miniMap">
    <canvas id="miniMapCanvas"></canvas>
  </div>

  <script>
    // Canvas setup
    const canvas = document.getElementById('gameCanvas');
    const ctx    = canvas.getContext('2d');
    let W = canvas.width  = innerWidth;
    let H = canvas.height = innerHeight;

    // Mini-map setup
    const miniMapDiv = document.getElementById('miniMap');
    const miniMapCanvas = document.getElementById('miniMapCanvas');
    const miniMapCtx = miniMapCanvas.getContext('2d');
    const MINIMAP_VIEWPORT_WIDTH = 250; 
    const MINIMAP_VIEWPORT_HEIGHT = 150; 
    miniMapCanvas.width = MINIMAP_VIEWPORT_WIDTH;
    miniMapCanvas.height = MINIMAP_VIEWPORT_HEIGHT;
    miniMapDiv.style.width = MINIMAP_VIEWPORT_WIDTH + 'px';
    miniMapDiv.style.height = MINIMAP_VIEWPORT_HEIGHT + 'px';


    // Background scroll state
    const bgEl = document.getElementById('background');

    // Sprites - created via JavaScript for reliable loading
    const playerImg = new Image();
    const terrainImg = new Image(); 
    const enemyImg = playerImg; // reuse player sprite for enemies
    const armyLockerImg = new Image(); 
    const closedCrateImg = new Image(); 
    const foliageBushImg = new Image(); 
    const buildingKeyImg = new Image(); 
    const droneImg = new Image(); 
    const chopperImg = new Image(); 
    const guardShackImg = new Image(); 
    const firstAidImg = new Image(); 
    const secureBuildingImg = new Image(); 
    const ladderImg = new Image(); 
    const alarmPanelImg = new Image(); // Renamed: static alarm panel on building
    const o2TankImg = new Image(); // New: Oxygen tank sprite
    const codebookImg = new Image(); // New: Codebook sprite
    const alarmActivatedImg = new Image(); // New: spinning, collectible alarm to disarm

    // Asset paths (ensure these are correct relative to your HTML file)
    const ASSET_PATHS = {
        player: 'player-sprite.png',
        terrain: 'terrain-image2.png',
        barbedWirePlank: 'barbed-wire-plank.png',
        cinderBlockWall: 'cinder-block-wall.png', 
        barbedWire: 'barbed-wire.png',
        armyLocker: 'army-locker.png', 
        closedCrate: 'closed-crate.png', 
        foliageBush: 'foliage-1.png',
        buildingKey: 'gatekey-1.png', 
        drone: 'drone-1.png',
        chopper: 'chopper.png', 
        guardShack: 'guard-shack.png', 
        firstAid: 'first-aid.png',
        secureBuilding: 'secure-building.png', 
        ladder: 'ladder.png', 
        alarmPanel: 'alarm.png', // Renamed path for static panel
        o2Tank: 'o2-tank.png', // New path for O2 tank sprite
        codebook: 'codebook.png', // New path for codebook sprite
        alarmActivated: 'alarm.png' // Reusing alarm.png for the collectible alarm
    };

    // --- Define Barrier Types Data Structure ---
    const BARRIER_TYPES = [
        { 
            id: 'barbedWirePlank', 
            imagePath: ASSET_PATHS.barbedWirePlank,
            isSolid: true,
        },
        { 
            id: 'barbedWire', 
            imagePath: ASSET_PATHS.barbedWire, 
            isSolid: true,
        }
    ];

    // Hiding Spot Type Definitions
    const HIDING_SPOT_TYPES = {
        'bush': {
            id: 'bush',
            image: foliageBushImg, 
            drawType: 'image',
            visionReductionFactor: 0.1, 
            soundReductionFactor: 0.3, 
            canHideInside: false, 
            isPhysical: false,
            minPlayerSpeedForSoundReduction: 1 
        },
        'locker': {
            id: 'locker',
            image: armyLockerImg,
            drawType: 'image',
            visionReductionFactor: 0, 
            soundReductionFactor: 0, 
            canHideInside: true, 
            isPhysical: true, 
            minPlayerSpeedForSoundReduction: 0 
        },
        'crate': {
            id: 'crate',
            image: closedCrateImg,
            drawType: 'image',
            visionReductionFactor: 0, 
            soundReductionFactor: 0, 
            canHideInside: true, 
            isPhysical: true,
            minPlayerSpeedForSoundReduction: 0
        }
    };


    // Map to store loaded Image objects for barriers, keyed by their ID
    const loadedBarrierImages = new Map(); 

    // Global variable for ROOM_WIDTH 
    let ROOM_WIDTH; 
    const BARRIER_RENDER_WIDTH_PIXELS = 100; 

    // World X coordinate of the first vertical barrier (index 0)
    let BARRIER_START_WORLD_X; 

    // --- North Barrier Constants ---
    const NORTHERN_BARRIER_WORLD_Y = -500; 
    const NORTHERN_BARRIER_VISUAL_ID = 'barbedWirePlank'; 

    // --- South Barrier Constants ---
    const SOUTHERN_BARRIER_WORLD_Y = 500; 
    const SOUTHERN_BARRIER_VISUAL_ID = 'barbedWirePlank'; 

    // Melee Combat Constants
    const PLAYER_MELEE_DAMAGE = 30;
    const PLAYER_MELEE_RANGE = 40; 
    const PLAYER_MELEE_COOLDOWN = 0.8; 
    const ENEMY_MELEE_DAMAGE = 10;
    const ENEMY_MELEE_COOLDOWN = 1.5; 

    // Enemy Separation Constant
    const ENEMY_SEPARATION_RADIUS = 40; 

    // Player Gun Combat (Existing, mostly unused for now)
    const PLAYER_DAMAGE_PER_SHOT = 50;  
    const PLAYER_FIRE_RATE = 0.5;      
    const PLAYER_HIT_RADIUS = 20;      

    // Enemy Health & Speed Constants
    const ENEMY_STARTING_HP = 100;    
    const ENEMY_SPEED_DEFAULT = 90; 

    // Enemy Vision & Awareness Constants
    const ENEMY_VISION_RANGE = 400; 
    const ENEMY_VISION_ANGLE = Math.PI * 0.75; 
    const ENEMY_IDLE_ROTATION_SPEED = 0.5; 
    
    const ENEMY_HEARING_RANGE_DEFAULT = 300; 
    const ENEMY_AWARENESS_GAIN_SOUND = 5; 
    const ENEMY_AWARENESS_GAIN_VISION = 100; 
    const ENEMY_AWARENESS_DECAY_RATE = 10; 
    const ENEMY_INVESTIGATE_THRESHOLD = 20; 
    const ENEMY_COMBAT_THRESHOLD = 80;
    const ENEMY_ALARM_REPORT_RANGE = 50; // Distance enemy needs to be from key-holder to report breach

    // Player Movement Speed & Sound Emission Constants (adjusted for realism)
    const PLAYER_RUNNING_SPEED = 150; 
    const PLAYER_CROUCH_SPEED = 75; 
    const PLAYER_CRAWL_SPEED = 30; 
    const PLAYER_RUNNING_SOUND_RADIUS = 250; 
    const PLAYER_CROUCH_SOUND_RADIUS = 100; 
    const PLAYER_CRAWL_SOUND_RADIUS = 40; 
    const PLAYER_STANDING_STILL_SOUND_RADIUS = 10; 

    // Enemy Inspection Constants
    const ENEMY_INSPECTION_COOLDOWN_MIN = 5; 
    const ENEMY_INSPECTION_COOLDOWN_MAX = 15;
    const ENEMY_INSPECTION_RADIUS = 200; 
    const ENEMY_INSPECTION_TRIGGER_AWARENESS = 30; 
    const ENEMY_INSPECTION_DURATION = 1.0; 

    // Building Key Item Constants (formerly just 'Key')
    const BUILDING_KEY_DROP_OFFSET_X = 50; 
    const BUILDING_KEY_DROP_OFFSET_Y = 50; 
    const BUILDING_KEY_ROTATION_SPEED = Math.PI * 1.5; 
    const BUILDING_KEY_DISPLAY_WIDTH = 64; 
    const BUILDING_KEY_DISPLAY_HEIGHT = 128; 
    const BUILDING_KEY_GLOW_COLOR = 'cyan'; 

    // Ladder Item Constants
    const LADDER_SPAWN_OFFSET_FROM_LOCKER_Y = -60; // How far above the locker the ladder drops
    const LADDER_DISPLAY_WIDTH = 32;
    const LADDER_DISPLAY_HEIGHT = 64;
    const LADDER_GLOW_COLOR = 'orange';
    const LADDER_ROTATION_SPEED = Math.PI * 1.0; // Slower rotation for ladders

    // Game Timer Constants
    const GAME_DURATION_SECONDS = 3 * 60; 
    const HELICOPTER_ARRIVAL_TIME_RELATIVE_TO_END = 20; 

    // Drone Constants
    const DRONE_WIDTH = 24;
    const DRONE_HEIGHT = 24;
    const DRONE_SPEED = 180; 
    const DRONE_VISION_RANGE = 300; 
    const DRONE_VISION_ANGLE = Math.PI * 0.5; 
    const DRONE_DAMAGE = 15;
    const DRONE_FIRE_RATE = 1.0; 
    const DRONE_ALERT_GAIN = 60; 
    const DRONE_GLOW_COLOR = 'darkblue';
    const DRONE_LASER_DURATION = 0.1; 

    // Breach Constants
    const BREACH_ALERT_AWARENESS = 90; 
    const BREACH_TARGET_OFFSET = 20; 

    // Oxygen Depletion Constants
    const PLAYER_MAX_OXYGEN_LEVEL = 20; 
    const OXYGEN_DEPLETION_RATE_PER_SEC = 1; 
    const OXYGEN_BAR_WIDTH = 80; // Horizontal bar width
    const OXYGEN_BAR_HEIGHT = 15; // Horizontal bar height
    const OXYGEN_BAR_OFFSET_Y = 20; // Offset below O2 tank sprite
    const O2_TANK_DISPLAY_WIDTH = 64;
    const O2_TANK_DISPLAY_HEIGHT = 64;
    const O2_TANK_GLOW_COLOR = 'lightblue';
    const O2_TANK_ROTATION_SPEED = Math.PI * 0.8; 

    // Game Objective Constants
    const EZ_RADIUS = 100; 
    const HELICOPTER_SPRITE_WIDTH = 96; 
    const HELICOPTER_SPRITE_HEIGHT = 96;
    const MIN_OBJECTIVE_ROOM_OFFSET = 2; // Keep this to prevent objectives from spawning immediately next to player if not forced

    // Player Interaction Constants
    const PLAYER_ITEM_COLLECTION_RANGE = 70; // For keys, first aid, ladders, alarm reset
    const PLAYER_BUILDING_INTERACTION_RANGE = 100; // For secure buildings

    // First Aid Constants
    const FIRST_AID_HEAL_PERCENTAGE = 0.20; 
    const FIRST_AID_SPAWN_OFFSET = 50; 
    const FIRST_AID_DISPLAY_WIDTH = 32; 
    const FIRST_AID_DISPLAY_HEIGHT = 32;
    const FIRST_AID_GLOW_COLOR = 'forestgreen'; 

    // Guard Shack Constants
    const GUARD_SHACK_WIDTH = 96; 
    const GUARD_SHACK_HEIGHT = 96;

    // Secure Building Constants
    const SECURE_BUILDING_WIDTH = 150;
    const SECURE_BUILDING_HEIGHT = 150;
    const SECURE_BUILDING_GLOW_COLOR = 'purple';
    const CODE_BOOK_DISPLAY_WIDTH = 40;
    const CODE_BOOK_DISPLAY_HEIGHT = 40;
    const CODE_BOOK_ROTATION_SPEED = Math.PI * 1.2;
    const CODE_BOOK_GLOW_COLOR = 'cyan'; // Color for collected codebook to glow
    const ALARM_PANEL_WIDTH = 32;
    const ALARM_PANEL_HEIGHT = 32;
    const ALARM_RESET_GLOW_COLOR = 'red';
    const ALARM_RESET_ROTATION_SPEED = Math.PI * 2.0;
    const ALARM_RESET_DISPLAY_WIDTH = 48;
    const ALARM_RESET_DISPLAY_HEIGHT = 48;


    // Area Management System - now stores barrier breached status per room
    const worldAreas = new Map(); 

    // World state
    const player = {
        x:0, y:0,
        speed:PLAYER_RUNNING_SPEED, alive:true, 
        width: 32, height: 32,
        damage: PLAYER_DAMAGE_PER_SHOT, fireRate: PLAYER_FIRE_RATE, lastShotTime: 0,
        hp: 100, maxHp: 100,
        meleeDamage: PLAYER_MELEE_DAMAGE,
        meleeRange: PLAYER_MELEE_RANGE,
        meleeCooldown: PLAYER_MELEE_COOLDOWN,
        lastMeleeTime: 0,
        hasBuildingKey: false, 
        hasLadder: false,      
        isCrouching: false, 
        isCrawling: false, 
        currentSoundRadius: PLAYER_RUNNING_SOUND_RADIUS, 
        isHiding: false, 
        currentHidingSpotId: null, 
        wasMovingLastFrame: false, 
        lastMoveAngle: 0, 
        oxygenLevel: PLAYER_MAX_OXYGEN_LEVEL, 
        collectedCodeBooksCount: 0, 
        o2TankRotation: 0 // New: for animating O2 tank sprite
    }; 
    const enemies = []; 
    const items = []; 
    const drones = []; 
    const guardShacks = []; 
    const secureBuildings = []; 
    const keys = {};

    // Global array of all placed hiding spots
    const activeHidingSpots = [];

    // Global timer variables
    let gameTimerRemaining = GAME_DURATION_SECONDS;
    let timerExpired = false; 
    let gameWon = false; 
    let helicopterPresent = false; 
    let extractionZoneIndex = null; 
    let extractionZoneLocation = { x: 0, y: 0 }; 

    let NUM_CODEBOOKS_TO_COLLECT = 1; 

    let isAlarmActive = false; 
    let alarmPulseAlpha = 0;   
    let alarmPulseDirection = 1; 
    let alarmTriggeredLocation = null; // New: where the alarm item will spawn

    // Input Event Listeners
    addEventListener('keydown', e=>keys[e.key]=true);
    addEventListener('keyup',   e=>keys[e.key]=false);

    // Mouse click event listener for shooting (Left Click - currently inactive for player combat logic)
    canvas.addEventListener('click', (e) => {
        if (!player.alive) return;
        if (e.button !== 0) return; 
    });

    // Keydown event listener for player melee attack ('F'), crouching ('Shift'), and crawling ('C')
    addEventListener('keydown', (e) => { 
        if (!player.alive || gameWon) return; 

        // Melee Attack (F key)
        if (e.key.toLowerCase() === 'f' && !keys.fPressed) { 
            keys.fPressed = true; 
            const now = performance.now() / 1000;

            if (now - player.lastMeleeTime < player.meleeCooldown) {
                return; 
            }

            let targetEnemy = null;
            for (const e of enemies) {
                if (!e.alive || e.state === 'dead') continue;

                const distToEnemy = Math.hypot(player.x - e.x, player.y - e.y);
                if (distToEnemy < player.meleeRange + (player.width/2 + e.width/2) ) { 
                    targetEnemy = e;
                    break; 
                }
            }

            if (targetEnemy) {
                targetEnemy.hp -= player.meleeDamage;
                console.log(`Player melees enemy ${targetEnemy.id}! Enemy HP: ${targetEnemy.hp}`);
                player.lastMeleeTime = now; 

                if (targetEnemy.state !== 'combat') {
                    targetEnemy.state = 'combat';
                    targetEnemy.awareness = ENEMY_COMBAT_THRESHOLD; 
                    console.log(`Enemy ${targetEnemy.id} noticed player! Entering combat state.`);
                }

                if (targetEnemy.hp <= 0) {
                    targetEnemy.alive = false;
                    targetEnemy.state = 'dead';
                    console.log(`Enemy ${targetEnemy.id} killed by melee!`);

                    // Drop building key if this enemy was the key holder
                    if (targetEnemy.isBuildingKeyHolder) {
                        items.push({
                            x: targetEnemy.x + BUILDING_KEY_DROP_OFFSET_X,
                            y: targetEnemy.y + BUILDING_KEY_DROP_OFFSET_Y,
                            width: BUILDING_KEY_DISPLAY_WIDTH, 
                            height: BUILDING_KEY_DISPLAY_HEIGHT,
                            type: 'buildingKey',
                            collected: false,
                            rotation: 0 
                        });
                        console.log(`Building Key dropped by ${targetEnemy.id}!`);
                    }
                }
            }
        }

        // Crouch (Shift key)
        if (e.key === 'Shift') { 
            player.isCrouching = true;
            player.isCrawling = false; 
        }

        // Crawl (C key)
        if (e.key.toLowerCase() === 'c') { 
            player.isCrawling = true;
            player.isCrouching = false; 
        }
    });

    // Keyup event listener for 'F' (reset), 'O' (Open/Interact), 'H' (Hide), 'Shift' (uncrouch), and 'C' (uncrawl)
    addEventListener('keyup', e => {
        if (e.key.toLowerCase() === 'f') {
            keys.fPressed = false;
        }

        // Uncrouch (Shift key)
        if (e.key === 'Shift') {
            player.isCrouching = false;
        }

        // Uncrawl (C key)
        if (e.key.toLowerCase() === 'c') {
            player.isCrawling = false;
        }

        if (!player.alive || gameWon) return; 

        const playerHalfWidth = player.width / 2;
        const playerHalfHeight = player.height / 2;


        // Handle Interaction (O key) - Now for Secure Buildings, Ladders, and Alarm Panels
        if (e.key.toLowerCase() === 'o') {
            const playerX = player.x;
            const playerY = player.y;

            // --- Try to interact with a Secure Building ---
            let interactedWithBuilding = false;
            for (const building of secureBuildings) {
                const distToBuilding = Math.hypot(playerX - building.x, playerY - building.y);
                if (distToBuilding < PLAYER_BUILDING_INTERACTION_RANGE) {
                    // Interaction: Enter Building / Collect Codebook
                    if (player.hasBuildingKey && !building.codeBookCollected) {
                        player.collectedCodeBooksCount++;
                        building.codeBookCollected = true;
                        player.hasBuildingKey = false; // Key is consumed
                        // Set the building's codebook to spin after collection
                        building.codebookRotation = 0; 
                        console.log(`Player collected Code Book from Secure Building ${building.id}! Total: ${player.collectedCodeBooksCount}/${NUM_CODEBOOKS_TO_COLLECT}`);
                        interactedWithBuilding = true;
                    } else if (!player.hasBuildingKey && !building.codeBookCollected) {
                        console.log(`Need a Building Key to enter Secure Building ${building.id}.`);
                        interactedWithBuilding = true; 
                    } else if (building.codeBookCollected) {
                        console.log(`Code Book already collected from Secure Building ${building.id}.`);
                        interactedWithBuilding = true;
                    }
                    // No alarm disarm here, it's now a collectible item
                    if (interactedWithBuilding) break; 
                }
            }
            if (interactedWithBuilding) return; 

            // --- NEW: Try to open a locker to drop a Ladder (as a collectible item) ---
            let interactedWithLocker = false;
            for (const spot of activeHidingSpots) {
                if (spot.type.id === 'locker' && spot.hasLadder && !player.hasLadder) {
                    const distToSpot = Math.hypot(playerX - spot.x, playerY - spot.y);
                    if (distToSpot < PLAYER_ITEM_COLLECTION_RANGE) {
                        // Drop the ladder as a world item
                        items.push({
                            x: spot.x,
                            y: spot.y + LADDER_SPAWN_OFFSET_FROM_LOCKER_Y, // Spawn slightly above locker
                            width: LADDER_DISPLAY_WIDTH,
                            height: LADDER_DISPLAY_HEIGHT,
                            type: 'ladder',
                            collected: false,
                            rotation: 0
                        });
                        spot.hasLadder = false;       // The locker no longer contains it
                        // Optional: if player was "hiding" in this locker, kick them out
                        if (player.isHiding && player.currentHidingSpotId === spot.id) {
                            player.isHiding = false;
                            player.currentHidingSpotId = null;
                            spot.isOccupiedByPlayer = false;
                        }
                        console.log(`Player opened locker ${spot.id} and a Ladder dropped out!`);
                        interactedWithLocker = true;
                        break; // Only interact with one locker
                    }
                }
            }
            if (interactedWithLocker) return; 

            // --- NEW: Try to disarm alarm by collecting the alarmReset item ---
            let disarmedAlarm = false;
            if (isAlarmActive) {
                const alarmResetItem = items.find(item => item.type === 'alarmReset' && !item.collected);
                if (alarmResetItem) {
                    const distToAlarmItem = Math.hypot(playerX - alarmResetItem.x, playerY - alarmResetItem.y);
                    if (distToAlarmItem < PLAYER_ITEM_COLLECTION_RANGE) {
                        isAlarmActive = false;
                        alarmTriggeredLocation = null; // Reset alarm location
                        // Mark the item as collected so it's removed from the world
                        alarmResetItem.collected = true; 
                        for (const enemy of enemies) {
                            enemy.hasTriggeredAlarm = false; 
                            enemy.ladderBreachAlerted = false; 
                        }
                        console.log("Player disarmed the alarm by collecting the alarm unit!");
                        disarmedAlarm = true;
                    }
                }
            }
            if (disarmedAlarm) return;


            // --- ORIGINAL: Try to use Ladder to cross a Barrier ---
            if (player.hasLadder) {
                const BARRIER_HALF_RENDER_WIDTH = BARRIER_RENDER_WIDTH_PIXELS / 2;
                
                let targetBarrierIndex = null;
                let closestDistToBarrierCenter = Infinity; 

                // Check barrier to the right (East) of the player's current room
                const barrierRightIndex = Math.floor((playerX - BARRIER_START_WORLD_X) / ROOM_WIDTH);
                const barrierRightWorldX = BARRIER_START_WORLD_X + (barrierRightIndex * ROOM_WIDTH);
                const distToRightBarrierCenter = Math.abs(playerX - barrierRightWorldX);

                // Check barrier to the left (West) of the player's current room
                const barrierLeftIndex = Math.floor((playerX - BARRIER_START_WORLD_X) / ROOM_WIDTH) - 1;
                const barrierLeftWorldX = BARRIER_START_WORLD_X + (barrierLeftIndex * ROOM_WIDTH);
                const distToLeftBarrierCenter = Math.abs(playerX - barrierLeftWorldX);

                // Determine which barrier is closer and within interaction range
                if (distToRightBarrierCenter <= PLAYER_ITEM_COLLECTION_RANGE) {
                    targetBarrierIndex = barrierRightIndex;
                    closestDistToBarrierCenter = distToRightBarrierCenter;
                }
                
                if (distToLeftBarrierCenter < closestDistToBarrierCenter && 
                    distToLeftBarrierCenter <= PLAYER_ITEM_COLLECTION_RANGE) {
                    targetBarrierIndex = barrierLeftIndex;
                }

                if (targetBarrierIndex !== null) {
                    let barrierStatus = worldAreas.get(targetBarrierIndex);
                    if (!barrierStatus) { 
                        console.warn(`Attempted to interact with non-existent barrier at index ${targetBarrierIndex}.`);
                        return; 
                    }

                    // Check if player is vertically within the main passage
                    const playerTop = player.y - playerHalfHeight;
                    const playerBottom = player.y + playerHalfHeight;
                    const northWallBottom = NORTHERN_BARRIER_WORLD_Y + BARRIER_RENDER_WIDTH_PIXELS;
                    const southWallTop = SOUTHERN_BARRIER_WORLD_Y;
                    const playerVerticallyAligned = (playerBottom > northWallBottom && playerTop < southWallTop);

                    if (!barrierStatus.isBreachedByLadder && playerVerticallyAligned) { 
                        barrierStatus.isBreachedByLadder = true; 
                        player.hasLadder = false; 
                        console.log(`SUCCESS: Barrier at index ${targetBarrierIndex} breached by ladder! Ladder consumed.`);
                    } else if (barrierStatus.isBreachedByLadder) {
                        console.log("WARNING: Barrier already has a ladder.");
                    } else { 
                        console.log("FAIL: Not vertically aligned with the barrier passage to use ladder.");
                    }
                } else {
                    console.log("FAIL: Not close enough to any barrier to use ladder.");
                }
            } else {
                console.log("O key pressed but player does not have ladder (for barricade traversal).");
            }
        }

        // Handle Hiding Spot interaction (H key)
        if (e.key.toLowerCase() === 'h') {
            const HIDING_INTERACTION_RADIUS = 60; 
            if (!player.isHiding) { 
                for (const spot of activeHidingSpots) {
                    if (spot.type.canHideInside) { 
                        const distToSpot = Math.hypot(player.x - spot.x, player.y - spot.y);
                        
                        const playerRoughRadius = Math.max(player.width, player.height) / 2;
                        const spotRoughRadius = Math.max(spot.width, spot.height) / 2;
                        const effectiveInteractionDistance = playerRoughRadius + spotRoughRadius + HIDING_INTERACTION_RADIUS;

                        if (distToSpot < effectiveInteractionDistance) {
                            player.isHiding = true;
                            player.currentHidingSpotId = spot.id;
                            spot.isOccupiedByPlayer = true;
                            player.x = spot.x; 
                            player.y = spot.y; 
                            player.oxygenLevel = PLAYER_MAX_OXYGEN_LEVEL; 
                            return; 
                        }
                    }
                }
                console.log("H key pressed but no valid hiding spot found nearby.");
            } else { 
                const currentSpot = activeHidingSpots.find(s => s.id === player.currentHidingSpotId);
                if (currentSpot) { 
                    if (currentSpot.type.canHideInside) { 
                        player.isHiding = false;
                        player.currentHidingSpotId = null;
                        currentSpot.isOccupiedByPlayer = false;
                        player.x += 10; 
                        player.oxygenLevel = PLAYER_MAX_OXYGEN_LEVEL; 
                    } else {
                        console.log("H key pressed but player is in a non-interactive hiding spot or currentSpot is invalid.");
                    }
                } else {
                    console.log("H key pressed but player.currentHidingSpotId is invalid or spot no longer exists.");
                }
            }
        }
    });

    /**
     * Determines if an entity (enemy or drone) has a clear line of sight to the player.
     * Checks distance, vision cone angle, and simplified room-based obstacles.
     * Applies hiding spot effects.
     * @param {object} entity The entity object (enemy or drone).
     * @param {object} player The player object.
     * @returns {boolean} True if entity can see player, false otherwise.
     */
    function canEntitySeePlayer(entity, player) {
        if (player.alive === false) return false; 

        let effectiveVisionRange = entity.visionRange;
        
        // Apply hiding spot effects if player is hiding. Drones now also respect this.
        if (player.isHiding) {
            const hidingSpot = activeHidingSpots.find(s => s.id === player.currentHidingSpotId);
            if (hidingSpot) {
                if (hidingSpot.type.visionReductionFactor === 0) { 
                    return false; 
                }
                effectiveVisionRange *= hidingSpot.type.visionReductionFactor;
            }
        }

        const dist_player = Math.hypot(player.x - entity.x, player.y - entity.y);

        if (dist_player > effectiveVisionRange) {
            return false; 
        }

        // Calculate angle from entity to player
        let angleToPlayer = Math.atan2(player.y - entity.y, player.x - entity.x);
        if (angleToPlayer < 0) angleToPlayer += Math.PI * 2; 

        let entityFacing = entity.facingAngle;
        if (entityFacing < 0) entityFacing += Math.PI * 2; 

        let angleDiff = Math.abs(angleToPlayer - entityFacing);
        if (angleDiff > Math.PI) angleDiff = (Math.PI * 2) - angleDiff; 

        if (angleDiff > entity.visionAngle / 2) {
            return false; 
        }

        // --- Simplified Obstacle Check for Vision (Barriers) ---
        const entityRoomIdx = Math.floor((entity.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
        const playerRoomIdx = Math.floor((player.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);

        if (entityRoomIdx === playerRoomIdx) {
            return true;
        } else {
            // New logic: Drones can always fly over horizontal barriers.
            // Vertical barriers: Drones always cross if alarm is active. Soldiers only if ladder is present AND alarm is active.
            if (entity.type === 'drone') { 
                return true; 
            } else { // It's an enemy soldier
                const barrierIndexBetween = Math.min(entityRoomIdx, playerRoomIdx);
                const barrierData = worldAreas.get(barrierIndexBetween);
                if (barrierData && barrierData.isBreachedByLadder && isAlarmActive) { 
                    return true;
                } else {
                    return false; 
                }
            }
        }
    }

    /**
     * Determines if an enemy can hear a sound source.
     * @param {object} enemy The enemy object.
     * @param {object} soundSource The sound source object (must have x, y, radius).
     * @returns {boolean} True if enemy can hear sound, false otherwise.
     */
    function canEnemyHearSound(enemy, soundSource) {
        let effectiveSoundRadius = soundSource.radius;

        // Apply hiding spot effects if player is hiding
        if (player.isHiding) {
            const hidingSpot = activeHidingSpots.find(s => s.id === player.currentHidingSpotId);
            if (hidingSpot) {
                if (hidingSpot.type.soundReductionFactor === 0) { 
                    return false; 
                }
                effectiveSoundRadius *= hidingSpot.type.soundReductionFactor;
            }
        }

        const distToSound = Math.hypot(soundSource.x - enemy.x, soundSource.y - enemy.y);

        // Enemy can hear if the sound source's effective radius extends into their hearing range
        if (distToSound <= enemy.hearingRange + effectiveSoundRadius) {
            // --- Simplified Obstacle Check for Sound (Barriers) ---
            const enemyRoomIdx = Math.floor((enemy.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
            const soundRoomIdx = Math.floor((soundSource.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);

            if (enemyRoomIdx === soundRoomIdx) {
                return true; 
            } else {
                const barrierIndexBetween = Math.min(enemyRoomIdx, soundRoomIdx);
                const barrierData = worldAreas.get(barrierIndexBetween);

                if (enemy.type === 'drone') { // Drones can always hear through barriers
                    return true; 
                } else if (barrierData && barrierData.isBreachedByLadder && isAlarmActive) { // Soldiers only if ladder is present AND alarm is active.
                    return true; 
                } else {
                    return false; 
                }
            }
        }
        return false; 
    }

    /**
     * Determines if an enemy (soldier) can see a specific ladder placed at a barrier.
     * @param {object} enemy The enemy object.
     * @param {number} barrierIndex The index of the barrier to check.
     * @returns {boolean} True if enemy can see the ladder, false otherwise.
     */
    function canEnemySeeLadder(enemy, barrierIndex) {
        const barrierData = worldAreas.get(barrierIndex);
        if (!barrierData || !barrierData.isBreachedByLadder) {
            return false;
        }

        const barrierWorldX = BARRIER_START_WORLD_X + (barrierIndex * ROOM_WIDTH);
        // Estimate ladder visual position near the barrier
        const ladderX = barrierWorldX; 
        const ladderY = (NORTHERN_BARRIER_WORLD_Y + BARRIER_RENDER_WIDTH_PIXELS + SOUTHERN_BARRIER_WORLD_Y) / 2;

        const dist_ladder = Math.hypot(ladderX - enemy.x, ladderY - enemy.y);

        if (dist_ladder > enemy.visionRange) {
            return false;
        }

        let angleToLadder = Math.atan2(ladderY - enemy.y, ladderX - enemy.x);
        if (angleToLadder < 0) angleToLadder += Math.PI * 2; 

        let enemyFacing = enemy.facingAngle;
        if (enemyFacing < 0) enemyFacing += Math.PI * 2; 

        let angleDiff = Math.abs(angleToLadder - enemyFacing);
        if (angleDiff > Math.PI) angleDiff = (Math.PI * 2) - angleDiff; 

        if (angleDiff > enemy.visionAngle / 2) {
            return false; 
        }

        // Additional check: enemy must be able to "path" to the ladder's side of the barrier
        // This is simplified and assumes direct sight across a breached barrier.
        // If the enemy is in the room adjacent to the ladder, it can "see" it across the barrier.
        const enemyRoomIdx = Math.floor((enemy.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
        if (enemyRoomIdx === barrierIndex || enemyRoomIdx === barrierIndex - 1) {
            return true;
        }
        return false;
    }


    /**
     * Calculates the overall world coordinates and room indices for a contiguous open area.
     * This is used to define patrol bounds for AI entities.
     * @param {number} homeAreaIndex The starting room index for the AI entity.
     * @returns {object} An object containing min/max world X/Y and min/max room indices of the accessible area.
     */
    function getConnectedRoomBounds(homeAreaIndex) {
        let minAccessibleRoomIdx = homeAreaIndex;
        let maxAccessibleRoomIdx = homeAreaIndex;

        // Find the leftmost connected room
        let checkIdx = homeAreaIndex - 1; 
        while (worldAreas.has(checkIdx) && worldAreas.get(checkIdx).isBreachedByLadder && isAlarmActive) { // Only if alarm is active
            minAccessibleRoomIdx = checkIdx;
            checkIdx--;
        }

        // Find the rightmost connected room
        checkIdx = homeAreaIndex; // Start check from the current room's right barrier
        while (worldAreas.has(checkIdx) && worldAreas.get(checkIdx).isBreachedByLadder && isAlarmActive) { // Only if alarm is active
            maxAccessibleRoomIdx = checkIdx + 1; 
            checkIdx++;
        }
        
        const barrierHalfWidth = BARRIER_RENDER_WIDTH_PIXELS / 2;
        const minWorldX = BARRIER_START_WORLD_X + (minAccessibleRoomIdx * ROOM_WIDTH) + barrierHalfWidth;
        const maxWorldX = BARRIER_START_WORLD_X + (maxAccessibleRoomIdx * ROOM_WIDTH) + ROOM_WIDTH - barrierHalfWidth; 

        const playableWorldYMin = NORTHERN_BARRIER_WORLD_Y + BARRIER_RENDER_WIDTH_PIXELS; 
        const playableWorldYMax = SOUTHERN_BARRIER_WORLD_Y; 

        return { 
            minWorldX, 
            maxWorldX, 
            minWorldY: playableWorldYMin, 
            maxWorldY: playableWorldYMax,
            minRoomIndex: minAccessibleRoomIdx, 
            maxRoomIndex: maxAccessibleRoomIdx
        };
    }

    /**
     * Simplified Pathfinding check: Determines if a straight line path exists between two points, considering vertical barriers.
     * Only checks if rooms between are breached by ladder AND alarm is active.
     * @param {object} startPoint {x,y}
     * @param {object} endPoint {x,y}
     * @returns {boolean} True if path is clear, false otherwise.
     */
    function getPathBetweenPoints(startPoint, endPoint) {
        if (!isAlarmActive) { // No path across barriers if alarm is not active
            return Math.floor((startPoint.x - BARRIER_START_WORLD_X) / ROOM_WIDTH) === Math.floor((endPoint.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
        }

        const startRoomIdx = Math.floor((startPoint.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
        const endRoomIdx = Math.floor((endPoint.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);

        if (startRoomIdx === endRoomIdx) {
            return true; // Same room, path clear.
        }

        const step = startRoomIdx < endRoomIdx ? 1 : -1;
        for (let i = startRoomIdx; i !== endRoomIdx; i += step) {
            const barrierToCheck = step === 1 ? i : i - 1; // Barrier to the right of current room (if moving right) or left (if moving left)
            const barrierData = worldAreas.get(barrierToCheck);
            if (!barrierData || !barrierData.isBreachedByLadder) {
                return false; // Found an unbreached barrier in between
            }
        }
        return true; // All barriers between are breached
    }

    /**
     * Checks if a given rectangle (x,y,w,h) overlaps with any existing static obstacles.
     * @param {number} x Center X of new object.
     * @param {number} y Center Y of new object.
     * @param {number} width Width of new object.
     * @param {number} height Height of new object.
     * @param {Array<Object>} existingObstacles An array of objects, each with x, y, width, height properties.
     * @returns {boolean} True if overlap detected, false otherwise.
     */
    function isOverlappingAnyObstacle(x, y, width, height, currentObstacles) {
        const newLeft = x - width / 2;
        const newRight = x + width / 2;
        const newTop = y - height / 2;
        const newBottom = y + height / 2;

        for (const obs of currentObstacles) {
            const obsLeft = obs.x - obs.width / 2;
            const obsRight = obs.x + obs.width / 2;
            const obsTop = obs.y - obs.height / 2;
            const obsBottom = obs.y + obs.height / 2;

            if (newRight > obsLeft && newLeft < obsRight &&
                newBottom > obsTop && newTop < obsBottom) {
                return true; // Overlap detected
            }
        }
        return false;
    }


    /**
     * Spawns entities (enemies, drones, guard shacks) within a specific world area.
     * @param {number} areaIndex The index of the area.
     * @param {number} numToSpawn The number of enemies (and thus drones/shacks) to spawn.
     * @param {string} initialState The initial state for enemies.
     */
    function spawnEnemiesAndDronesInArea(areaIndex, numToSpawn, initialState = 'idle') {
        if (worldAreas.has(areaIndex) && worldAreas.get(areaIndex).populated) {
            return;
        }

        const barrierHalfWidth = BARRIER_RENDER_WIDTH_PIXELS / 2;
        const playableWorldYMin = NORTHERN_BARRIER_WORLD_Y + BARRIER_RENDER_WIDTH_PIXELS; 
        const playableWorldYMax = SOUTHERN_BARRIER_WORLD_Y; 
        const playableWorldYHeight = playableWorldYMax - playableWorldYMin; 

        if (playableWorldYHeight <= 0) {
             console.warn(`Playable Y height is non-positive. Check NORTHERN_BARRIER_WORLD_Y and SOUTHERN_BARRIER_WORLD_Y.`);
             return;
        }

        for (let i = 0; i < numToSpawn; i++) {
            // Calculate spawn bounds for this specific room
            const roomSpawnAreaStartX = BARRIER_START_WORLD_X + (areaIndex * ROOM_WIDTH) + barrierHalfWidth; 
            const roomSpawnAreaEndX = BARRIER_START_WORLD_X + ((areaIndex + 1) * ROOM_WIDTH) - barrierHalfWidth; 
            const roomPlayableAreaWidth = roomSpawnAreaEndX - roomSpawnAreaStartX;

            if (roomPlayableAreaWidth <= 0) {
                console.warn(`Area ${areaIndex} has non-positive playable width. Skipping entity spawn for this area.`);
                continue;
            }

            // --- Spawn Enemy ---
            const enemyHalfWidth = 32 / 2; 
            const enemyHalfHeight = 32 / 2;
            let ex = roomSpawnAreaStartX + enemyHalfWidth + (Math.random() * (roomPlayableAreaWidth - enemyHalfWidth * 2)); 
            let ey = playableWorldYMin + enemyHalfHeight + (Math.random() * (playableWorldYHeight - enemyHalfHeight * 2));
            enemies.push({ 
                x:ex, y:ey, speed:ENEMY_SPEED_DEFAULT, width: 32, height: 32, hp: ENEMY_STARTING_HP, maxHp: ENEMY_STARTING_HP,
                state: initialState, visionRange: ENEMY_VISION_RANGE, visionAngle: ENEMY_VISION_ANGLE,
                facingAngle: Math.random() * Math.PI * 2, hearingRange: ENEMY_HEARING_RANGE_DEFAULT, 
                awareness: 0, meleeDamage: ENEMY_MELEE_DAMAGE, meleeCooldown: ENEMY_MELEE_COOLDOWN,
                lastMeleeTime: 0, homeAreaIndex: areaIndex, alive: true,
                id: `enemy-${Date.now()}-${enemies.length}`, lastKnownSoundLocation: { x: null, y: null },
                inspectionTarget: null, lastInspectionTime: 0, patrolTarget: null, type: 'enemy',
                isBuildingKeyHolder: false, 
                ladderBreachAlerted: false, 
                alarmReportTarget: null, 
                hasTriggeredAlarm: false 
            });
            console.log(`Enemy spawned at (${ex.toFixed(0)}, ${ey.toFixed(0)}) in area ${areaIndex}`);


            // --- Spawn Drone ---
            const droneHalfWidth = DRONE_WIDTH / 2;
            const droneHalfHeight = DRONE_HEIGHT / 2;
            let dx = roomSpawnAreaStartX + droneHalfWidth + (Math.random() * (roomPlayableAreaWidth - droneHalfWidth * 2));
            let dy = playableWorldYMin + droneHalfHeight + (Math.random() * (playableWorldYHeight - droneHalfHeight * 2));
            drones.push({
                x: dx, y: dy, width: DRONE_WIDTH, height: DRONE_HEIGHT, speed: DRONE_SPEED,
                visionRange: DRONE_VISION_RANGE, visionAngle: Math.PI * 0.5, facingAngle: Math.random() * Math.PI * 2,
                damage: DRONE_DAMAGE, fireRate: DRONE_FIRE_RATE, lastShotTime: 0,
                state: 'patrolling', patrolTarget: null, homeAreaIndex: areaIndex, alive: true, 
                id: `drone-${Date.now()}-${drones.length}`, laserTarget: null, laserDuration: 0, type: 'drone' 
            });
            console.log(`Drone spawned at (${dx.toFixed(0)}, ${dy.toFixed(0)}) in area ${areaIndex}`);

            // --- Spawn Guard Shack ---
            // This now respects object collision
            let sx, sy;
            let placementAttempts = 0;
            const MAX_PLACEMENT_ATTEMPTS = 50;
            const shackHalfWidth = GUARD_SHACK_WIDTH / 2;
            const shackHalfHeight = GUARD_SHACK_HEIGHT / 2;
            const playableAreaWidth = roomSpawnAreaEndX - roomSpawnAreaStartX;

            do {
                sx = roomSpawnAreaStartX + shackHalfWidth + (Math.random() * (playableAreaWidth - shackHalfWidth * 2));
                sy = playableWorldYMin + shackHalfHeight + (Math.random() * (playableWorldYHeight - shackHalfHeight * 2));
                placementAttempts++;
            } while (isOverlappingAnyObstacle(sx, sy, GUARD_SHACK_WIDTH, GUARD_SHACK_HEIGHT, [...guardShacks, ...secureBuildings, ...activeHidingSpots]) && placementAttempts < MAX_PLACEMENT_ATTEMPTS);

            if (placementAttempts < MAX_PLACEMENT_ATTEMPTS) {
                guardShacks.push({
                    x: sx, y: sy, width: GUARD_SHACK_WIDTH, height: GUARD_SHACK_HEIGHT,
                    homeAreaIndex: areaIndex, id: `shack-${Date.now()}-${guardShacks.length}`,
                    kitAvailable: true 
                });
                console.log(`Guard Shack spawned at (${sx.toFixed(0)}, ${sy.toFixed(0)}) in area ${areaIndex}`);
            } else {
                console.warn(`Failed to find non-overlapping spot for Guard Shack in area ${areaIndex} after ${MAX_PLACEMENT_ATTEMPTS} attempts.`);
            }
        }
        
        if (worldAreas.has(areaIndex)) { 
            worldAreas.get(areaIndex).populated = true;
        } else { 
             worldAreas.set(areaIndex, { isBreachedByLadder: false, currentEnemies: [], maxEnemies: 0, populated: true });
        }
    }

    /**
     * Draws a sprite with a layered glow effect using Canvas shadow properties.
     * @param {HTMLImageElement} img The image to draw.
     * @param {number} sx X-coordinate for drawing (center of sprite).
     * @param {number} sy Y-coordinate for drawing (center of sprite).
     * @param {number} spriteW The width to draw the sprite.
     * @param {number} spriteH The height to draw the sprite.
     * @param {string} glowColor The color of the glow.
     * @param {number} baseGlowBlur The base blur radius.
     * @param {number | null} rotation The rotation angle in radians, or null for default player/enemy rotation.
     */
    function drawSprite(img, sx, sy, spriteW, spriteH, glowColor, baseGlowBlur=20, rotation = null) {
      const drawSpriteContent = () => {
        if (img.complete && img.naturalWidth > 0 && img.naturalHeight > 0) {
          ctx.drawImage(img, -spriteW/2, -spriteH/2, spriteW, spriteH);
        } else {
          // Fallback if image not loaded
          ctx.beginPath();
          ctx.rect(-spriteW/2, -spriteH/2, spriteW, spriteH);
          ctx.fillStyle = glowColor; // Use glow color as fallback fill
          ctx.fill();
        }
      };

      ctx.save();
      ctx.translate(sx, sy);
      
      if (rotation !== null) {
        ctx.rotate(rotation);
      } else {
        ctx.rotate(-Math.PI/2); // Default rotation for player/enemies to face right based on sprite
      }

      ctx.shadowColor = glowColor;
      
      ctx.save(); ctx.shadowBlur  = baseGlowBlur * 2.5; ctx.globalAlpha = 0.6; drawSpriteContent(); ctx.restore();
      ctx.save(); ctx.shadowBlur  = baseGlowBlur * 1.2; ctx.globalAlpha = 0.9; drawSpriteContent(); ctx.restore();
      ctx.save(); ctx.shadowBlur  = baseGlowBlur * 0.3; ctx.globalAlpha = 1.0; drawSpriteContent(); ctx.restore();

      ctx.shadowBlur  = 0;
      ctx.shadowColor = 'rgba(0,0,0,0)';
      ctx.globalAlpha = 1.0;
      drawSpriteContent();

      ctx.restore(); 
    }

    // Update positions & handle collisions
    function update(dt) {
      // Update alarm pulse alpha
      if (isAlarmActive) {
          alarmPulseAlpha += alarmPulseDirection * dt * 0.5; // Adjust speed as needed
          if (alarmPulseAlpha > 0.3) { // Max alpha for the glow
              alarmPulseAlpha = 0.3;
              alarmPulseDirection = -1;
          } else if (alarmPulseAlpha < 0.05) { // Min alpha for the glow
              alarmPulseAlpha = 0.05;
              alarmPulseDirection = 1;
          }
      } else {
          alarmPulseAlpha = 0; // No pulse if alarm is off
      }

      // Update O2 tank rotation
      if (player.isHiding) {
          player.o2TankRotation = (player.o2TankRotation + dt * O2_TANK_ROTATION_SPEED) % (Math.PI * 2);
      }

      // Update codebook rotation for collected buildings
      secureBuildings.forEach(building => {
          if (building.codeBookCollected) {
              building.codebookRotation = (building.codebookRotation + dt * CODE_BOOK_ROTATION_SPEED) % (Math.PI * 2);
          }
      });


      // Check win condition first
      if (player.alive && !gameWon && player.collectedCodeBooksCount >= NUM_CODEBOOKS_TO_COLLECT && helicopterPresent) {
          const distToEZ = Math.hypot(player.x - extractionZoneLocation.x, player.y - extractionZoneLocation.y);
          if (distToEZ <= EZ_RADIUS) {
              gameWon = true;
              player.alive = false; 
              console.log("Mission Accomplished!");
          }
      }

      // Update global game timer
      if (!timerExpired && !gameWon) { 
          gameTimerRemaining -= dt;
          if (gameTimerRemaining <= HELICOPTER_ARRIVAL_TIME_RELATIVE_TO_END && !helicopterPresent) {
              helicopterPresent = true;
              console.log("Helicopter inbound!");
          }
          if (gameTimerRemaining <= 0) {
              gameTimerRemaining = 0; 
              player.alive = false; 
              timerExpired = true;  
              console.log("Time's up! Game Over.");
          }
      }

      if (!player.alive || gameWon) return; 

      const prevPlayerX = player.x;
      const prevPlayerY = player.y;

      let proposedPlayerX = player.x;
      let proposedPlayerY = player.y;

      let currentMoveSpeed; 
      let currentSoundRadius; 
      let actuallyMoving = false;

      // Determine player's speed and sound based on states
      const hidingSpot = activeHidingSpots.find(s => s.id === player.currentHidingSpotId);
      const isHidingInContainer = player.isHiding && hidingSpot && hidingSpot.type.canHideInside;

      if (isHidingInContainer) {
          proposedPlayerX = hidingSpot.x; 
          proposedPlayerY = hidingSpot.y;
          currentSoundRadius = 0; 
          currentMoveSpeed = 0; 

          // Deplete oxygen when hiding in container
          player.oxygenLevel -= OXYGEN_DEPLETION_RATE_PER_SEC * dt;
          if (player.oxygenLevel <= 0) {
              player.oxygenLevel = 0;
              player.alive = false; 
              console.log("Player suffocated!");
              return; 
          }
      } else {
          // Determine base speed and sound based on movement mode
          if (player.isCrawling) {
              currentMoveSpeed = PLAYER_CRAWL_SPEED;
              currentSoundRadius = PLAYER_CRAWL_SOUND_RADIUS;
          } else if (player.isCrouching) {
              currentMoveSpeed = PLAYER_CROUCH_SPEED;
              currentSoundRadius = PLAYER_CROUCH_SOUND_RADIUS;
          } else {
              currentMoveSpeed = PLAYER_RUNNING_SPEED; 
              currentSoundRadius = PLAYER_RUNNING_SOUND_RADIUS;
          }

          // Capture raw input for direction
          let inputX = 0;
          let inputY = 0;
          if (keys['ArrowUp'])    inputY = -1;
          if (keys['ArrowDown'])  inputY = 1;
          if (keys['ArrowLeft'])  inputX = -1;
          if (keys['ArrowRight']) inputX = 1;

          if (inputX !== 0 || inputY !== 0) { 
              player.lastMoveAngle = Math.atan2(inputY, inputX); 
              proposedPlayerX += inputX * currentMoveSpeed * dt;
              proposedPlayerY += inputY * currentMoveSpeed * dt;
              actuallyMoving = true;
          } else if (player.isCrawling) { 
              if (!isNaN(player.lastMoveAngle)) { 
                proposedPlayerX += Math.cos(player.lastMoveAngle) * currentMoveSpeed * dt;
                proposedPlayerY += Math.sin(player.lastMoveAngle) * currentMoveSpeed * dt;
                actuallyMoving = (Math.hypot(proposedPlayerX - prevPlayerX, proposedPlayerY - prevPlayerY) > 0.1);
              }
          }
      }
      
      player.wasMovingLastFrame = actuallyMoving; 

      // Apply sound reduction for passive hiding spots if player is in one and not fully concealed
      if (player.isHiding && hidingSpot && !hidingSpot.type.canHideInside) { 
          if (player.wasMovingLastFrame && player.speed <= hidingSpot.type.minPlayerSpeedForSoundReduction) {
                 currentSoundRadius *= hidingSpot.type.soundReductionFactor;
              } else if (!player.wasMovingLastFrame) { 
                 currentSoundRadius = PLAYER_STANDING_STILL_SOUND_RADIUS * hidingSpot.type.soundReductionFactor; 
              }
      }

      player.speed = currentMoveSpeed; 
      player.currentSoundRadius = currentSoundRadius; 


      // --- Player Collision detection against all barriers & physical hiding spots ---
      const playerHalfWidth = player.width / 2;
      const playerHalfHeight = player.height / 2; 
      const barrierHalfWidth = BARRIER_RENDER_WIDTH_PIXELS / 2; 

      // 1. Vertical Room Barriers (West/East Walls)
      const currentRoomIdx = Math.floor((player.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
      const checkRange = Math.max(2, Math.ceil( (W/2 + BARRIER_RENDER_WIDTH_PIXELS) / ROOM_WIDTH) ); 
      for (let i = currentRoomIdx - checkRange; i <= currentRoomIdx + checkRange; i++) {
          const barrierDataForCollision = BARRIER_TYPES[Math.abs(i % BARRIER_TYPES.length)]; 

          if (barrierDataForCollision.isSolid) {
              const barrierWorldX = BARRIER_START_WORLD_X + (i * ROOM_WIDTH); 
              const barrierLeftEdge  = barrierWorldX - barrierHalfWidth;
              const barrierRightEdge = barrierWorldX + barrierHalfWidth;

              const roomBarrierStatus = worldAreas.get(i);
              const isBarrierBreachedByLadder = roomBarrierStatus ? roomBarrierStatus.isBreachedByLadder : false; 

              if (isBarrierBreachedByLadder) {
                  continue; // Player can pass through if ladder was used.
              }

              if (player.x + playerHalfWidth <= barrierLeftEdge && proposedPlayerX + playerHalfWidth > barrierLeftEdge) {
                  proposedPlayerX = barrierLeftEdge - playerHalfWidth; 
              }
              if (player.x - playerHalfWidth >= barrierRightEdge && proposedPlayerX - playerHalfWidth < barrierRightEdge) {
                  proposedPlayerX = barrierRightEdge + playerHalfWidth; 
              }
          }
      }

      // 2. North Barrier
      const northBarrierBottomEdge = NORTHERN_BARRIER_WORLD_Y + BARRIER_RENDER_WIDTH_PIXELS; 

      if (player.y - playerHalfHeight < northBarrierBottomEdge) {
          proposedPlayerY = northBarrierBottomEdge + playerHalfHeight; 
      }

      // 3. South Barrier
      const southBarrierTopEdge = SOUTHERN_BARRIER_WORLD_Y; 
      if (player.y + playerHalfHeight > southBarrierTopEdge) {
          proposedPlayerY = southBarrierTopEdge - playerHalfHeight; 
      }

      // Collision with physical hiding spots (lockers/crates) if not hiding inside them
      if (!isHidingInContainer) { 
          for (const spot of activeHidingSpots) {
              if (spot.type.isPhysical) {
                  const spotLeft = spot.x - spot.width/2;
                  const spotRight = spot.x + spot.width/2;
                  const spotTop = spot.y - spot.height/2;
                  const spotBottom = spot.y + spot.height/2;

                  if (proposedPlayerX + playerHalfWidth > spotLeft && proposedPlayerX - playerHalfWidth < spotRight &&
                      proposedPlayerY + playerHalfHeight > spotTop && proposedPlayerY - playerHalfHeight < spotBottom) {
                      
                      const dx_push = (player.x < spot.x) ? (spotLeft - (proposedPlayerX + playerHalfWidth)) : (spotRight - (proposedPlayerX - playerHalfWidth));
                      const dy_push = (player.y < spot.y) ? (spotTop - (proposedPlayerY + playerHalfHeight)) : (spotBottom - (proposedPlayerY - playerHalfHeight));

                      if (Math.abs(dx_push) < Math.abs(dy_push)) {
                          proposedPlayerX += dx_push;
                      } else {
                          proposedPlayerY += dy_push;
                      }
                  }
              }
          }
      }
      // Player collision with Secure Buildings
      for (const building of secureBuildings) {
            const buildingLeft = building.x - building.width/2;
            const buildingRight = building.x + building.width/2;
            const buildingTop = building.y - building.height/2;
            const buildingBottom = building.y + building.height/2;

            if (proposedPlayerX + playerHalfWidth > buildingLeft && proposedPlayerX - playerHalfWidth < buildingRight &&
                proposedPlayerY + playerHalfHeight > buildingTop && proposedPlayerY - playerHalfHeight < buildingBottom) {
                
                const dx_push = (player.x < building.x) ? (buildingLeft - (proposedPlayerX + playerHalfWidth)) : (buildingRight - (proposedPlayerX - playerHalfWidth));
                const dy_push = (player.y < building.y) ? (buildingTop - (proposedPlayerY + playerHalfHeight)) : (buildingBottom - (proposedPlayerY - playerHalfHeight));

                if (Math.abs(dx_push) < Math.abs(dy_push)) {
                    proposedPlayerX += dx_push;
                } else {
                    proposedPlayerY += dy_push;
                }
            }
        }


      player.x = proposedPlayerX;
      player.y = proposedPlayerY; 

      // Player enters/exits non-interactible hiding spots (bushes)
      if (!isHidingInContainer) { 
          let foundWalkInSpot = null;
          const playerBoundingBox = {
              left: player.x - playerHalfWidth,
              right: player.x + playerHalfWidth,
              top: player.y - playerHalfHeight, 
              bottom: player.y + playerHalfHeight
          };

          for (const spot of activeHidingSpots) {
              if (!spot.type.canHideInside) { 
                  const spotBoundingBox = {
                      left: spot.x - spot.width/2,
                      right: spot.x + spot.width/2,
                      top: spot.y - spot.height/2,
                      bottom: spot.y + spot.height/2
                  };

                  if (playerBoundingBox.right > spotBoundingBox.left &&
                      playerBoundingBox.left < spotBoundingBox.right &&
                      playerBoundingBox.bottom > spotBoundingBox.top &&
                      playerBoundingBox.top < spotBoundingBox.bottom) {
                      foundWalkInSpot = spot;
                      break; 
                  }
              }
          }

          if (foundWalkInSpot) {
              player.isHiding = true;
              player.currentHidingSpotId = foundWalkInSpot.id;
          } else if (player.isHiding) { 
              const lastSpot = activeHidingSpots.find(s => s.id === player.currentHidingSpotId);
              if (lastSpot && !lastSpot.type.canHideInside) { 
                player.isHiding = false;
                player.currentHidingSpotId = null;
              }
          }
      }


      // Guard Shack Interaction (Player Overlap)
      const playerBoundingBoxForShack = {
          left: player.x - playerHalfWidth,
          right: player.x + playerHalfWidth,
          top: player.y - playerHalfHeight,
          bottom: player.y + playerHalfHeight
      };

      for (const shack of guardShacks) {
          const shackLeft = shack.x - shack.width / 2;
          const shackRight = shack.x + shack.width / 2;
          const shackTop = shack.y - shack.height / 2;
          const shackBottom = shack.y + shack.height / 2;

          const playerOverlappingShack = (
              playerBoundingBoxForShack.right > shackLeft &&
              playerBoundingBoxForShack.left < shackRight &&
              playerBoundingBoxForShack.bottom > shackTop &&
              playerBoundingBoxForShack.top < shackBottom
          );

          if (playerOverlappingShack) {
              if (shack.kitAvailable) { 
                  const offsetX = (Math.random() - 0.5) * FIRST_AID_SPAWN_OFFSET * 2;
                  const offsetY = (Math.random() - 0.5) * FIRST_AID_SPAWN_OFFSET * 2;
                  
                  items.push({
                      x: shack.x + offsetX,
                      y: shack.y + offsetY,
                      width: FIRST_AID_DISPLAY_WIDTH,
                      height: FIRST_AID_DISPLAY_HEIGHT,
                      type: 'firstAidKit',
                      collected: false,
                      rotation: 0 
                  });
                  shack.kitAvailable = false; 
                  console.log(`First Aid Kit spawned near shack ${shack.id}!`);
              }
          } 
      }


      // --- Area Population Logic ---
      const playerRoomIdx = Math.floor((player.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
      const areasToManage = [playerRoomIdx, playerRoomIdx + 1, playerRoomIdx - 1, playerRoomIdx + 2, playerRoomIdx - 2]; 

      for (const areaIdx of areasToManage) {
          if (!worldAreas.has(areaIdx)) {
              worldAreas.set(areaIdx, { 
                  isBreachedByLadder: false, 
                  currentEnemies: [], 
                  maxEnemies: 0, 
                  populated: false 
              });
              console.log(`Initialized new world area: ${areaIdx}`);
          }
          if (!worldAreas.get(areaIdx).populated) {
              const maxEnemiesInArea = 1 + Math.floor(Math.random() * 2); 
              worldAreas.get(areaIdx).maxEnemies = maxEnemiesInArea;
              spawnEnemiesAndDronesInArea(areaIdx, maxEnemiesInArea, 'idle'); 
          }
      }


      // --- Enemy AI and Combat ---
      const now = performance.now() / 1000;
      for (let i = enemies.length - 1; i >= 0; i--) {
        const e = enemies[i];
        if (!e.alive) { 
          enemies.splice(i, 1); 
          continue; 
        }

        const dist_player = Math.hypot(player.x - e.x, player.y - e.y);
        let proposedEnemyX = e.x;
        let proposedEnemyY = e.y;

        // Awareness Check (done before state determination)
        let enemySawPlayer = canEntitySeePlayer(e, player); 
        let enemyHeardPlayer = canEnemyHearSound(e, { x: player.x, y: player.y, radius: player.currentSoundRadius });

        if (enemySawPlayer) {
            e.awareness = ENEMY_COMBAT_THRESHOLD; 
            e.lastKnownSoundLocation = { x: player.x, y: player.y }; 
            e.inspectionTarget = null; 
        } else if (enemyHeardPlayer && player.currentSoundRadius > 0) { 
            e.awareness = Math.min(100, e.awareness + ENEMY_AWARENESS_GAIN_SOUND * dt);
            e.lastKnownSoundLocation = { x: player.x, y: player.y }; 
            e.inspectionTarget = null; 
        } else {
            e.awareness = Math.max(0, e.awareness - ENEMY_AWARENESS_DECAY_RATE * dt);
        }

        // --- Alarm Trigger Logic (Soldiers only) ---
        if (e.type === 'enemy' && !isAlarmActive) {
            const currentEnemyRoomIdx = Math.floor((e.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
            const checkRange = 1; // Check adjacent barriers
            for (let b = currentEnemyRoomIdx - checkRange; b <= currentEnemyRoomIdx + checkRange; b++) {
                const barrierData = worldAreas.get(b);
                if (barrierData && barrierData.isBreachedByLadder && !e.ladderBreachAlerted) {
                    // Enemy sees a ladder-breached barrier for the first time
                    e.ladderBreachAlerted = true;
                    console.log(`Enemy ${e.id} spotted a ladder breach at barrier ${b}!`);

                    // Find the nearest alive key-holding guard (who hasn't already triggered the alarm)
                    const keyHoldingGuard = enemies.find(
                        (otherE) => otherE.alive && otherE.isBuildingKeyHolder && !otherE.hasTriggeredAlarm
                    );

                    if (keyHoldingGuard) {
                        console.log(`Enemy ${e.id} is reporting breach to key-holding guard ${keyHoldingGuard.id}.`);
                        e.state = 'reporting_ladder_breach';
                        e.alarmReportTarget = keyHoldingGuard;
                        break; // Found a ladder and a target, focus on this
                    } else {
                        console.log(`No alive key-holding guard found to report to. Alarm not triggered.`);
                    }
                }
            }
        }


        // Determine State based on Awareness and previous state
        const prevState = e.state;
        if (e.awareness >= ENEMY_COMBAT_THRESHOLD) {
            e.state = 'combat';
        } else if (e.state === 'reporting_ladder_breach') { 
            // No change, reporting state takes precedence
        } else if (e.awareness >= ENEMY_INVESTIGATE_THRESHOLD || e.inspectionTarget !== null || (e.state === 'investigating' && e.lastKnownSoundLocation.x !== null)) { 
            e.state = 'investigating';
        } else {
            e.state = 'idle';
        }

        // State-specific behavior
        switch (e.state) {
            case 'idle':
                if (prevState !== 'idle') {
                    e.patrolTarget = null;
                    e.inspectionTarget = null; 
                    e.lastKnownSoundLocation = { x: null, y: null }; 
                }

                const PATROL_TARGET_THRESHOLD = 50; 
                // Dynamically get patrol bounds based on connected rooms (now considers ladder breaches if alarm is active)
                const patrolBounds = getConnectedRoomBounds(e.homeAreaIndex);

                if (!e.patrolTarget || Math.hypot(e.patrolTarget.x - e.x, e.patrolTarget.y - e.y) < PATROL_TARGET_THRESHOLD) {
                    const enemyHalfWidth = e.width / 2;
                    const enemyHalfHeight = e.height / 2;
                    const playableAreaWidth = patrolBounds.maxWorldX - patrolBounds.minWorldX;
                    const playableWorldYHeight = patrolBounds.maxWorldY - patrolBounds.minWorldY;

                    if (playableAreaWidth <= enemyHalfWidth * 2 || playableWorldYHeight <= enemyHalfHeight * 2) {
                        e.patrolTarget = { x: e.x, y: e.y }; 
                    } else {
                        e.patrolTarget = {
                            x: patrolBounds.minWorldX + enemyHalfWidth + (Math.random() * (playableAreaWidth - enemyHalfWidth * 2)),
                            y: patrolBounds.minWorldY + enemyHalfHeight + (Math.random() * (playableWorldYHeight - enemyHalfHeight * 2))
                        };
                    }
                }

                if (e.patrolTarget) { 
                    const distToPatrolTarget = Math.hypot(e.patrolTarget.x - e.x, e.patrolTarget.y - e.y);
                    if (distToPatrolTarget > 0) {
                        const moveX = ((e.patrolTarget.x - e.x) / distToPatrolTarget) * e.speed * dt;
                        const moveY = ((e.patrolTarget.y - e.y) / distToPatrolTarget) * e.speed * dt;
                        proposedEnemyX += moveX;
                        proposedEnemyY += moveY;
                        e.facingAngle = Math.atan2(e.patrolTarget.y - e.y, e.patrolTarget.x - e.x);
                    } else {
                        e.patrolTarget = null;
                    }
                }

                if (now - e.lastInspectionTime > ENEMY_INSPECTION_COOLDOWN_MIN + (Math.random() * (ENEMY_INSPECTION_COOLDOWN_MAX - ENEMY_INSPECTION_COOLDOWN_MIN))) { 
                    const enemyRoomIndex = Math.floor((e.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
                    const potentialHidingSpots = activeHidingSpots.filter(spot => 
                        spot.type.canHideInside && 
                        !spot.isOccupiedByPlayer && 
                        Math.hypot(e.x - spot.x, e.y - spot.y) < ENEMY_INSPECTION_RADIUS &&
                        Math.floor((spot.x - BARRIER_START_WORLD_X) / ROOM_WIDTH) === enemyRoomIndex 
                    );
                    if (potentialHidingSpots.length > 0) {
                        e.inspectionTarget = potentialHidingSpots[Math.floor(Math.random() * potentialHidingSpots.length)];
                        e.awareness = ENEMY_INVESTIGATE_THRESHOLD; 
                        e.lastInspectionTime = now; 
                    }
                }
                break;

            case 'investigating':
                if (prevState !== 'investigating') {
                    e.patrolTarget = null;
                }

                if (e.inspectionTarget) { 
                    const distToTarget = Math.hypot(e.inspectionTarget.x - e.x, e.inspectionTarget.y - e.y);
                    if (distToTarget > e.speed * dt) { 
                        proposedEnemyX += ((e.inspectionTarget.x - e.x)/distToTarget)*e.speed*dt;
                        proposedEnemyY += ((e.inspectionTarget.y - e.y)/distToTarget)*e.speed*dt;
                        e.facingAngle = Math.atan2(e.inspectionTarget.y - e.y, e.inspectionTarget.x - e.x);
                    } else { 
                        e.facingAngle = Math.atan2(player.y - e.y, player.x - e.x); 

                        if (player.isHiding && player.currentHidingSpotId === e.inspectionTarget.id) {
                            e.awareness = 100; 
                            e.state = 'combat'; 
                        }
                        
                        e.inspectionTarget = null; 
                        e.lastInspectionTime = now; 
                    }
                } else if (e.lastKnownSoundLocation.x !== null && e.lastKnownSoundLocation.y !== null) { 
                    const distToSoundLoc = Math.hypot(e.lastKnownSoundLocation.x - e.x, e.lastKnownSoundLocation.y - e.y);
                    if (distToSoundLoc > e.speed * dt) { 
                        proposedEnemyX += ((e.lastKnownSoundLocation.x - e.x)/distToSoundLoc)*e.speed*dt;
                        proposedEnemyY += ((e.lastKnownSoundLocation.y - e.y)/distToSoundLoc)*e.speed*dt;
                        e.facingAngle = Math.atan2(e.lastKnownSoundLocation.y - e.y, e.lastKnownSoundLocation.x - e.x);
                    } else {
                        e.lastKnownSoundLocation = { x: null, y: null };
                    }
                } else {
                    e.facingAngle += ENEMY_IDLE_ROTATION_SPEED * dt;
                    e.facingAngle %= (Math.PI * 2); 
                }
                break;

            case 'reporting_ladder_breach':
                if (!e.alarmReportTarget || !e.alarmReportTarget.alive) { // Target dead or invalid
                    e.state = 'idle'; // Fall back to idle if target is gone
                    e.alarmReportTarget = null;
                    break;
                }
                
                // New: Enemy must cross breached barrier first if target is in another room
                const enemyCurrentRoomIdx = Math.floor((e.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
                const targetRoomIdx = Math.floor((e.alarmReportTarget.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
                
                if (enemyCurrentRoomIdx !== targetRoomIdx) {
                    const pathClear = getPathBetweenPoints(e, e.alarmReportTarget);
                    if (pathClear) {
                        const distToTarget = Math.hypot(e.alarmReportTarget.x - e.x, e.alarmReportTarget.y - e.y);
                        if (distToTarget > e.speed * dt) { 
                            proposedEnemyX += ((e.alarmReportTarget.x - e.x)/distToTarget)*e.speed*dt;
                            proposedEnemyY += ((e.alarmReportTarget.y - e.y)/distToTarget)*e.speed*dt;
                            e.facingAngle = Math.atan2(e.alarmReportTarget.y - e.y, e.alarmReportTarget.x - e.x);
                        } 
                    } else {
                        console.log(`Enemy ${e.id} cannot reach reporting target ${e.alarmReportTarget.id}. Path blocked.`);
                        e.state = 'investigating'; 
                        e.alarmReportTarget = null;
                    }
                } else { // Enemy is in the same room as the alarmReportTarget
                    const distToReportTarget = Math.hypot(e.alarmReportTarget.x - e.x, e.alarmReportTarget.y - e.y);
                    e.facingAngle = Math.atan2(e.alarmReportTarget.y - e.y, e.alarmReportTarget.x - e.x);

                    if (distToReportTarget > ENEMY_ALARM_REPORT_RANGE) {
                        proposedEnemyX += ((e.alarmReportTarget.x - e.x)/distToReportTarget)*e.speed*dt;
                        proposedEnemyY += ((e.alarmReportTarget.y - e.y)/distToReportTarget)*e.speed*dt;
                    } else {
                        // Reached key-holding guard, trigger alarm!
                        if (!e.alarmReportTarget.hasTriggeredAlarm) {
                            isAlarmActive = true;
                            e.alarmReportTarget.hasTriggeredAlarm = true; 
                            e.alarmReportTarget.awareness = ENEMY_COMBAT_THRESHOLD; 
                            e.alarmReportTarget.state = 'combat'; 
                            console.log(`Alarm triggered by key-holder ${e.alarmReportTarget.id} (reported by ${e.id})!`);
                            
                            // NEW: Spawn the alarmReset item at the location of the key-holder's secure building
                            const keyHoldersBuilding = secureBuildings.find(b => b.homeAreaIndex === e.alarmReportTarget.homeAreaIndex && b.hasAlarmPanel);
                            if (keyHoldersBuilding) {
                                alarmTriggeredLocation = { x: keyHoldersBuilding.x, y: keyHoldersBuilding.y };
                                items.push({
                                    x: keyHoldersBuilding.x,
                                    y: keyHoldersBuilding.y + SECURE_BUILDING_HEIGHT / 2 + 50, // Spawn above building
                                    width: ALARM_RESET_DISPLAY_WIDTH,
                                    height: ALARM_RESET_DISPLAY_HEIGHT,
                                    type: 'alarmReset',
                                    collected: false,
                                    rotation: 0 
                                });
                                console.log(`Alarm reset item spawned at secure building ${keyHoldersBuilding.id}.`);
                            } else {
                                console.warn("No secure building found for key-holder's room to spawn alarm reset item.");
                            }
                        }
                        e.alarmReportTarget = null;
                        e.state = 'combat'; 
                    }
                }
                break;

            case 'combat':
                if (prevState !== 'combat') {
                    e.patrolTarget = null;
                    e.inspectionTarget = null;
                    e.lastKnownSoundLocation = { x: null, y: null };
                }
                e.facingAngle = Math.atan2(player.y - e.y, player.x - e.x); 

                let canReachPlayer = getPathBetweenPoints(e, player);

                if (canReachPlayer) {
                    if (dist_player > e.meleeRange + (player.width/2 + e.width/2)/2 ) { 
                        proposedEnemyX += ((player.x - e.x)/dist_player)*e.speed*dt;
                        proposedEnemyY += ((player.y - e.y)/dist_player)*e.speed*dt;
                    } else {
                        if (now - e.lastMeleeTime > e.meleeCooldown) {
                            player.hp -= e.meleeDamage;
                            e.lastMeleeTime = now;
                            if (player.hp <= 0) {
                                player.alive = false;
                            }
                        }
                    }
                } else {
                    e.state = 'investigating'; 
                    e.lastKnownSoundLocation = { x: player.x, y: player.y }; 
                }
                break;
            case 'dead':
                break;
        }

        // Enemy Separation Logic
        for (let j = 0; j < enemies.length; j++) {
            const otherEnemy = enemies[j];
            if (e === otherEnemy || !otherEnemy.alive || otherEnemy.state === 'dead') continue; 

            const dx_other = proposedEnemyX - otherEnemy.x; 
            const dy_other = proposedEnemyY - otherEnemy.y;
            const dist_other = Math.hypot(dx_other, dy_other);

            if (dist_other < ENEMY_SEPARATION_RADIUS && dist_other > 0) {
                const overlap = ENEMY_SEPARATION_RADIUS - dist_other;
                const nx = dx_other / dist_other;
                const ny = dy_other / dist_other;

                proposedEnemyX += nx * overlap * 0.5; 
                proposedEnemyY += ny * overlap * 0.5;
            }
        }

        // --- ENEMY COLLISION AGAINST ALL SOLID BARRIERS AND OBJECTS ---
        const enemyHalfWidth = e.width / 2;
        const enemyHalfHeight = e.height / 2;

        // Vertical Room Barriers (West/East Walls)
        const currentEnemyRoomIdx = Math.floor((e.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
        const barrierCheckRange = Math.max(2, Math.ceil( (enemyHalfWidth + W/2 + BARRIER_RENDER_WIDTH_PIXELS) / ROOM_WIDTH) ); 
        for (let i = currentEnemyRoomIdx - barrierCheckRange; i <= currentEnemyRoomIdx + barrierCheckRange; i++) {
            const barrierDataForCollision = BARRIER_TYPES[Math.abs(i % BARRIER_TYPES.length)]; 
            
            if (barrierDataForCollision.isSolid) {
                const barrierWorldX = BARRIER_START_WORLD_X + (i * ROOM_WIDTH); 
                const barrierLeftEdge  = barrierWorldX - barrierHalfWidth;
                const barrierRightEdge = barrierWorldX + barrierHalfWidth;

                const roomBarrierStatus = worldAreas.get(i);
                const isBarrierBreachedByLadder = roomBarrierStatus ? roomBarrierStatus.isBreachedByLadder : false; 

                if (isBarrierBreachedByLadder && isAlarmActive) { 
                    continue; 
                }

                if (e.x + enemyHalfWidth <= barrierLeftEdge && proposedEnemyX + enemyHalfWidth > barrierLeftEdge) {
                    proposedEnemyX = barrierLeftEdge - enemyHalfWidth; 
                }
                if (e.x - enemyHalfWidth >= barrierRightEdge && proposedEnemyX - enemyHalfWidth < barrierRightEdge) {
                    proposedEnemyX = barrierRightEdge + enemyHalfWidth; 
                }
            }
        }

        // North Barrier (Fixed horizontal wall)
        const northBarrierBottomEdge = NORTHERN_BARRIER_WORLD_Y + BARRIER_RENDER_WIDTH_PIXELS; 
        if (proposedEnemyY - enemyHalfHeight < northBarrierBottomEdge) {
            proposedEnemyY = northBarrierBottomEdge + enemyHalfHeight;
        }

        // South Barrier (Fixed horizontal wall)
        const southBarrierTopEdge = SOUTHERN_BARRIER_WORLD_Y; 
        if (proposedEnemyY + enemyHalfHeight > southBarrierTopEdge) {
            proposedEnemyY = southBarrierTopEdge - enemyHalfHeight;
        }

        // Enemy collision with physical hiding spots (lockers/crates)
        for (const spot of activeHidingSpots) {
            if (spot.type.isPhysical) { 
                const spotLeft = spot.x - spot.width/2;
                const spotRight = spot.x + spot.width/2;
                const spotTop = spot.y - spot.height/2;
                const spotBottom = spot.y + spot.height/2;

                if (proposedEnemyX + enemyHalfWidth > spotLeft && proposedEnemyX - enemyHalfWidth < spotRight &&
                    proposedEnemyY + enemyHalfHeight > spotTop && proposedEnemyY - enemyHalfHeight < spotBottom) {
                    
                    const dx_push = (e.x < spot.x) ? (spotLeft - (proposedEnemyX + enemyHalfWidth)) : (spotRight - (proposedEnemyX - enemyHalfWidth));
                    const dy_push = (e.y < spot.y) ? (spotTop - (proposedEnemyY + enemyHalfHeight)) : (spotBottom - (proposedEnemyY - enemyHalfHeight));

                    if (Math.abs(dx_push) < Math.abs(dy_push)) {
                        proposedEnemyX += dx_push;
                    } else {
                        proposedEnemyY += dy_push;
                    }
                }
            }
        }
        // Enemies should also collide with Guard Shacks and Secure Buildings
        const obstacles = [...guardShacks, ...secureBuildings];
        for (const obstacle of obstacles) {
            const obsLeft = obstacle.x - obstacle.width/2;
            const obsRight = obstacle.x + obstacle.width/2;
            const obsTop = obstacle.y - obstacle.height/2;
            const obsBottom = obstacle.y + obstacle.height/2;

            if (proposedEnemyX + enemyHalfWidth > obsLeft && proposedEnemyX - enemyHalfWidth < obsRight &&
                proposedEnemyY + enemyHalfHeight > obsTop && proposedEnemyY - enemyHalfHeight < obsBottom) {
                
                const dx_push = (e.x < obstacle.x) ? (obsLeft - (proposedEnemyX + enemyHalfWidth)) : (obsRight - (proposedEnemyX - enemyHalfWidth));
                const dy_push = (e.y < obstacle.y) ? (obsTop - (proposedEnemyY + enemyHalfHeight)) : (obsBottom - (proposedEnemyY - enemyHalfHeight));

                if (Math.abs(dx_push) < Math.abs(dy_push)) {
                    proposedEnemyX += dx_push;
                } else {
                    proposedEnemyY += dy_push;
                }
            }
        }


        e.x = proposedEnemyX;
        e.y = proposedEnemyY; 
      }

      // --- Drone AI and Combat ---
      for (const drone of drones) {
          if (!drone.alive) continue;

          let proposedDroneX = drone.x;
          let proposedDroneY = drone.y;

          const droneSawPlayer = canEntitySeePlayer(drone, player); 

          if (droneSawPlayer) {
              drone.state = 'attacking';
              drone.facingAngle = Math.atan2(player.y - drone.y, player.x - drone.x); 

              // Alert nearby enemies (soldiers in the same room)
              for (const enemy of enemies) {
                  const enemyRoomIdx = Math.floor((enemy.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
                  const droneRoomIdx = Math.floor((drone.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
                  const canAlert = (enemyRoomIdx === droneRoomIdx) || (isAlarmActive && getPathBetweenPoints(enemy, drone));

                  if (enemy.alive && canAlert) { 
                      enemy.awareness = Math.min(100, enemy.awareness + DRONE_ALERT_GAIN);
                      if (enemy.state !== 'combat' && enemy.state !== 'reporting_ladder_breach') { 
                          enemy.state = 'combat';
                      }
                      enemy.lastKnownSoundLocation = { x: player.x, y: player.y }; 
                  }
              }

              // Fire on player
              if (now - drone.lastShotTime > drone.fireRate) {
                  player.hp -= drone.damage;
                  drone.lastShotTime = now;
                  drone.laserTarget = { x: player.x, y: player.y }; 
                  drone.laserDuration = DRONE_LASER_DURATION; 
                  console.log(`Drone ${drone.id} fired! Player HP: ${player.hp}`);
                  if (player.hp <= 0) {
                      player.alive = false;
                      console.log("Player killed by drone!");
                  }
              }
          } else { 
              if (drone.state === 'attacking') {
                  drone.state = 'patrolling';
              }

              // Patrolling logic 
              const DRONE_PATROL_THRESHOLD = 70; 
              const patrolBounds = getConnectedRoomBounds(isAlarmActive ? Math.floor((drone.x - BARRIER_START_WORLD_X) / ROOM_WIDTH) : drone.homeAreaIndex);

              if (!drone.patrolTarget || Math.hypot(drone.patrolTarget.x - drone.x, drone.patrolTarget.y - drone.y) < DRONE_PATROL_THRESHOLD) {
                  const droneHalfWidth = drone.width / 2;
                  const droneHalfHeight = DRONE_HEIGHT / 2;
                  const playableAreaWidth = patrolBounds.maxWorldX - patrolBounds.minWorldX;
                  const playableWorldYHeight = patrolBounds.maxWorldY - patrolBounds.minWorldY;

                  if (playableAreaWidth <= droneHalfWidth * 2 || playableWorldYHeight <= droneHalfHeight * 2) {
                      drone.patrolTarget = { x: drone.x, y: drone.y }; 
                  } else {
                      drone.patrolTarget = {
                          x: patrolBounds.minWorldX + droneHalfWidth + (Math.random() * (playableAreaWidth - droneHalfWidth * 2)),
                          y: patrolBounds.minWorldY + droneHalfHeight + (Math.random() * (playableWorldYHeight - droneHalfHeight * 2))
                      };
                  }
              }

              if (drone.patrolTarget) {
                  const distToPatrolTarget = Math.hypot(drone.patrolTarget.x - drone.x, drone.patrolTarget.y - drone.y);
                  if (distToPatrolTarget > 0) {
                      const moveX = ((drone.patrolTarget.x - drone.x) / distToPatrolTarget) * drone.speed * dt;
                      const moveY = ((drone.patrolTarget.y - drone.y) / distToPatrolTarget) * drone.speed * dt;
                      proposedDroneX += moveX;
                      proposedDroneY += moveY;
                      drone.facingAngle = Math.atan2(drone.patrolTarget.y - drone.y, drone.patrolTarget.x - drone.x);
                  } else {
                      drone.patrolTarget = null;
                  }
              }
          }
          
          // --- DRONE COLLISION AGAINST ALL SOLID BARRIERS (NO HIDING SPOTS, THEY FLY) ---
          const droneHalfWidth = drone.width / 2;
          const droneHalfHeight = DRONE_HEIGHT / 2;
          const barrierHalfWidth = BARRIER_RENDER_WIDTH_PIXELS / 2;

          // Vertical Room Barriers (West/East Walls) - Drones ignore if alarm is active
          if (!isAlarmActive) { 
            const currentDroneRoomIdx = Math.floor((drone.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
            const droneBarrierCheckRange = Math.max(2, Math.ceil( (droneHalfWidth + W/2 + BARRIER_RENDER_WIDTH_PIXELS) / ROOM_WIDTH) ); 
            for (let i = currentDroneRoomIdx - droneBarrierCheckRange; i <= currentDroneRoomIdx + droneBarrierCheckRange; i++) {
                const barrierDataForCollision = BARRIER_TYPES[Math.abs(i % BARRIER_TYPES.length)]; 
                
                if (barrierDataForCollision.isSolid) {
                    const barrierWorldX = BARRIER_START_WORLD_X + (i * ROOM_WIDTH); 
                    const barrierLeftEdge  = barrierWorldX - barrierHalfWidth;
                    const barrierRightEdge = barrierWorldX + barrierHalfWidth;

                    const roomBarrierStatus = worldAreas.get(i);
                    const isBarrierBreachedByLadder = roomBarrierStatus ? roomBarrierStatus.isBreachedByLadder : false; 

                    if (isBarrierBreachedByLadder && isAlarmActive) { 
                        continue; 
                    }

                    if (drone.x + droneHalfWidth <= barrierLeftEdge && proposedDroneX + droneHalfWidth > barrierLeftEdge) {
                        proposedDroneX = barrierLeftEdge - droneHalfWidth; 
                    }
                    if (drone.x - droneHalfWidth >= barrierRightEdge && proposedDroneX - droneHalfWidth < barrierRightEdge) {
                        proposedDroneX = barrierRightEdge + droneHalfWidth; 
                    }
                }
            }
          }


          // North Barrier (Fixed horizontal wall) - Drones always ignore fixed horizontal barriers
          if (proposedDroneY - droneHalfHeight < NORTHERN_BARRIER_WORLD_Y + BARRIER_RENDER_WIDTH_PIXELS) {
              proposedDroneY = NORTHERN_BARRIER_WORLD_Y + BARRIER_RENDER_WIDTH_PIXELS + droneHalfHeight;
          }

          // South Barrier (Fixed horizontal wall)
          if (proposedDroneY + droneHalfHeight > SOUTHERN_BARRIER_WORLD_Y) {
              proposedDroneY = SOUTHERN_BARRIER_WORLD_Y - droneHalfHeight;
          }

          // Drones should also collide with Guard Shacks and Secure Buildings
          const droneObstacles = [...guardShacks, ...secureBuildings];
          for (const obstacle of droneObstacles) {
                const obsLeft = obstacle.x - obstacle.width/2;
                const obsRight = obstacle.x + obstacle.width/2;
                const obsTop = obstacle.y - obstacle.height/2;
                const obsBottom = obstacle.y + obstacle.height/2;

                if (proposedDroneX + droneHalfWidth > obsLeft && proposedDroneX - droneHalfWidth < obsRight &&
                    proposedDroneY + droneHalfHeight > obsTop && proposedDroneY - droneHalfHeight < obsBottom) {
                    
                    const dx_push = (drone.x < obstacle.x) ? (obsLeft - (proposedDroneX + droneHalfWidth)) : (obsRight - (proposedDroneX - droneHalfWidth));
                    const dy_push = (drone.y < obstacle.y) ? (obsTop - (proposedDroneY + droneHalfHeight)) : (obsBottom - (proposedDroneY - droneHalfHeight));

                    if (Math.abs(dx_push) < Math.abs(dy_push)) {
                        proposedDroneX += dx_push;
                    } else {
                        proposedDroneY += dy_push;
                    }
                }
            }


          drone.x = proposedDroneX;
          drone.y = proposedDroneY;

          // Decay laser visual timer
          if (drone.laserDuration > 0) {
              drone.laserDuration -= dt;
          }
      }

      // --- Item Collection ---
      for (let i = items.length - 1; i >= 0; i--) {
        const item = items[i];
        if (item.collected) {
            items.splice(i, 1); // Remove collected items
            continue;
        }

        // Update item rotations
        if (item.type === 'buildingKey') {
            item.rotation = (item.rotation + dt * BUILDING_KEY_ROTATION_SPEED) % (Math.PI * 2);
        } else if (item.type === 'ladder') { 
            item.rotation = (item.rotation + dt * LADDER_ROTATION_SPEED) % (Math.PI * 2);
        } else if (item.type === 'firstAidKit') { 
            item.rotation = (item.rotation + dt * 1.0) % (Math.PI * 2); // Generic rotation for first aid
        } else if (item.type === 'alarmReset') {
            item.rotation = (item.rotation + dt * ALARM_RESET_ROTATION_SPEED) % (Math.PI * 2);
        }

        const distToPlayer = Math.hypot(player.x - item.x, player.y - item.y);
        if (distToPlayer < player.width/2 + item.width/2 + PLAYER_ITEM_COLLECTION_RANGE) { 
            if (item.type === 'buildingKey') {
                player.hasBuildingKey = true;
                console.log("Player collected a Building Key!");
            } else if (item.type === 'ladder') { 
                player.hasLadder = true;
                console.log("Player collected a Ladder!");
            } else if (item.type === 'firstAidKit') { 
                player.hp = Math.min(player.maxHp, player.hp + player.maxHp * FIRST_AID_HEAL_PERCENTAGE);
                console.log(`Player collected First Aid Kit! HP: ${player.hp}`);
            } else if (item.type === 'alarmReset' && isAlarmActive) { // Only allow collection if alarm is actually active
                isAlarmActive = false;
                alarmTriggeredLocation = null;
                for (const enemy of enemies) { // Reset enemy alarm flags
                    enemy.hasTriggeredAlarm = false;
                    enemy.ladderBreachAlerted = false;
                }
                console.log("Player disarmed the alarm by collecting the alarm unit!");
            }
            item.collected = true; 
        }
      }
    }

    // Draw everything
    function draw() {
      ctx.clearRect(0,0,W,H);
      // Camera always centered on player
      const camX = player.x - W/2;
      const camY = player.y - H/2; 

      // Background DIV scrolling
      const backgroundRepeatUnitX = 2 * W; 
      const backgroundRepeatUnitY = H; 

      let parallaxX = -player.x;
      parallaxX = (parallaxX % backgroundRepeatUnitX + backgroundRepeatUnitX) % backgroundRepeatUnitX;
      bgEl.style.backgroundPositionX = parallaxX + 'px';

      let parallaxY = -player.y;
      parallaxY = (parallaxY % backgroundRepeatUnitY + backgroundRepeatUnitY) % backgroundRepeatUnitY;
      bgEl.style.backgroundPositionY = parallaxY + 'px';

      // --- Draw the vertical room barriers (WEST/EAST walls) ---
      const firstVisibleBarrierIdx = Math.floor((camX - BARRIER_START_WORLD_X - BARRIER_RENDER_WIDTH_PIXELS) / ROOM_WIDTH);
      const lastVisibleBarrierIdx = Math.ceil((camX + W - BARRIER_START_WORLD_X + BARRIER_RENDER_WIDTH_PIXELS) / ROOM_WIDTH);

      const verticalWallWorldYMin = NORTHERN_BARRIER_WORLD_Y + BARRIER_RENDER_WIDTH_PIXELS; 
      const verticalWallWorldYMax = SOUTHERN_BARRIER_WORLD_Y; 
      
      for (let i = firstVisibleBarrierIdx; i <= lastVisibleBarrierIdx; i++) {
          const roomBarrierData = worldAreas.get(i);
          const isBarrierBreachedByLadder = roomBarrierData ? roomBarrierData.isBreachedByLadder : false; 

          // Always draw the barrier visually, regardless of breach status
          const barrierWorldX = BARRIER_START_WORLD_X + (i * ROOM_WIDTH); 
          let barrierScreenX = barrierWorldX - camX; 

          const selectedBarrierData = BARRIER_TYPES[Math.abs(i % BARRIER_TYPES.length)]; 
          const barrierImage = loadedBarrierImages.get(selectedBarrierData.id);

          if (barrierImage && barrierImage.complete && barrierImage.naturalWidth > 0 && barrierImage.naturalHeight > 0) {
              const renderedBarrierWidth = BARRIER_RENDER_WIDTH_PIXELS; 
              
              const aspectRatio = barrierImage.naturalHeight / barrierImage.naturalWidth;
              const scaledImageHeight = Math.ceil(renderedBarrierWidth * aspectRatio); 

              let currentTileWorldY = Math.max(verticalWallWorldYMin, Math.floor(camY / scaledImageHeight) * scaledImageHeight);

              while (currentTileWorldY < verticalWallWorldYMax + scaledImageHeight) { 
                  const screenY = currentTileWorldY - camY;

                  if (screenY + scaledImageHeight > 0 && screenY < H) {
                      ctx.drawImage(
                          barrierImage, 
                          barrierScreenX - renderedBarrierWidth/2, 
                          screenY,                                        
                          renderedBarrierWidth,                     
                          scaledImageHeight                         
                      );
                  }
                  currentTileWorldY += scaledImageHeight; 
              }
          } 

          // If breached by ladder, draw the ladder on it
          if (isBarrierBreachedByLadder && ladderImg.complete && ladderImg.naturalWidth > 0) {
              const ladderScreenX = barrierScreenX;
              const ladderScreenY = (verticalWallWorldYMin + verticalWallWorldYMax)/2 - camY; // Center of the passage
              ctx.drawImage(ladderImg, ladderScreenX - LADDER_DISPLAY_WIDTH/2, ladderScreenY - LADDER_DISPLAY_HEIGHT/2, LADDER_DISPLAY_WIDTH, LADDER_DISPLAY_HEIGHT);
          }
      }

      // --- Draw the North Barrier (world-fixed horizontally) ---
      const northBarrierImage = loadedBarrierImages.get(NORTHERN_BARRIER_VISUAL_ID);
      if (northBarrierImage && northBarrierImage.complete && northBarrierImage.naturalWidth > 0 && northBarrierImage.naturalHeight > 0) {
          const northBarrierScreenY = NORTHERN_BARRIER_WORLD_Y - camY;
          
          const finalDrawnHeight = BARRIER_RENDER_WIDTH_PIXELS; 
          const finalDrawnWidth = northBarrierImage.naturalHeight * (finalDrawnHeight / northBarrierImage.naturalWidth); 

          const worldLeftEdge = camX;
          const worldRightEdge = camX + W;

          let startWorldX = Math.floor(worldLeftEdge / finalDrawnWidth) * finalDrawnWidth;

          for (let worldX = startWorldX; worldX < worldRightEdge + finalDrawnWidth; worldX += finalDrawnWidth) {
              ctx.save();
              const screenX = worldX - camX;
              const centerX = screenX + finalDrawnWidth / 2; 
              const centerY = northBarrierScreenY + finalDrawnHeight / 2;
              ctx.translate(centerX, centerY);
              ctx.rotate(Math.PI / 2); 
              ctx.drawImage(
                  northBarrierImage, 
                  -finalDrawnWidth / 2,  
                  -finalDrawnHeight / 2, 
                  finalDrawnWidth,       
                  finalDrawnHeight       
              );
              ctx.restore();
          }
      }

      // --- Draw the South Barrier (world-fixed horizontally) ---
      const southBarrierImage = loadedBarrierImages.get(SOUTHERN_BARRIER_VISUAL_ID);
      if (southBarrierImage && southBarrierImage.complete && southBarrierImage.naturalWidth > 0 && southBarrierImage.naturalHeight > 0) {
          const southBarrierScreenY = SOUTHERN_BARRIER_WORLD_Y - camY;
          
          const finalDrawnHeight = BARRIER_RENDER_WIDTH_PIXELS; 
          const finalDrawnWidth = southBarrierImage.naturalHeight * (finalDrawnHeight / southBarrierImage.naturalWidth);

          const worldLeftEdge = camX;
          const worldRightEdge = camX + W;

          let startWorldX = Math.floor(worldLeftEdge / finalDrawnWidth) * finalDrawnWidth;

          for (let worldX = startWorldX; worldX < worldRightEdge + finalDrawnWidth; worldX += finalDrawnWidth) {
              ctx.save();
              const screenX = worldX - camX;
              const centerX = screenX + finalDrawnWidth / 2; 
              const centerY = southBarrierScreenY + finalDrawnHeight / 2; 
              ctx.translate(centerX, centerY);
              ctx.rotate(Math.PI / 2); 
              ctx.drawImage(
                  southBarrierImage, 
                  -finalDrawnWidth / 2,  
                  -finalDrawnHeight / 2, 
                  finalDrawnWidth,       
                  finalDrawnHeight       
              );
              ctx.restore();
          }
      }

      // Draw Guard Shacks
      guardShacks.forEach(shack => {
          const sx = shack.x - camX;
          const sy = shack.y - camY;
          if (guardShackImg.complete && guardShackImg.naturalWidth > 0) {
              ctx.drawImage(guardShackImg, sx - shack.width/2, sy - shack.height/2, shack.width, shack.height);
          } else {
              ctx.fillStyle = 'brown';
              ctx.fillRect(sx - shack.width/2, sy - shack.height/2, shack.width, shack.height);
              ctx.fillStyle = 'white';
              ctx.font = '10px monospace';
              ctx.textAlign = 'center';
              ctx.fillText('SHACK', sx, sy);
          }
      });

      // Draw Secure Buildings
      secureBuildings.forEach(building => {
          const sx = building.x - camX;
          const sy = building.y - camY;
          if (secureBuildingImg.complete && secureBuildingImg.naturalWidth > 0) {
              drawSprite(secureBuildingImg, sx, sy, building.width, building.height, SECURE_BUILDING_GLOW_COLOR, 30);
          } else {
              ctx.fillStyle = 'darkgrey';
              ctx.fillRect(sx - building.width/2, sy - building.height/2, building.width, building.height);
              ctx.fillStyle = 'white';
              ctx.font = '10px monospace';
              ctx.textAlign = 'center';
              ctx.fillText('SECURE', sx, sy - 10);
              ctx.fillText('BUILD', sx, sy + 10);
          }
          
          // Draw static alarm panel if it has one
          if (building.hasAlarmPanel && alarmPanelImg.complete && alarmPanelImg.naturalWidth > 0) {
              ctx.drawImage(alarmPanelImg, sx - ALARM_PANEL_WIDTH/2, sy - ALARM_PANEL_HEIGHT/2, ALARM_PANEL_WIDTH, ALARM_PANEL_HEIGHT);
          }

          // Draw spinning codebook AFTER it's collected
          if (building.codeBookCollected) {
              drawSprite(codebookImg, sx, sy - building.height/2 - 30, CODE_BOOK_DISPLAY_WIDTH, CODE_BOOK_DISPLAY_HEIGHT, CODE_BOOK_GLOW_COLOR, 20, building.codebookRotation);
          }
      });


      // Draw Hiding Spots 
      activeHidingSpots.forEach(spot => {
          const sx = spot.x - camX;
          const sy = spot.y - camY;
          const spotType = spot.type;

          if (spotType.drawType === 'image' && spotType.image.complete && spotType.image.naturalWidth > 0) {
              ctx.drawImage(spotType.image, sx - spot.width/2, sy - spot.height/2, spot.width, spot.height);
          }
      });

      // Draw Oxygen UI if player is hiding in container (now outside of hiding spot loop)
      const currentHidingSpot = activeHidingSpots.find(s => s.id === player.currentHidingSpotId);
      if (player.isHiding && currentHidingSpot && currentHidingSpot.type.canHideInside) {
          const o2TankScreenX = W / 2; // Fixed position relative to screen center
          const o2TankScreenY = H / 2 - player.height / 2 - 100; // Above player

          // Draw O2 Tank Sprite
          drawSprite(o2TankImg, o2TankScreenX, o2TankScreenY, O2_TANK_DISPLAY_WIDTH, O2_TANK_DISPLAY_HEIGHT, O2_TANK_GLOW_COLOR, 20, player.o2TankRotation);

          // Draw Horizontal Oxygen Bar underneath the O2 Tank
          const barX = o2TankScreenX - OXYGEN_BAR_WIDTH / 2;
          const barY = o2TankScreenY + O2_TANK_DISPLAY_HEIGHT / 2 + OXYGEN_BAR_OFFSET_Y; 

          ctx.fillStyle = 'darkgray';
          ctx.fillRect(barX, barY, OXYGEN_BAR_WIDTH, OXYGEN_BAR_HEIGHT);

          const oxygenFillWidth = (player.oxygenLevel / PLAYER_MAX_OXYGEN_LEVEL) * OXYGEN_BAR_WIDTH;
          const oxygenFillX = barX + OXYGEN_BAR_WIDTH - oxygenFillWidth; // Fill from right
          
          let oxygenColor = 'lime';
          if (player.oxygenLevel < PLAYER_MAX_OXYGEN_LEVEL * 0.25) { 
              oxygenColor = 'red';
          } else if (player.oxygenLevel < PLAYER_MAX_OXYGEN_LEVEL * 0.5) { 
              oxygenColor = 'orange';
          }
          ctx.fillStyle = oxygenColor;
          ctx.fillRect(oxygenFillX, barY, oxygenFillWidth, OXYGEN_BAR_HEIGHT); // Draw fill from its start X
          ctx.strokeStyle = 'black';
          ctx.strokeRect(barX, barY, OXYGEN_BAR_WIDTH, OXYGEN_BAR_HEIGHT);

          // O2 icon for the bar
          ctx.fillStyle = 'white';
          ctx.font = `${OXYGEN_BAR_HEIGHT * 0.7}px Arial`; // Use a standard font for emoji if possible
          ctx.textAlign = 'center';
          ctx.textBaseline = 'middle';
          ctx.fillText('O2', barX + OXYGEN_BAR_WIDTH / 2, barY + OXYGEN_BAR_HEIGHT / 2);
      }


      // Player at center of canvas (only draw if not fully hidden, or partially hidden)
      if (!player.isHiding || (player.isHiding && activeHidingSpots.find(s => s.id === player.currentHidingSpotId)?.type?.visionReductionFactor > 0)) {
        drawSprite(playerImg, W/2, H/2, player.width, player.height, 'yellow', 45);
      }
      
      // Draw Player Sound Radius (for debugging/visualizing stealth)
      ctx.beginPath();
      ctx.arc(W/2, H/2, player.currentSoundRadius, 0, Math.PI * 2);
      ctx.fillStyle = 'rgba(255, 255, 0, 0.05)'; 
      ctx.fill();
      ctx.strokeStyle = 'rgba(255, 255, 0, 0.2)';
      ctx.stroke();


      // Enemies relative to camera
      enemies.forEach(e => {
        if (e.alive && e.state !== 'dead') {
            const sx = e.x - camX, sy = e.y - camY;
            drawSprite(enemyImg, sx, sy, e.width, e.height, 'crimson', 60);

            // Draw HP bar above enemy
            const hpBarWidth = e.width * 1.5;
            const hpBarHeight = 5;
            const hpBarX = sx - hpBarWidth / 2;
            const hpBarY = sy - e.height / 2 - 10;
            ctx.fillStyle = 'gray';
            ctx.fillRect(hpBarX, hpBarY, hpBarWidth, hpBarHeight);
            ctx.fillStyle = 'lime';
            ctx.fillRect(hpBarX, hpBarY, hpBarWidth * (e.hp / e.maxHp), hpBarHeight);
            ctx.strokeStyle = 'black';
            ctx.strokeRect(hpBarX, hpBarY, hpBarWidth, hpBarHeight);

            // Draw Vision Cone
            ctx.save();
            ctx.translate(sx, sy); 
            ctx.rotate(e.facingAngle); 

            ctx.beginPath();
            ctx.moveTo(0, 0); 
            ctx.arc(0, 0, e.visionRange, -e.visionAngle / 2, e.visionAngle / 2);
            ctx.closePath();
            
            let coneColor = 'rgba(0, 255, 255, 0.15)'; 
            if (e.state === 'investigating' || e.state === 'reporting_ladder_breach') {
                coneColor = 'rgba(255, 165, 0, 0.2)'; 
            } else if (e.state === 'combat') {
                coneColor = 'rgba(255, 0, 0, 0.25)'; 
            }
            ctx.fillStyle = coneColor; 
            ctx.fill();

            ctx.restore();

            // Draw Hearing Range (always a circle)
            ctx.beginPath();
            ctx.arc(sx, sy, e.hearingRange, 0, Math.PI * 2);
            ctx.fillStyle = 'rgba(0, 0, 255, 0.03)'; 
            ctx.fill();
            ctx.strokeStyle = 'rgba(0, 0, 255, 0.1)'; 
            ctx.stroke();

            // Draw Awareness Bar/Indicator
            const awarenessBarWidth = e.width * 1.5;
            const awarenessBarHeight = 5;
            const awarenessBarX = sx - awarenessBarWidth / 2;
            const awarenessBarY = sy - e.height / 2 - 20; 
            ctx.fillStyle = 'darkblue';
            ctx.fillRect(awarenessBarX, awarenessBarY, awarenessBarWidth, awarenessBarHeight);
            ctx.fillStyle = 'blue';
            ctx.fillRect(awarenessBarX, awarenessBarY, awarenessBarWidth * (e.awareness / 100), awarenessBarHeight);
            ctx.strokeStyle = 'white';
            ctx.strokeRect(awarenessBarX, awarenessBarY, awarenessBarWidth, awarenessBarHeight);

            // Draw last known sound location marker if investigating
            if (e.state === 'investigating' && e.lastKnownSoundLocation.x !== null) {
                const soundMarkerX = e.lastKnownSoundLocation.x - camX;
                const soundMarkerY = e.lastKnownSoundLocation.y - camY;
                ctx.beginPath();
                ctx.arc(soundMarkerX, soundMarkerY, 5, 0, Math.PI * 2);
                ctx.fillStyle = 'yellow';
                ctx.fill();
                ctx.strokeStyle = 'black';
                ctx.stroke();
            }
            // NO "KEY" text above enemy
        }
      });

      // Drones relative to camera
      drones.forEach(d => {
          if (d.alive) {
              const sx = d.x - camX, sy = d.y - camY;
              drawSprite(droneImg, sx, sy, d.width, d.height, DRONE_GLOW_COLOR, 30); 

              // Draw Drone Vision Cone
              ctx.save();
              ctx.translate(sx, sy); 
              ctx.rotate(d.facingAngle); 

              ctx.beginPath();
              ctx.moveTo(0, 0); 
              ctx.arc(0, 0, d.visionRange, -d.visionAngle / 2, d.visionAngle / 2);
              ctx.closePath();
              ctx.fillStyle = 'rgba(128, 0, 128, 0.15)'; 
              ctx.fill();
              ctx.restore();

              // Draw Laser (if active)
              if (d.laserDuration > 0 && d.laserTarget) {
                  ctx.beginPath();
                  ctx.moveTo(sx, sy);
                  ctx.lineTo(d.laserTarget.x - camX, d.laserTarget.y - camY);
                  ctx.strokeStyle = 'red';
                  ctx.lineWidth = 2;
                  ctx.stroke();
              }
          }
      });

      // Draw Helicopter at EZ if present
      if (helicopterPresent) {
          const chopperSx = extractionZoneLocation.x - camX;
          const chopperSy = extractionZoneLocation.y - camY;
          if (chopperImg.complete && chopperImg.naturalWidth > 0) {
              ctx.drawImage(chopperImg, chopperSx - HELICOPTER_SPRITE_WIDTH/2, chopperSy - HELICOPTER_SPRITE_HEIGHT/2, HELICOPTER_SPRITE_WIDTH, HELICOPTER_SPRITE_HEIGHT);
          } else {
              ctx.fillStyle = 'gray';
              ctx.fillRect(chopperSx - HELICOPTER_SPRITE_WIDTH/2, chopperSy - HELICOPTER_SPRITE_HEIGHT/2, HELICOPTER_SPRITE_WIDTH, HELICOPTER_SPRITE_HEIGHT);
              ctx.fillStyle = 'black';
              ctx.font = '12px Arial';
              ctx.textAlign = 'center';
              ctx.fillText('HELICOPTER', chopperSx, chopperSy); // Using text if sprite not loaded
          }
          // Draw EZ radius for player visibility
          ctx.beginPath();
          ctx.arc(chopperSx, chopperSy, EZ_RADIUS, 0, Math.PI * 2);
          ctx.strokeStyle = 'lime';
          ctx.setLineDash([5, 5]); 
          ctx.stroke();
          ctx.setLineDash([]); 
      }


      // Draw collectible items (building keys, ladders, first aid, alarm reset)
      items.forEach(item => {
        if (!item.collected) {
            const sx = item.x - camX, sy = item.y - camY;
            if (item.type === 'buildingKey') {
                drawSprite(buildingKeyImg, sx, sy, item.width, item.height, BUILDING_KEY_GLOW_COLOR, 40, item.rotation); 
            } else if (item.type === 'ladder') { 
                drawSprite(ladderImg, sx, sy, item.width, item.height, LADDER_GLOW_COLOR, 30, item.rotation);
            } else if (item.type === 'firstAidKit') { 
                drawSprite(firstAidImg, sx, sy, item.width, item.height, FIRST_AID_GLOW_COLOR, 30, item.rotation);
            } else if (item.type === 'alarmReset' && isAlarmActive) { // Only draw if alarm is active
                drawSprite(alarmActivatedImg, sx, sy, item.width, item.height, ALARM_RESET_GLOW_COLOR, 40, item.rotation);
            }
        }
      });


      // --- UI elements (Main Canvas) ---
      ctx.fillStyle = 'white';
      ctx.font      = '20px monospace';
      ctx.textAlign = 'left';
      ctx.fillText(`HP: ${player.hp}/${player.maxHp}`, 10, 30);

      ctx.fillStyle = player.hasBuildingKey ? 'gold' : 'gray';
      ctx.fillText(`B. Key: ${player.hasBuildingKey ? 'YES' : 'NO'}`, 10, 60);

      ctx.fillStyle = player.hasLadder ? 'orange' : 'gray';
      ctx.fillText(`Ladder: ${player.hasLadder ? 'YES' : 'NO'}`, 10, 90);

      ctx.fillStyle = player.isHiding ? 'lime' : 'white'; 
      ctx.fillText(`Hiding: ${player.isHiding ? 'YES' : 'NO'}`, 10, 120);
      
      ctx.fillStyle = player.isCrouching ? 'lightblue' : 'white'; 
      ctx.fillText(`Crouching: ${player.isCrouching ? 'YES' : 'NO'}`, 10, 150);

      ctx.fillStyle = player.isCrawling ? 'purple' : 'white'; 
      ctx.fillText(`Crawling: ${player.isCrawling ? 'YES' : 'NO'}`, 10, 180);

      ctx.fillStyle = player.collectedCodeBooksCount >= NUM_CODEBOOKS_TO_COLLECT ? 'yellow' : 'gray'; 
      ctx.fillText(`Code Books: ${player.collectedCodeBooksCount}/${NUM_CODEBOOKS_TO_COLLECT}`, 10, 210);

      // Draw Timer
      const minutes = Math.floor(gameTimerRemaining / 60);
      const seconds = Math.floor(gameTimerRemaining % 60);
      const timerText = `Time: ${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
      
      ctx.fillStyle = gameTimerRemaining <= 10 && gameTimerRemaining > 0 ? 'red' : 'white'; 
      ctx.textAlign = 'right';
      ctx.fillText(timerText, W - 10, 30);

      // Alarm Status UI
      if (isAlarmActive) {
        ctx.fillStyle = 'red';
        ctx.textAlign = 'right';
        ctx.fillText('ALARM ACTIVE!', W - 10, 60);
      }


      ctx.fillStyle = 'white';
      ctx.font = '16px monospace';
      ctx.textAlign = 'left'; 
      ctx.fillText("Move: Arrow Keys", 10, H - 110); 
      ctx.fillText("Crouch: Shift (quieter)", 10, H - 90); 
      ctx.fillText("Crawl: C (quietest)", 10, H - 70); 
      ctx.fillText("Melee: F", 10, H - 50);
      ctx.fillText("Hide/Unhide: H", 10, H - 30); 
      ctx.fillText("Interact (O): Building (Key), Barrier (Ladder), Locker (Ladder), Alarm (Disarm)", 10, H - 10); 


      // --- Game End Messages ---
      if (!player.alive) {
        ctx.fillStyle = 'red';
        ctx.font      = '40px monospace';
        ctx.textAlign = 'center';
        if (timerExpired) {
          ctx.fillText('TIME\'S UP!', W/2, H/2);
        } else if (gameWon) { 
          ctx.fillText('MISSION ACCOMPLISHED!', W/2, H/2); 
        }
        else {
          ctx.fillText('KIA: Hunted Down!', W/2, H/2);
        }
      } else if (gameWon) {
        ctx.fillStyle = 'lime';
        ctx.font      = '40px monospace';
        ctx.textAlign = 'center';
        ctx.fillText('MISSION ACCOMPLISHED!', W/2, H/2);
      }

      // --- ALARM PULSE OVERLAY ---
      if (isAlarmActive) {
          ctx.save();
          ctx.globalAlpha = alarmPulseAlpha;
          ctx.fillStyle = 'red';
          ctx.fillRect(0, 0, W, H);
          ctx.restore();
      }

      // --- Mini-Map Drawing (on miniMapCtx) ---
      drawMiniMap();
    }

    function drawMiniMap() {
        miniMapCtx.clearRect(0, 0, MINIMAP_VIEWPORT_WIDTH, MINIMAP_VIEWPORT_HEIGHT);

        // Get the range of currently initialized rooms
        let minGlobalRoomIdx = Infinity;
        let maxGlobalRoomIdx = -Infinity;
        if (worldAreas.size > 0) {
            for (const key of worldAreas.keys()) {
                if (key < minGlobalRoomIdx) minGlobalRoomIdx = key;
                if (key > maxGlobalRoomIdx) maxGlobalRoomIdx = key;
            }
        } else {
            return; 
        }
        
        const totalRoomSpan = (maxGlobalRoomIdx - minGlobalRoomIdx) + 1;
        if (totalRoomSpan <= 0) return; 

        const roomWidthOnMap = MINIMAP_VIEWPORT_WIDTH / totalRoomSpan; 
        const roomHeightOnMap = MINIMAP_VIEWPORT_HEIGHT * 0.7; 
        const startYOnMap = (MINIMAP_VIEWPORT_HEIGHT - roomHeightOnMap) / 2; 


        // Draw rooms and barriers
        for (let i = minGlobalRoomIdx; i <= maxGlobalRoomIdx; i++) {
            const roomData = worldAreas.get(i);
            if (!roomData) continue; 

            const mapRoomX = (i - minGlobalRoomIdx) * roomWidthOnMap;

            miniMapCtx.fillStyle = 'rgba(50, 50, 50, 0.5)'; 
            miniMapCtx.fillRect(mapRoomX, startYOnMap, roomWidthOnMap, roomHeightOnMap);
            miniMapCtx.strokeStyle = '#555';
            miniMapCtx.strokeRect(mapRoomX, startYOnMap, roomWidthOnMap, roomHeightOnMap);

            // Draw barriers if not breached by ladder
            if (roomData.populated && !roomData.isBreachedByLadder) { 
                 miniMapCtx.fillStyle = 'rgba(200, 20, 20, 0.8)'; 
                 miniMapCtx.fillRect(mapRoomX + roomWidthOnMap - 2, startYOnMap, 4, roomHeightOnMap); 
            } else if (roomData.populated && roomData.isBreachedByLadder) {
                 miniMapCtx.fillStyle = 'rgba(20, 200, 20, 0.4)'; // Light green for breached
                 miniMapCtx.fillRect(mapRoomX + roomWidthOnMap - 2, startYOnMap, 4, roomHeightOnMap); 
            }
        }

        // Draw Player position
        const currentPlayerRoomIdx = Math.floor((player.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
        const playerMapX = (currentPlayerRoomIdx - minGlobalRoomIdx) * roomWidthOnMap + roomWidthOnMap / 2;
        const playerMapY = startYOnMap + roomHeightOnMap / 2;
        miniMapCtx.beginPath();
        miniMapCtx.arc(playerMapX, playerMapY, 5, 0, Math.PI * 2);
        miniMapCtx.fillStyle = 'yellow';
        miniMapCtx.fill();
        miniMapCtx.strokeStyle = 'black';
        miniMapCtx.stroke();


        // Draw Secure Building locations
        secureBuildings.forEach(building => {
            const buildingRoomIdx = Math.floor((building.x - BARRIER_START_WORLD_X) / ROOM_WIDTH);
            const mapBuildingX = (buildingRoomIdx - minGlobalRoomIdx) * roomWidthOnMap + roomWidthOnMap / 2;
            const mapBuildingY = startYOnMap + roomHeightOnMap * 0.25; 
            miniMapCtx.fillStyle = building.codeBookCollected ? 'darkblue' : 'blue';
            miniMapCtx.font = `${roomWidthOnMap * 0.4}px monospace`; 
            miniMapCtx.textAlign = 'center';
            miniMapCtx.textBaseline = 'middle';
            // Only show CB on minimap if objective is active or collected (no static CB above building)
            miniMapCtx.fillText('CB', mapBuildingX, mapBuildingY); 
        });

        // Draw Extraction Zone location
        if (extractionZoneIndex !== null && worldAreas.has(extractionZoneIndex)) {
            const mapEZX = (extractionZoneIndex - minGlobalRoomIdx) * roomWidthOnMap + roomWidthOnMap / 2;
            const mapEZY = startYOnMap + roomHeightOnMap * 0.75; 
            miniMapCtx.fillStyle = 'lime';
            miniMapCtx.font = `${roomWidthOnMap * 0.4}px monospace`; 
            miniMapCtx.textAlign = 'center';
            miniMapCtx.textBaseline = 'middle';
            miniMapCtx.fillText('EZ', mapEZX, mapEZY);
        }
    }


    // Main loop
    let last = 0;
    function loop(now) {
      if (!last) last = now;
      const dt = (now - last)/1000;
      last = now;

      update(dt);
      draw();
      // Only request next frame if game is not won or lost
      if (player.alive && !gameWon) { 
        requestAnimationFrame(loop);
      }
    }

    // --- Asset Loading System ---
    let assetsToLoadCount = 0;
    const allAssetsToLoad = [];

    allAssetsToLoad.push({ img: playerImg, path: ASSET_PATHS.player, name: 'player' });
    allAssetsToLoad.push({ img: terrainImg, path: ASSET_PATHS.terrain, name: 'terrain' });
    allAssetsToLoad.push({ img: armyLockerImg, path: ASSET_PATHS.armyLocker, name: 'armyLocker' });
    allAssetsToLoad.push({ img: closedCrateImg, path: ASSET_PATHS.closedCrate, name: 'closedCrate' });
    allAssetsToLoad.push({ img: foliageBushImg, path: ASSET_PATHS.foliageBush, name: 'foliageBush' });
    allAssetsToLoad.push({ img: buildingKeyImg, path: ASSET_PATHS.buildingKey, name: 'buildingKey' }); 
    allAssetsToLoad.push({ img: droneImg, path: ASSET_PATHS.drone, name: 'drone' }); 
    allAssetsToLoad.push({ img: chopperImg, path: ASSET_PATHS.chopper, name: 'chopper' }); 
    allAssetsToLoad.push({ img: guardShackImg, path: ASSET_PATHS.guardShack, name: 'guardShack' }); 
    allAssetsToLoad.push({ img: firstAidImg, path: ASSET_PATHS.firstAid, name: 'firstAid' }); 
    allAssetsToLoad.push({ img: secureBuildingImg, path: ASSET_PATHS.secureBuilding, name: 'secureBuilding' }); 
    allAssetsToLoad.push({ img: ladderImg, path: ASSET_PATHS.ladder, name: 'ladder' }); 
    allAssetsToLoad.push({ img: alarmPanelImg, path: ASSET_PATHS.alarmPanel, name: 'alarmPanel' }); 
    allAssetsToLoad.push({ img: o2TankImg, path: ASSET_PATHS.o2Tank, name: 'o2Tank' }); // New
    allAssetsToLoad.push({ img: codebookImg, path: ASSET_PATHS.codebook, name: 'codebook' }); // New
    allAssetsToLoad.push({ img: alarmActivatedImg, path: ASSET_PATHS.alarmActivated, name: 'alarmActivated' }); // New


    BARRIER_TYPES.forEach(barrier => {
        const img = new Image();
        allAssetsToLoad.push({ img: img, path: barrier.imagePath, name: barrier.id });
        loadedBarrierImages.set(barrier.id, img); 
    });

    function assetLoadingComplete() {
        assetsToLoadCount++;
        if (assetsToLoadCount === allAssetsToLoad.length) { 
            console.log("All assets loaded. Initializing game...");
            initializeGame();
        }
    }

    function initializeGame() {
        W = canvas.width  = innerWidth; 
        H = canvas.height = innerHeight;
        
        ROOM_WIDTH = W * 1.5; 
        BARRIER_START_WORLD_X = 0; 

        // Reset player state
        player.x = BARRIER_START_WORLD_X + ROOM_WIDTH / 2; 
        player.y = 0;         
        player.lastMoveAngle = 0; 
        player.alive = true; 
        player.isHiding = false; 
        player.isCrouching = false; 
        player.isCrawling = false; 
        player.hasBuildingKey = false; 
        player.hasLadder = false; 
        player.hp = player.maxHp; 
        player.oxygenLevel = PLAYER_MAX_OXYGEN_LEVEL; 
        player.collectedCodeBooksCount = 0; 
        player.o2TankRotation = 0;

        // Reset game state arrays and flags
        enemies.length = 0; 
        items.length = 0;
        drones.length = 0; 
        guardShacks.length = 0; 
        activeHidingSpots.length = 0; 
        secureBuildings.length = 0; 
        worldAreas.clear(); 

        gameTimerRemaining = GAME_DURATION_SECONDS;
        timerExpired = false;
        gameWon = false; 
        helicopterPresent = false;
        isAlarmActive = false; 
        alarmTriggeredLocation = null;

        // Initialize worldAreas map with default status for a broad range of rooms
        const initialRoomRangeStart = -5; 
        const initialRoomRangeEnd = 5;    
        for (let i = initialRoomRangeStart; i <= initialRoomRangeEnd; i++) { 
            worldAreas.set(i, { 
                isBreachedByLadder: false, 
                currentEnemies: [], 
                maxEnemies: 0, 
                populated: false 
            });
        }

        // --- Select Secure Areas and Extraction Zone ---
        const possibleObjectiveRooms = [];
        for (let i = initialRoomRangeStart; i <= initialRoomRangeEnd; i++) {
            // Include room 0 as a possible objective room
            possibleObjectiveRooms.push(i); 
        }
        
        NUM_CODEBOOKS_TO_COLLECT = Math.floor(Math.random() * 3) + 1; 
        console.log(`Mission Objective: Collect ${NUM_CODEBOOKS_TO_COLLECT} Code Book(s).`);

        if (possibleObjectiveRooms.length < NUM_CODEBOOKS_TO_COLLECT + 1) { 
            console.error("Not enough rooms to place objectives! Adjust initialRoomRange or reduce NUM_CODEBOOKS_TO_COLLECT.");
            NUM_CODEBOOKS_TO_COLLECT = Math.min(NUM_CODEBOOKS_TO_COLLECT, possibleObjectiveRooms.length -1); 
            if (NUM_CODEBOOKS_TO_COLLECT < 1) NUM_CODEBOOKS_TO_COLLECT = 1;
        }

        // Select N unique rooms for secure buildings, ensuring they are not too close to the start
        const selectedSecureAreaRooms = [];
        let attempts = 0;
        const potentialSecureRoomsForSelection = possibleObjectiveRooms.filter(idx => Math.abs(idx - 0) >= MIN_OBJECTIVE_ROOM_OFFSET);
        if (potentialSecureRoomsForSelection.length < NUM_CODEBOOKS_TO_COLLECT) {
            console.warn("Not enough far-away rooms for secure buildings. Some might be closer than MIN_OBJECTIVE_ROOM_OFFSET.");
            potentialSecureRoomsForSelection.push(...possibleObjectiveRooms); // Fallback to all rooms
        }

        while (selectedSecureAreaRooms.length < NUM_CODEBOOKS_TO_COLLECT && attempts < 200) {
            const roomIdx = potentialSecureRoomsForSelection[Math.floor(Math.random() * potentialSecureRoomsForSelection.length)];
            if (!selectedSecureAreaRooms.includes(roomIdx)) {
                selectedSecureAreaRooms.push(roomIdx);
            }
            attempts++;
        }
        if (selectedSecureAreaRooms.length < NUM_CODEBOOKS_TO_COLLECT) {
            console.error("Could not find enough unique rooms for secure buildings after many attempts.");
            // Add any remaining unique rooms if not enough were found (can lead to fewer than NUM_CODEBOOKS_TO_COLLECT)
            while(selectedSecureAreaRooms.length < NUM_CODEBOOKS_TO_COLLECT && possibleObjectiveRooms.length > selectedSecureAreaRooms.length){
                const roomIdx = possibleObjectiveRooms[Math.floor(Math.random() * possibleObjectiveRooms.length)];
                if (!selectedSecureAreaRooms.includes(roomIdx)) {
                    selectedSecureAreaRooms.push(roomIdx);
                }
            }
        }

        // Select Extraction Zone (EZ)
        let ezRoomFound = false;
        attempts = 0;
        const potentialEZRoomsForSelection = possibleObjectiveRooms.filter(idx => !selectedSecureAreaRooms.includes(idx) && Math.abs(idx - 0) >= MIN_OBJECTIVE_ROOM_OFFSET);
        if (potentialEZRoomsForSelection.length === 0) {
            console.warn("No ideal far-away rooms for EZ. Choosing from remaining available rooms.");
            potentialEZRoomsForSelection.push(...possibleObjectiveRooms.filter(idx => !selectedSecureAreaRooms.includes(idx)));
        }

        while (!ezRoomFound && attempts < 100) {
            const roomIdx = potentialEZRoomsForSelection[Math.floor(Math.random() * potentialEZRoomsForSelection.length)];
            if (!selectedSecureAreaRooms.includes(roomIdx)) { // EZ must not be a secure area
                extractionZoneIndex = roomIdx;
                ezRoomFound = true;
            }
            attempts++;
        }
        if (!ezRoomFound) {
            console.error("Could not find a unique room for Extraction Zone. Defaulting to a fixed offset.");
            extractionZoneIndex = possibleObjectiveRooms.find(r => !selectedSecureAreaRooms.includes(r)) || (selectedSecureAreaRooms.length > 0 ? selectedSecureAreaRooms[0] + 1 : 1);
            if (extractionZoneIndex === 0 && selectedSecureAreaRooms.includes(0)) { // Ensure EZ is not 0 if a secure building is there
                extractionZoneIndex = 1;
            }
        }
        
        console.log(`Secure Areas (Code Books) in Rooms: ${selectedSecureAreaRooms.join(', ')}`);
        console.log(`Extraction Zone (EZ) in Room: ${extractionZoneIndex}`);

        const ezBounds = getConnectedRoomBounds(extractionZoneIndex); 
        extractionZoneLocation.x = ezBounds.minWorldX + (ezBounds.maxWorldX - ezBounds.minWorldX) / 2;
        extractionZoneLocation.y = ezBounds.minWorldY + (ezBounds.maxWorldY - ezBounds.minWorldY) / 2;

        // Spawn entities in relevant areas (including initial room)
        const roomsToPopulate = new Set([0, extractionZoneIndex, ...selectedSecureAreaRooms]);
        for (const roomIdx of roomsToPopulate) {
            const maxEnemiesInArea = 1 + Math.floor(Math.random() * 2); 
            worldAreas.get(roomIdx).maxEnemies = maxEnemiesInArea;
            spawnEnemiesAndDronesInArea(roomIdx, maxEnemiesInArea, 'idle');
        }
        console.log("Initial guards, drones, and shacks spawned in objective and starting rooms.");

        // Spawn Secure Buildings and assign key-holding guards
        selectedSecureAreaRooms.forEach((secureRoomIdx, index) => {
            const secureRoomBounds = getConnectedRoomBounds(secureRoomIdx);
            let newBuildingX, newBuildingY;
            let placementAttempts = 0;
            const MAX_BUILDING_PLACEMENT_ATTEMPTS = 100;
            const buildingHalfWidth = SECURE_BUILDING_WIDTH / 2;
            const buildingHalfHeight = SECURE_BUILDING_HEIGHT / 2;
            const playableAreaWidth = secureRoomBounds.maxWorldX - secureRoomBounds.minWorldX;
            const playableAreaHeight = secureRoomBounds.maxWorldY - secureRoomBounds.minWorldY;

            do {
                newBuildingX = secureRoomBounds.minWorldX + buildingHalfWidth + (Math.random() * (playableAreaWidth - buildingHalfWidth * 2));
                newBuildingY = secureRoomBounds.minWorldY + buildingHalfHeight + (Math.random() * (playableAreaHeight - buildingHalfHeight * 2));
                placementAttempts++;
            } while (isOverlappingAnyObstacle(newBuildingX, newBuildingY, SECURE_BUILDING_WIDTH, SECURE_BUILDING_HEIGHT, [...secureBuildings, ...guardShacks, ...activeHidingSpots]) && placementAttempts < MAX_BUILDING_PLACEMENT_ATTEMPTS);

            if (placementAttempts < MAX_BUILDING_PLACEMENT_ATTEMPTS) {
                const newBuilding = {
                    x: newBuildingX,
                    y: newBuildingY,
                    width: SECURE_BUILDING_WIDTH,
                    height: SECURE_BUILDING_HEIGHT,
                    homeAreaIndex: secureRoomIdx,
                    id: `secureBuilding-${Date.now()}-${index}`,
                    hasCodeBook: true, 
                    codeBookCollected: false,
                    hasAlarmPanel: true,
                    codebookRotation: 0 // Initialize rotation for collected codebook sprite
                };
                secureBuildings.push(newBuilding);
                console.log(`Secure Building ${newBuilding.id} spawned in room ${secureRoomIdx}.`);

                // Assign a random enemy in this room to be the key holder for this building
                const enemiesInThisRoom = enemies.filter(e => e.homeAreaIndex === secureRoomIdx && e.alive);
                if (enemiesInThisRoom.length > 0) {
                    const keyHolder = enemiesInThisRoom[Math.floor(Math.random() * enemiesInThisRoom.length)];
                    keyHolder.isBuildingKeyHolder = true;
                    console.log(`Enemy ${keyHolder.id} in room ${secureRoomIdx} is now the Building Key Holder.`);
                } else {
                    console.warn(`No enemies found in room ${secureRoomIdx} to assign Building Key for building ${newBuilding.id}.`);
                }
            } else {
                 console.warn(`Failed to find non-overlapping spot for Secure Building in area ${secureRoomIdx} after ${MAX_BUILDING_PLACEMENT_ATTEMPTS} attempts.`);
            }
        });


        // Place initial Hiding Spots and Ladders
        const roomsToPlaceHidingSpotsIn = new Set([...roomsToPopulate]); // Include all populated rooms
        for (const roomIdx of roomsToPlaceHidingSpotsIn) {
            const roomBounds = getConnectedRoomBounds(roomIdx);
            const playableAreaWidth = roomBounds.maxWorldX - roomBounds.minWorldX;
            const playableAreaHeight = roomBounds.maxWorldY - roomBounds.minWorldY;

            const placeObjectInRoom = (typeDef, objWidth, objHeight, maxAttempts = 50) => {
                let objX, objY;
                let attempts = 0;
                do {
                    objX = roomBounds.minWorldX + objWidth / 2 + (Math.random() * (playableAreaWidth - objWidth));
                    objY = roomBounds.minWorldY + objHeight / 2 + (Math.random() * (playableAreaHeight - objHeight));
                    attempts++;
                } while (isOverlappingAnyObstacle(objX, objY, objWidth, objHeight, [...activeHidingSpots, ...guardShacks, ...secureBuildings]) && attempts < maxAttempts);

                if (attempts < maxAttempts) {
                    activeHidingSpots.push({ 
                        id: `${typeDef.id}-${roomIdx}-${Date.now()}`, type: typeDef, 
                        x: objX, y: objY, 
                        width: objWidth, height: objHeight, isOccupiedByPlayer: false,
                        hasLadder: false 
                    });
                    return true;
                } else {
                    console.warn(`Failed to find non-overlapping spot for ${typeDef.id} in area ${roomIdx}.`);
                    return false;
                }
            };

            // Add lockers
            placeObjectInRoom(HIDING_SPOT_TYPES.locker, 50, 80);
            // Add bushes
            placeObjectInRoom(HIDING_SPOT_TYPES.bush, 100, 100);
            // Add crates
            placeObjectInRoom(HIDING_SPOT_TYPES.crate, 64, 64);
        }
        
        // Randomly assign ONE ladder to a locker in the STARTING room (room 0)
        const lockersInStartingRoom = activeHidingSpots.filter(spot => 
            spot.type.id === 'locker' && 
            Math.floor((spot.x - BARRIER_START_WORLD_X) / ROOM_WIDTH) === 0
        );
        if (lockersInStartingRoom.length > 0) {
            const ladderLocker = lockersInStartingRoom[Math.floor(Math.random() * lockersInStartingRoom.length)];
            ladderLocker.hasLadder = true;
            console.log(`Locker ${ladderLocker.id} in room 0 contains a Ladder.`);
        } else {
            console.warn(`No lockers found in room 0 to place ladder.`);
        }

        console.log(`Placed ${activeHidingSpots.length} hiding spots.`);

        requestAnimationFrame(loop);
        console.log("Game loop and entities started.");
    }

    // Start loading all assets
    allAssetsToLoad.forEach(asset => {
        asset.img.onload = assetLoadingComplete;
        asset.img.onerror = (e) => {
            console.error(`Error loading ${asset.path} (ID: ${asset.name}):`, e);
            assetLoadingComplete(); // Still call so game can attempt to start even with missing assets
        };
        asset.img.src = asset.path; 
    });

    // Handle window resizing
    addEventListener('resize', () => {
      W = canvas.width  = innerWidth;
      H = canvas.height = innerHeight;
      ROOM_WIDTH = W * 1.5; 
      console.log(`Resized and re-calculated ROOM_WIDTH: ${ROOM_WIDTH}px`);
    });
  </script>
</body>
</html>