diff --git a/indexbt.html b/indexbt.html
deleted file mode 100644
index 50c3784..0000000
--- a/indexbt.html
+++ /dev/null
@@ -1,2072 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <meta charset="utf-8">
-    <title>Office Adventure Game</title>
-    <style>
-        body {
-            margin: 0;
-            padding: 0;
-            display: flex;
-            justify-content: center;
-            align-items: center;
-            min-height: 100vh;
-            background: #333;
-        }
-        #game-container {
-            position: relative;
-        }
-        #loading {
-            position: absolute;
-            top: 50%;
-            left: 50%;
-            transform: translate(-50%, -50%);
-            color: white;
-            font-family: Arial, sans-serif;
-            font-size: 24px;
-            display: none;
-        }
-    </style>
-    <script src="https://cdn.jsdelivr.net/npm/phaser@3.60.0/dist/phaser.min.js"></script>
-    <script src="https://cdn.jsdelivr.net/npm/easystarjs@0.4.4/bin/easystar-0.4.4.js"></script>
-</head>
-<body>
-    <div id="game-container">
-        <div id="loading">Loading...</div>
-    </div>
-
-    <script>
-        const config = {
-            type: Phaser.AUTO,
-            width: 1280,
-            height: 720,
-            parent: 'game-container',
-            pixelArt: true,
-            physics: {
-                default: 'arcade',
-                arcade: {
-                    gravity: { y: 0 },
-                    debug: true
-                }
-            },
-            scene: {
-                preload: preload,
-                create: create,
-                update: update
-            },
-            inventory: {
-                items: [],
-                display: null
-            }
-        };
-        const TILE_SIZE = 48;
-        const DOOR_ALIGN_OVERLAP = 48*3;
-        const GRID_SIZE = 32;
-        const MOVEMENT_SPEED = 150;
-        const ARRIVAL_THRESHOLD = 8;
-        const PATH_UPDATE_INTERVAL = 500;
-        const STUCK_THRESHOLD = 1;
-        const STUCK_TIME = 500;
-        // Hide rooms initially and on exit
-        const hideRoomsInitially = true;
-        const hideRoomsOnExit = false;
-        const hideNonAdjacentRooms = false;
-
-        // Declare gameScenario as let (not const) so we can assign it later
-        let gameScenario = null;  // Initialize as null
-
-        let game = new Phaser.Game(config);
-        let player;
-        let cursors;
-        let rooms = {};
-        let currentRoom;
-        let inventory = {
-            items: [],
-            container: null
-        };
-        let objectsGroup;
-        let wallsLayer;
-        let discoveredRooms = new Set();
-        let pathfinder;
-        let currentPath = [];
-        let isMoving = false;
-        let targetPoint = null;
-        let lastPathUpdateTime = 0;
-        let stuckTimer = 0;
-        let lastPosition = null;
-        let stuckTime = 0;
-        let currentPlayerRoom = null;
-        let lastPlayerPosition = { x: 0, y: 0 };
-        const ROOM_CHECK_THRESHOLD = 32; // Only check for room changes when player moves this many pixels
-
-        // Add these constants at the top with other constants
-        const INTERACTION_CHECK_INTERVAL = 100; // Only check interactions every 100ms
-        const INTERACTION_RANGE = 2 * TILE_SIZE;
-        const INTERACTION_RANGE_SQ = INTERACTION_RANGE * INTERACTION_RANGE;
-
-        // Add new Bluetooth state
-        let bluetoothDevices = [];
-        const BLUETOOTH_SCAN_RANGE = TILE_SIZE * 5;
-        const BLUETOOTH_MIN_SIGNAL = 30;
-
-        // preloads the assets
-        function preload() {
-            // Show loading text
-            document.getElementById('loading').style.display = 'block';
-
-            // Load tilemap files and regular tilesets first
-            this.load.tilemapTiledJSON('room_reception', 'assets/rooms/room_reception.json');
-            this.load.tilemapTiledJSON('room_office', 'assets/rooms/room_office.json');
-            this.load.tilemapTiledJSON('room_ceo', 'assets/rooms/room_ceo.json');
-            this.load.tilemapTiledJSON('room_closet', 'assets/rooms/room_closet.json');
-            this.load.tilemapTiledJSON('room_servers', 'assets/rooms/room_servers.json');
-            this.load.image('Modern_Office_48x48', 'assets/Modern_Office_48x48.png');
-            this.load.image('Room_Builder_48x48', 'assets/Room_Builder_48x48.png');
-            this.load.image('19_Hospital_Shadowless_48x48', 'assets/19_Hospital_Shadowless_48x48.png');
-            this.load.image('18_Jail_Shadowless_48x48', 'assets/18_Jail_Shadowless_48x48.png');
-            this.load.image('1_Generic_Shadowless_48x48', 'assets/1_Generic_Shadowless_48x48.png');
-            this.load.image('11_Halloween_Shadowless_48x48', 'assets/11_Halloween_Shadowless_48x48.png');
-            this.load.image('5_Classroom_and_library_Shadowless_48x48', 'assets/5_Classroom_and_library_Shadowless_48x48.png');
-            
-            // Load object sprites
-            this.load.image('pc', 'assets/objects/pc.png');
-            this.load.image('key', 'assets/objects/key.png');
-            this.load.image('notes', 'assets/objects/notes.png');
-            this.load.image('phone', 'assets/objects/phone.png');
-            this.load.image('suitcase', 'assets/objects/suitcase.png');
-            this.load.image('smartscreen', 'assets/objects/smartscreen.png');
-            this.load.image('photo', 'assets/objects/photo.png');
-            this.load.image('suitcase', 'assets/objects/suitcase.png');
-            this.load.image('safe', 'assets/objects/safe.png');
-            this.load.image('book', 'assets/objects/book.png');
-            this.load.image('bluetooth_scanner', 'assets/objects/bluetooth_scanner.png');
-            this.load.image('tablet', 'assets/objects/tablet.png');
-
-            this.load.json('gameScenarioJSON', 'assets/scenarios/ceo_exfil.json');
-            gameScenario = this.cache.json.get('gameScenarioJSON');
-        }
-
-        // creates the game
-        // hides the loading text
-        // calculates the world bounds
-        // sets the physics world bounds
-        // creates the player
-        // initializes the rooms
-        // validates the doors by room overlap
-        // hides all rooms initially if hideRoomsInitially is true
-        // reveals only the starting room
-        // sets up the camera
-        // sets up the input
-        // creates the inventory display
-        // processes all door collisions
-        // initializes the pathfinder
-        // initializes the inventory
-        function create() {
-            // Hide loading text
-            document.getElementById('loading').style.display = 'none';
-
-            // Ensure gameScenario is loaded before proceeding
-            if (!gameScenario) {
-                gameScenario = this.cache.json.get('gameScenarioJSON');
-            }
-
-            // Now calculate world bounds after scenario is loaded
-            const worldBounds = calculateWorldBounds();
-            
-            // Set the physics world bounds
-            this.physics.world.setBounds(
-                worldBounds.x, 
-                worldBounds.y, 
-                worldBounds.width, 
-                worldBounds.height
-            );
-
-            // Create player first
-            player = this.add.rectangle(400, 300, 32, 32, 0xff0000);
-            this.physics.add.existing(player);
-            player.body.setSize(16, 16);
-            player.body.setOffset(8, 8);
-            player.body.setCollideWorldBounds(true);
-            player.body.setBounce(0);
-            player.body.setDrag(0);
-            player.body.setFriction(0);
-
-            player.setDepth(1000);
-
-            // Initialize room layout after player creation
-            initializeRooms.call(this);
-            validateDoorsByRoomOverlap.call(this);
-
-            // Hide all rooms initially if hideRoomsInitially is true
-            if (hideRoomsInitially) {
-                Object.keys(gameScenario.rooms).forEach(roomId => {
-                    hideRoom.call(this, roomId);
-                });
-            }
-
-            // Explicitly reveal the starting room and ensure its doors are visible
-            const startingRoom = gameScenario.startRoom;
-            revealRoom.call(this, startingRoom);
-            
-            // Force doors visibility for starting room
-            if (rooms[startingRoom] && rooms[startingRoom].doorsLayer) {
-                rooms[startingRoom].doorsLayer.setVisible(true);
-                rooms[startingRoom].doorsLayer.setAlpha(1);
-                console.log(`Starting room doors layer:`, {
-                    visible: rooms[startingRoom].doorsLayer.visible,
-                    alpha: rooms[startingRoom].doorsLayer.alpha,
-                    depth: rooms[startingRoom].doorsLayer.depth
-                });
-            }
-
-            // Setup camera
-            this.cameras.main.startFollow(player);
-            this.cameras.main.setZoom(1);
-
-            // Setup input with proper context
-            this.input.on('pointerdown', (pointer) => {
-                // Check if click is in inventory area
-                const inventoryArea = {
-                    y: this.cameras.main.height - 70,
-                    height: 70
-                };
-                
-                if (pointer.y > inventoryArea.y) {
-                    // Find clicked inventory item
-                    const clickedItem = inventory.items.find(item => {
-                        if (!item) return false;
-                        const bounds = item.getBounds();
-                        return Phaser.Geom.Rectangle.Contains(
-                            bounds,
-                            pointer.x,
-                            pointer.y
-                        );
-                    });
-                    
-                    if (clickedItem) {
-                        console.log('Inventory item clicked:', clickedItem.name);
-                        handleObjectInteraction(clickedItem);
-                        return;
-                    }
-                }
-                
-                // if not clicking inventory, handle as movement
-                console.log('Click detected at:', pointer.worldX, pointer.worldY);
-                movePlayerToPoint.call(this, pointer.worldX, pointer.worldY);
-            });
-
-            // creates the inventory display
-            createInventoryDisplay.call(this);
-
-            // Add this new call after all rooms are created
-            processAllDoorCollisions.call(this);
-
-            // Initialize pathfinder
-            initializePathfinder.call(this);
-
-            // Initialize game systems
-            initializeInventory.call(this);
-
-            // Add this line after processAllDoorCollisions()
-            setupDoorOverlapChecks.call(this);
-
-            // Add this before introduceScenario.call(this)
-            console.log('=== Room Objects ===');
-            Object.entries(rooms).forEach(([roomId, room]) => {
-                console.log(`Room ${roomId} objects:`, room.objects);
-            });
-
-            // FIND Add bluetooth scanner
-            //addBluetoothScanner.call(this);
-
-            // introduce the scenario
-            introduceScenario.call(this);
-
-            // Enable physics debug only in development
-            this.physics.world.debugGraphic.clear();
-            this.physics.world.drawDebug = false;
-
-            // Optimize physics world
-            this.physics.world.setBounds(
-                worldBounds.x, 
-                worldBounds.y, 
-                worldBounds.width, 
-                worldBounds.height,
-                true  // Enable bounds collision
-            );
-            
-            // Optimize physics settings
-            this.physics.world.setFPS(60);
-            this.physics.world.step(1/60);
-        }
-
-        function update() {
-            // updates the player's movement
-            updatePlayerMovement.call(this);
-            
-            // checks for object interactions
-            checkObjectInteractions.call(this);
-            
-            // checks for room transitions
-            checkRoomTransitions.call(this);
-            
-            // adds a circle to the start of the path
-            if (currentPath && currentPath.length > 0 && isMoving) {
-                this.add.circle(currentPath[0].x, currentPath[0].y, 5, 0xff0000).setDepth(1000);
-            }
-        }
-
-        // introduces the scenario
-        function introduceScenario() {
-            console.log(gameScenario.scenario_brief);
-            alert(gameScenario.scenario_brief);
-        }
-
-        // initializes the rooms
-        // calculates the positions of the rooms
-        // creates the rooms
-        function initializeRooms() {
-            // Calculate room positions and create room instances
-            let roomPositions = calculateRoomPositions();
-            
-            Object.entries(gameScenario.rooms).forEach(([roomId, roomData]) => {
-                const position = roomPositions[roomId];
-                createRoom.call(this, roomId, roomData, position);
-            });
-        }
-
-        // calculates the positions of the rooms
-        // calculates the dimensions of the rooms
-        // calculates the positions of the rooms based on the dimensions and overlaps
-        function calculateRoomPositions() {
-            const OVERLAP = 96;
-            const positions = {};
-            
-            console.log('=== Starting Room Position Calculations ===');
-            
-            // Get room dimensions from tilemaps
-            const roomDimensions = {};
-            Object.entries(gameScenario.rooms).forEach(([roomId, roomData]) => {
-                const map = game.cache.tilemap.get(roomData.type);
-                console.log(`Debug - Room ${roomId}:`, {
-                    mapData: map,
-                    fullData: map?.data,
-                    json: map?.json
-                });
-                
-                // Try different ways to access the data
-                if (map) {
-                    let width, height;
-                    if (map.json) {
-                        width = map.json.width;
-                        height = map.json.height;
-                    } else if (map.data) {
-                        width = map.data.width;
-                        height = map.data.height;
-                    } else {
-                        width = map.width;
-                        height = map.height;
-                    }
-                    
-                    roomDimensions[roomId] = {
-                        width: width * 48,  // tile width is 48
-                        height: height * 48 // tile height is 48
-                    };
-                    console.log(`Room ${roomId} dimensions:`, roomDimensions[roomId]);
-                } else {
-                    console.error(`Could not find tilemap data for room ${roomId}`);
-                    // Fallback to default dimensions if needed
-                    roomDimensions[roomId] = {
-                        width: 800,  // default width
-                        height: 600  // default height
-                    };
-                }
-            });
-            
-            // Start with reception room at origin
-            positions[gameScenario.startRoom] = { x: 0, y: 0 };
-            console.log(`Starting room ${gameScenario.startRoom} position:`, positions[gameScenario.startRoom]);
-            
-            // Process rooms level by level, starting from reception
-            const processed = new Set([gameScenario.startRoom]);
-            const queue = [gameScenario.startRoom];
-            
-            while (queue.length > 0) {
-                const currentRoomId = queue.shift();
-                const currentRoom = gameScenario.rooms[currentRoomId];
-                const currentPos = positions[currentRoomId];
-                const currentDimensions = roomDimensions[currentRoomId];
-                
-                console.log(`\nProcessing room ${currentRoomId}`);
-                console.log('Current position:', currentPos);
-                console.log('Connections:', currentRoom.connections);
-                
-                Object.entries(currentRoom.connections).forEach(([direction, connected]) => {
-                    console.log(`\nProcessing ${direction} connection:`, connected);
-                    
-                    if (Array.isArray(connected)) {
-                        const rooms = connected.filter(r => !processed.has(r));
-                        console.log('Unprocessed connected rooms:', rooms);
-                        if (rooms.length === 0) return;
-                        
-                        if (direction === 'north' || direction === 'south') {
-                            const firstRoom = rooms[0];
-                            const firstRoomWidth = roomDimensions[firstRoom].width;
-                            const firstRoomHeight = roomDimensions[firstRoom].height;
-                            
-                            const secondRoom = rooms[1];
-                            const secondRoomWidth = roomDimensions[secondRoom].width;
-                            const secondRoomHeight = roomDimensions[secondRoom].height;
-                            
-                            if (direction === 'north') {
-                                // First room - right edge aligns with current room's left edge
-                                positions[firstRoom] = {
-                                    x: currentPos.x - firstRoomWidth + DOOR_ALIGN_OVERLAP,
-                                    y: currentPos.y - firstRoomHeight + OVERLAP
-                                };
-                                
-                                // Second room - left edge aligns with current room's right edge
-                                positions[secondRoom] = {
-                                    x: currentPos.x + currentDimensions.width - DOOR_ALIGN_OVERLAP,
-                                    y: currentPos.y - secondRoomHeight + OVERLAP
-                                };
-                            } else if (direction === 'south') {
-                                // First room - left edge aligns with current room's right edge
-                                positions[firstRoom] = {
-                                    x: currentPos.x - firstRoomWidth + DOOR_ALIGN_OVERLAP,
-                                    y: currentPos.y + currentDimensions.height - OVERLAP
-                                };
-                                
-                                // Second room - right edge aligns with current room's left edge
-                                positions[secondRoom] = {
-                                    x: currentPos.x + currentDimensions.width - DOOR_ALIGN_OVERLAP,
-                                    y: currentPos.y + currentDimensions.height - secondRoomHeight - OVERLAP
-                                };
-                            }
-                            
-                            rooms.forEach(roomId => {
-                                processed.add(roomId);
-                                queue.push(roomId);
-                                console.log(`Positioned room ${roomId} at:`, positions[roomId]);
-                            });
-                        }
-                    } else {
-                        if (processed.has(connected)) {
-                            console.log(`Room ${connected} already processed, skipping`);
-                            return;
-                        }
-                        
-                        const connectedDimensions = roomDimensions[connected];
-                        
-                        // Center the connected room
-                        const x = currentPos.x + 
-                            (currentDimensions.width - connectedDimensions.width) / 2;
-                        const y = direction === 'north'
-                            ? currentPos.y - connectedDimensions.height + OVERLAP
-                            : currentPos.y + currentDimensions.height - OVERLAP;
-                        
-                        positions[connected] = { x, y };
-                        processed.add(connected);
-                        queue.push(connected);
-                        
-                        console.log(`Positioned single room ${connected} at:`, positions[connected]);
-                    }
-                });
-            }
-            
-            console.log('\n=== Final Room Positions ===');
-            Object.entries(positions).forEach(([roomId, pos]) => {
-                console.log(`${roomId}:`, pos);
-            });
-            
-            return positions;
-        }
-
-        // creates a room
-        // creates the tilemap for the room
-        // creates the layers for the room
-        // adds the objects to the room
-        function createRoom(roomId, roomData, position) {
-            try {
-                console.log(`Creating room ${roomId} of type ${roomData.type}`);
-                
-                const map = this.make.tilemap({ key: roomData.type });
-                const tilesets = [];
-                
-                // Add tilesets
-                const regularTilesets = map.tilesets.filter(t => !t.name.includes('Interiors_48x48'));
-                regularTilesets.forEach(tileset => {
-                    const loadedTileset = map.addTilesetImage(tileset.name, tileset.name);
-                    if (loadedTileset) {
-                        tilesets.push(loadedTileset);
-                        console.log(`Added regular tileset: ${tileset.name}`);
-                    }
-                });
-
-                // Initialize room data structure first
-                rooms[roomId] = {
-                    map,
-                    layers: {},
-                    wallsLayers: [],
-                    position
-                };
-
-                const layers = rooms[roomId].layers;
-                const wallsLayers = rooms[roomId].wallsLayers;
-                
-                // IMPORTANT: This counter ensures unique layer IDs across ALL rooms and should not be removed
-                if (!window.globalLayerCounter) window.globalLayerCounter = 0;
-
-                // Calculate base depth for this room's layers
-                const roomDepth = position.y * 100;
-                
-                // Create doors layer first with a specific depth
-                const doorsLayerIndex = map.layers.findIndex(layer => 
-                    layer.name.toLowerCase().includes('doors'));
-                let doorsLayer = null;
-                if (doorsLayerIndex !== -1) {
-                    window.globalLayerCounter++;
-                    const uniqueDoorsId = `${roomId}_doors_${window.globalLayerCounter}`;
-                    doorsLayer = map.createLayer(doorsLayerIndex, tilesets, position.x, position.y);
-                    if (doorsLayer) {
-                        doorsLayer.name = uniqueDoorsId;
-                        // Set doors layer depth higher than other layers
-                        doorsLayer.setDepth(roomDepth + 500);
-                        layers[uniqueDoorsId] = doorsLayer;
-                        rooms[roomId].doorsLayer = doorsLayer;
-                    }
-                }
-
-                // Create other layers with appropriate depths
-                map.layers.forEach((layerData, index) => {
-                    // Skip the doors layer as we already created it
-                    if (index === doorsLayerIndex) return;
-
-                    window.globalLayerCounter++;
-                    const uniqueLayerId = `${roomId}_${layerData.name}_${window.globalLayerCounter}`;
-                    
-                    const layer = map.createLayer(index, tilesets, position.x, position.y);
-                    if (layer) {
-                        layer.name = uniqueLayerId;
-                        
-                        // Set depth based on layer type and room position
-                        if (layerData.name.toLowerCase().includes('floor')) {
-                            layer.setDepth(roomDepth + 100);
-                        } else if (layerData.name.toLowerCase().includes('walls')) {
-                            layer.setDepth(roomDepth + 200);
-                            // Handle walls layer collision
-                            try {
-                                layer.setCollisionByExclusion([-1]);
-                                
-                                if (doorsLayer) {
-                                    const doorTiles = doorsLayer.getTilesWithin()
-                                        .filter(tile => tile.index !== -1);
-                                    
-                                    doorTiles.forEach(doorTile => {
-                                        const wallTile = layer.getTileAt(doorTile.x, doorTile.y);
-                                        if (wallTile) {
-                                            if (!doorTile.properties?.locked) {
-                                                wallTile.setCollision(false);
-                                            }
-                                        }
-                                    });
-                                }
-                                
-                                wallsLayers.push(layer);
-                                console.log(`Added collision to wall layer: ${uniqueLayerId}`);
-                            } catch (e) {
-                                console.warn(`Error setting up collisions for ${uniqueLayerId}:`, e);
-                            }
-                        } else if (layerData.name.toLowerCase().includes('props')) {
-                            layer.setDepth(roomDepth + 300);
-                        } else {
-                            layer.setDepth(roomDepth + 400);
-                        }
-                        
-                        layers[uniqueLayerId] = layer;
-                        layer.setVisible(false);
-                        layer.setAlpha(0);
-                    }
-                });
-
-                // Add collisions between player and wall layers
-                if (player && player.body) {
-                    wallsLayers.forEach(wallLayer => {
-                        if (wallLayer) {
-                            this.physics.add.collider(player, wallLayer);
-                            console.log(`Added collision between player and wall layer: ${wallLayer.name}`);
-                        }
-                    });
-                }
-
-                // Store door layer reference for later processing
-                if (doorsLayer) {
-                    rooms[roomId].doorsLayer = doorsLayer;
-                }
-
-                // Update object creation to handle new structure
-                const objectsLayer = map.getObjectLayer('Object Layer 1');
-                if (objectsLayer && objectsLayer.objects) {
-                    rooms[roomId].objects = {};
-                    
-                    objectsLayer.objects.forEach(obj => {
-                        // Find matching object in scenario data
-                        const scenarioObject = gameScenario.rooms[roomId].objects.find(
-                            item => item.type === obj.name
-                        );
-                        
-                        // Check if this object should be active in the current scenario
-                        const isActiveObject = scenarioObject !== undefined;
-                        
-                        const sprite = this.add.sprite(
-                            position.x + obj.x,
-                            position.y + (obj.gid !== undefined ? obj.y - obj.height : obj.y),
-                            obj.name
-                        );
-                        
-                        sprite.setOrigin(0, 0);
-                        sprite.name = obj.name;
-                        sprite.setInteractive({ useHandCursor: true });
-                        sprite.setDepth(1001);
-                        sprite.originalAlpha = 1;
-                        sprite.active = isActiveObject;
-                        
-                        // Store scenario data with sprite for later use
-                        if (isActiveObject) {
-                            sprite.scenarioData = scenarioObject;
-                        }
-                        
-                        // Initially hide all objects - they'll be shown when room is revealed
-                        sprite.setVisible(false);
-                        
-                        if (obj.rotation) {
-                            sprite.setRotation(Phaser.Math.DegToRad(obj.rotation));
-                        }
-                        
-                        rooms[roomId].objects[obj.name] = sprite;
-                        
-                        // Add click handler for all objects
-                        sprite.on('pointerdown', () => {
-                            if (isActiveObject) {
-                                console.log(`Clicked active object ${obj.name}`);
-                                handleObjectInteraction(sprite);
-                            } else {
-                                alert("Nothing of note here");
-                            }
-                        });
-                    });
-                }
-
-                // After processing tilemap objects, add scenario-specific objects
-                if (gameScenario.rooms[roomId].objects) {
-                    gameScenario.rooms[roomId].objects.forEach(scenarioObj => {
-                        // Skip if object already exists from tilemap
-                        if (!rooms[roomId].objects[scenarioObj.type]) {
-                            console.log(`Creating scenario object in ${roomId}:`, scenarioObj);
-                            const sprite = createObjectSprite(
-                                this,
-                                scenarioObj,
-                                position.x + TILE_SIZE * 2, // Default position
-                                position.y + TILE_SIZE * 2
-                            );
-                            rooms[roomId].objects[scenarioObj.type] = sprite;
-                        }
-                    });
-                }
-
-            } catch (error) {
-                console.error(`Error creating room ${roomId}:`, error);
-                console.error('Error details:', error.stack);
-            }
-        }
-
-        // reveals a room
-        // reveals all layers and objects in the room
-        function revealRoom(roomId) {
-            if (rooms[roomId]) {
-                const room = rooms[roomId];
-                
-                // Reveal all layers
-                Object.values(room.layers).forEach(layer => {
-                    if (layer && layer.setVisible) {
-                        layer.setVisible(true);
-                        layer.setAlpha(1);
-                    }
-                });
-                
-                // Explicitly reveal doors layer if it exists
-                if (room.doorsLayer) {
-                    room.doorsLayer.setVisible(true);
-                    room.doorsLayer.setAlpha(1);
-                }
-                
-                // Show all objects
-                if (room.objects) {
-                    Object.values(room.objects).forEach(obj => {
-                        if (obj && obj.setVisible && obj.active) { // Only show active objects
-                            obj.setVisible(true);
-                            obj.alpha = obj.active ? (obj.originalAlpha || 1) : 0.3;
-                        }
-                    });
-                }
-                
-                discoveredRooms.add(roomId);
-            }
-            currentRoom = roomId;
-        }
-
-        // moves the player to a point
-        // ensures the coordinates are within the world bounds
-        function movePlayerToPoint(x, y) {
-            const worldBounds = this.physics.world.bounds;
-            
-            // Ensure coordinates are within bounds
-            x = Phaser.Math.Clamp(x, worldBounds.x, worldBounds.x + worldBounds.width);
-            y = Phaser.Math.Clamp(y, worldBounds.y, worldBounds.y + worldBounds.height);
-            
-            targetPoint = { x, y };
-            isMoving = true;
-        }
-
-        // updates the player's movement
-        // moves the player towards the target point
-        // stops if a collision is detected
-        function updatePlayerMovement() {
-            if (!isMoving || !targetPoint) {
-                if (player.body.velocity.x !== 0 || player.body.velocity.y !== 0) {
-                    player.body.setVelocity(0, 0);
-                }
-                return;
-            }
-
-            // Cache player position
-            const px = player.x;
-            const py = player.y;
-            
-            // Use squared distance for performance
-            const dx = targetPoint.x - px;
-            const dy = targetPoint.y - py;
-            const distanceSq = dx * dx + dy * dy;
-
-            // Reached target point
-            if (distanceSq < ARRIVAL_THRESHOLD * ARRIVAL_THRESHOLD) {
-                isMoving = false;
-                player.body.setVelocity(0, 0);
-                return;
-            }
-
-            // Only check room transitions periodically
-            const movedX = Math.abs(px - lastPlayerPosition.x);
-            const movedY = Math.abs(py - lastPlayerPosition.y);
-            
-            if (movedX > ROOM_CHECK_THRESHOLD || movedY > ROOM_CHECK_THRESHOLD) {
-                updatePlayerRoom();
-                lastPlayerPosition.x = px;
-                lastPlayerPosition.y = py;
-            }
-
-            // Normalize movement vector for consistent speed
-            const distance = Math.sqrt(distanceSq);
-            const velocityX = (dx / distance) * MOVEMENT_SPEED;
-            const velocityY = (dy / distance) * MOVEMENT_SPEED;
-
-            // Only update velocity if it changed significantly
-            const currentVX = player.body.velocity.x;
-            const currentVY = player.body.velocity.y;
-            const velocityDiffX = Math.abs(currentVX - velocityX);
-            const velocityDiffY = Math.abs(currentVY - velocityY);
-
-            if (velocityDiffX > 1 || velocityDiffY > 1) {
-                player.body.setVelocity(velocityX, velocityY);
-            }
-
-            // Stop if collision detected
-            if (player.body.blocked.none === false) {
-                isMoving = false;
-                player.body.setVelocity(0, 0);
-            }
-        }
-
-        // creates the inventory display
-        // creates the background and slot outlines
-        function createInventoryDisplay() {
-            
-            // Create slot outlines
-            const slotsContainer = this.add.container(110, this.cameras.main.height - 60)
-                .setScrollFactor(0)
-                .setDepth(2001);
-            
-            // Create 10 slot outlines
-            for (let i = 0; i < 10; i++) {
-                const outline = this.add.rectangle(
-                    i * 60, 
-                    0,
-                    50,
-                    50,
-                    0x666666,
-                    0.3
-                );
-                outline.setStrokeStyle(1, 0x666666);
-                slotsContainer.add(outline);
-            }
-            
-            // Initialize inventory container with highest depth
-            inventory.container = this.add.container(110, this.cameras.main.height - 60)
-                .setScrollFactor(0)
-                .setDepth(2002);
-
-            // Modify the input event to check if clicking on inventory
-            this.input.on('pointerdown', (pointer) => {
-                // Convert pointer position to world coordinates
-                const worldPoint = this.cameras.main.getWorldPoint(pointer.x, pointer.y);
-                
-                // Check if click is in inventory area
-                const inventoryArea = {
-                    x: 100,
-                    y: this.cameras.main.height - 70,
-                    width: this.cameras.main.width - 200,
-                    height: 70
-                };
-                
-                if (pointer.y > inventoryArea.y) {
-                    // Click is in inventory area, let the inventory sprites handle it
-                    return;
-                }
-                
-                // Otherwise, handle as movement click
-                console.log('Click detected at:', worldPoint.x, worldPoint.y);
-                movePlayerToPoint.call(this, worldPoint.x, worldPoint.y);
-            });
-        }
-
-        // checks for object interactions
-        // highlights the object if the player is in range
-        // handles the click event for the object
-        function checkObjectInteractions() {
-            // Skip if not enough time has passed since last check
-            const currentTime = performance.now();
-            if (this.lastInteractionCheck && 
-                currentTime - this.lastInteractionCheck < INTERACTION_CHECK_INTERVAL) {
-                return;
-            }
-            this.lastInteractionCheck = currentTime;
-
-            const playerRoom = currentPlayerRoom;
-            if (!playerRoom || !rooms[playerRoom].objects) return;
-
-            // Cache player position
-            const px = player.x;
-            const py = player.y;
-            
-            // Get only objects within viewport bounds plus some margin
-            const camera = this.cameras.main;
-            const margin = INTERACTION_RANGE;
-            const viewBounds = {
-                left: camera.scrollX - margin,
-                right: camera.scrollX + camera.width + margin,
-                top: camera.scrollY - margin,
-                bottom: camera.scrollY + camera.height + margin
-            };
-
-            Object.values(rooms[playerRoom].objects).forEach(obj => {
-                // Skip inactive objects and those outside viewport
-                if (!obj.active || 
-                    obj.x < viewBounds.left || 
-                    obj.x > viewBounds.right || 
-                    obj.y < viewBounds.top || 
-                    obj.y > viewBounds.bottom) {
-                    return;
-                }
-
-                // Use squared distance for performance
-                const dx = px - obj.x;
-                const dy = py - obj.y;
-                const distanceSq = dx * dx + dy * dy;
-
-                if (distanceSq <= INTERACTION_RANGE_SQ) {
-                    // Check for Bluetooth unlocking
-                    if (obj.scenarioData?.type === 'tablet' && obj.scenarioData.locked) {
-                        const scanner = inventory.items.find(item => 
-                            item.scenarioData?.type === "bluetooth_scanner"
-                        );
-                        
-                        if (scanner) {
-                            const devices = getBluetoothDevicesInRange({ x: scanner.x, y: scanner.y });
-                            const matchingDevice = devices.find(d => 
-                                d.mac === obj.scenarioData.mac && 
-                                d.signalStrength >= BLUETOOTH_MIN_SIGNAL
-                            );
-                            
-                            if (matchingDevice) {
-                                console.log('=== Tablet Unlocked ===');
-                                console.log('Scanner position:', { x: scanner.x, y: scanner.y });
-                                console.log('Tablet position:', { x: obj.x, y: obj.y });
-                                console.log('Signal strength:', matchingDevice.signalStrength);
-                                obj.scenarioData.locked = false;
-                            }
-                        }
-                    }
-
-                    if (!obj.isHighlighted) {
-                        obj.isHighlighted = true;
-                        obj.setTint(0xdddddd);
-                    }
-                } else if (obj.isHighlighted) {
-                    obj.isHighlighted = false;
-                    obj.clearTint();
-                }
-            });
-        }
-
-        // checks for room transitions
-        function checkRoomTransitions() {
-            // Now handled by physics overlap
-        }
-
-        // calculates the world bounds
-        function calculateWorldBounds() {
-            if (!gameScenario || !gameScenario.rooms) {
-                console.error('Game scenario not loaded properly');
-                // Return default bounds
-                return {
-                    x: -1800,
-                    y: -1800,
-                    width: 3600,
-                    height: 3600
-                };
-            }
-
-            let minX = -1800, minY = -1800, maxX = 1800, maxY = 1800;
-            
-            // Check all room positions to determine world bounds
-            Object.values(gameScenario.rooms).forEach(room => {
-                const position = calculateRoomPositions()[room.id];
-                if (position) {
-                    // Assuming each room is 800x600
-                    minX = Math.min(minX, position.x);
-                    minY = Math.min(minY, position.y);
-                    maxX = Math.max(maxX, position.x + 800);
-                    maxY = Math.max(maxY, position.y + 600);
-                }
-            });
-
-            // Add some padding
-            const padding = 200;
-            return {
-                x: minX - padding,
-                y: minY - padding,
-                width: (maxX - minX) + (padding * 2),
-                height: (maxY - minY) + (padding * 2)
-            };
-        }
-
-        // processes all door-wall interactions
-        function processAllDoorCollisions() {
-            Object.entries(rooms).forEach(([roomId, room]) => {
-                if (room.doorsLayer) {
-                    const doorTiles = room.doorsLayer.getTilesWithin()
-                        .filter(tile => tile.index !== -1);
-
-                    // Find all rooms that overlap with this room
-                    Object.entries(rooms).forEach(([otherId, otherRoom]) => {
-                        if (roomsOverlap(room.position, otherRoom.position)) {
-                            otherRoom.wallsLayers.forEach(wallLayer => {
-                                processDoorCollisions(doorTiles, wallLayer, room.doorsLayer);
-                            });
-                        }
-                    });
-                }
-            });
-        }
-
-        // processes door collisions
-        // sets the collision of the door tile to false
-        // visually indicates the door opening
-        function processDoorCollisions(doorTiles, wallLayer, doorsLayer) {
-            doorTiles.forEach(doorTile => {
-                // Convert door tile coordinates to world coordinates
-                const worldX = doorsLayer.x + (doorTile.x * doorsLayer.tilemap.tileWidth);
-                const worldY = doorsLayer.y + (doorTile.y * doorsLayer.tilemap.tileHeight);
-                
-                // Convert world coordinates back to the wall layer's local coordinates
-                const wallX = Math.floor((worldX - wallLayer.x) / wallLayer.tilemap.tileWidth);
-                const wallY = Math.floor((worldY - wallLayer.y) / wallLayer.tilemap.tileHeight);
-                
-                const wallTile = wallLayer.getTileAt(wallX, wallY);
-                if (wallTile) {
-                    if (doorTile.properties?.locked) {
-                        wallTile.setCollision(true);
-                    } else {
-                        wallTile.setCollision(false);
-                    }
-                }
-            });
-        }
-
-        // checks if two rooms overlap
-        function roomsOverlap(pos1, pos2) {
-            // Add some tolerance for overlap detection
-            const OVERLAP_TOLERANCE = 48; // One tile width
-            const ROOM_WIDTH = 800;
-            const ROOM_HEIGHT = 600;
-            
-            return !(pos1.x + ROOM_WIDTH - OVERLAP_TOLERANCE < pos2.x || 
-                     pos1.x > pos2.x + ROOM_WIDTH - OVERLAP_TOLERANCE || 
-                     pos1.y + ROOM_HEIGHT - OVERLAP_TOLERANCE < pos2.y || 
-                     pos1.y > pos2.y + ROOM_HEIGHT - OVERLAP_TOLERANCE);
-        }
-
-        // initializes the pathfinder
-        // creates a grid of the world
-        function initializePathfinder() {
-            const worldBounds = this.physics.world.bounds;
-            const gridWidth = Math.ceil(worldBounds.width / GRID_SIZE);
-            const gridHeight = Math.ceil(worldBounds.height / GRID_SIZE);
-            
-            try {
-                pathfinder = new EasyStar.js();
-                const grid = Array(gridHeight).fill().map(() => Array(gridWidth).fill(0));
-                
-                // Mark walls
-                Object.values(rooms).forEach(room => {
-                    room.wallsLayers.forEach(wallLayer => {
-                        wallLayer.getTilesWithin().forEach(tile => {
-                            // Only mark as unwalkable if the tile collides AND hasn't been disabled for doors
-                            if (tile.collides && tile.canCollide) {  // Add check for canCollide
-                                const gridX = Math.floor((tile.x * TILE_SIZE + wallLayer.x - worldBounds.x) / GRID_SIZE);
-                                const gridY = Math.floor((tile.y * TILE_SIZE + wallLayer.y - worldBounds.y) / GRID_SIZE);
-                                
-                                if (gridX >= 0 && gridX < gridWidth && gridY >= 0 && gridY < gridHeight) {
-                                    grid[gridY][gridX] = 1;
-                                }
-                            }
-                        });
-                    });
-                });
-
-                pathfinder.setGrid(grid);
-                pathfinder.setAcceptableTiles([0]);
-                pathfinder.enableDiagonals();
-                
-                console.log('Pathfinding initialized successfully');
-            } catch (error) {
-                console.error('Error initializing pathfinder:', error);
-            }
-        }
-
-        // smooths the path
-        function smoothPath(path) {
-            if (path.length <= 2) return path;
-            
-            const smoothed = [path[0]];
-            for (let i = 1; i < path.length - 1; i++) {
-                const prev = path[i - 1];
-                const current = path[i];
-                const next = path[i + 1];
-                
-                // Calculate the angle change
-                const angle1 = Phaser.Math.Angle.Between(prev.x, prev.y, current.x, current.y);
-                const angle2 = Phaser.Math.Angle.Between(current.x, current.y, next.x, next.y);
-                const angleDiff = Math.abs(Phaser.Math.Angle.Wrap(angle1 - angle2));
-                
-                // Only keep points where there's a significant direction change
-                if (angleDiff > 0.2) { // About 11.5 degrees
-                    smoothed.push(current);
-                }
-            }
-            smoothed.push(path[path.length - 1]);
-            
-            return smoothed;
-        }
-
-        // debugs the path
-        function debugPath(path) {
-            if (!path) return;
-            console.log('Current path:', {
-                pathLength: path.length,
-                currentTarget: path[0],
-                playerPos: { x: player.x, y: player.y },
-                isMoving: isMoving
-            });
-        }
-
-        // optimizes the path
-        function optimizePath(path) {
-            if (path.length <= 2) return path;
-            
-            const optimized = [path[0]];
-            let currentPoint = 0;
-            
-            while (currentPoint < path.length - 1) {
-                // Look ahead as far as possible along a straight line
-                let furthestVisible = currentPoint + 1;
-                for (let i = currentPoint + 2; i < path.length; i++) {
-                    if (canMoveDirectly(path[currentPoint], path[i])) {
-                        furthestVisible = i;
-                    } else {
-                        break;
-                    }
-                }
-                
-                // Add the furthest visible point to our optimized path
-                optimized.push(path[furthestVisible]);
-                currentPoint = furthestVisible;
-            }
-            
-            return optimized;
-        }
-
-        // checks if direct movement is possible
-        function canMoveDirectly(start, end) {
-            // Check if there are any walls between start and end points
-            const distance = Phaser.Math.Distance.Between(start.x, start.y, end.x, end.y);
-            const angle = Phaser.Math.Angle.Between(start.x, start.y, end.x, end.y);
-            
-            // Check several points along the line
-            const steps = Math.ceil(distance / (GRID_SIZE / 2));
-            const stepSize = distance / steps;
-            
-            for (let i = 1; i < steps; i++) {
-                const pointX = start.x + Math.cos(angle) * (stepSize * i);
-                const pointY = start.y + Math.sin(angle) * (stepSize * i);
-                
-                // Check if this point intersects with any walls
-                let collision = false;
-                Object.values(rooms).forEach(room => {
-                    room.wallsLayers.forEach(wallLayer => {
-                        const tile = wallLayer.getTileAtWorldXY(pointX, pointY);
-                        if (tile && tile.collides) {
-                            collision = true;
-                        }
-                    });
-                });
-                
-                if (collision) {
-                    return false;
-                }
-            }
-            
-            return true;
-        }
-
-        // updates the player's room
-        function updatePlayerRoom() {
-            // Update last position
-            lastPlayerPosition = { x: player.x, y: player.y };
-
-            let overlappingRooms = [];
-
-            // Check all rooms for overlap
-            for (const [roomId, room] of Object.entries(rooms)) {
-                const bounds = getRoomBounds(roomId);
-                if (isPlayerInBounds(bounds)) {
-                    overlappingRooms.push(roomId);
-                    
-                    // Reveal room if not already visible
-                    if (!discoveredRooms.has(roomId)) {
-                        console.log(`Player overlapping room: ${roomId}`);
-                        revealRoom(roomId);
-                    }
-                }
-            }
-
-            // If we're not overlapping any rooms
-            if (overlappingRooms.length === 0) {
-                console.log('Player not in any room');
-                currentPlayerRoom = null;
-                return null;
-            }
-
-            // Update current room (use the first overlapping room as the "main" room)
-            if (currentPlayerRoom !== overlappingRooms[0]) {
-                console.log(`Player's main room changed to: ${overlappingRooms[0]}`);
-                currentPlayerRoom = overlappingRooms[0];
-                onRoomChange(overlappingRooms[0]);
-            }
-
-            return currentPlayerRoom;
-        }
-
-        // gets the bounds of a room
-        function getRoomBounds(roomId) {
-            const room = rooms[roomId];
-            return {
-                x: room.position.x,
-                y: room.position.y,
-                width: room.map.widthInPixels,
-                height: room.map.heightInPixels
-            };
-        }
-
-        // checks if the player is in bounds
-        function isPlayerInBounds(bounds) {
-            const buffer = 0; // Changed from TILE_SIZE (48) to 0
-            return (
-                player.x >= bounds.x - buffer &&
-                player.x <= bounds.x + bounds.width + buffer &&
-                player.y >= bounds.y - buffer &&
-                player.y <= bounds.y + bounds.height + buffer
-            );
-        }
-
-        // handles room changes
-        // reveals the new room
-        // hides rooms that aren't connected and aren't currently being overlapped
-        function onRoomChange(newRoomId) {
-            // Reveal the new room (although it should already be revealed)
-            revealRoom.call(this, newRoomId);
-            
-            // Only hide rooms that aren't connected AND aren't currently being overlapped
-            Object.keys(rooms).forEach(roomId => {
-                const bounds = getRoomBounds(roomId);
-                const playerOverlapping = isPlayerInBounds(bounds);
-                
-                if (hideNonAdjacentRooms && !playerOverlapping && !isConnectedRoom(newRoomId, roomId)) {
-                    hideRoom.call(this, roomId);
-                }
-            });
-        }
-
-        // hides a room
-        function hideRoom(roomId) {
-            if (rooms[roomId]) {
-                const room = rooms[roomId];
-                
-                // Hide all layers
-                Object.values(room.layers).forEach(layer => {
-                    if (layer && layer.setVisible) {
-                        layer.setVisible(false);
-                        layer.setAlpha(0);
-                    }
-                });
-
-                // Hide all objects (both active and inactive)
-                if (room.objects) {
-                    Object.values(room.objects).forEach(obj => {
-                        if (obj && obj.setVisible) {
-                            obj.setVisible(false);
-                        }
-                    });
-                }
-            }
-        }
-
-        // checks if rooms are connected
-        function isConnectedRoom(currentRoomId, checkRoomId) {
-            const currentRoom = gameScenario.rooms[currentRoomId];
-            if (!currentRoom || !currentRoom.connections) return false;
-
-            // Check all connections
-            return Object.values(currentRoom.connections).some(connection => {
-                if (Array.isArray(connection)) {
-                    return connection.includes(checkRoomId);
-                }
-                return connection === checkRoomId;
-            });
-        }
-
-        // handles interactions with objects
-        // displays the object's data in an alert
-        function handleObjectInteraction(sprite) {
-            if (!sprite || !sprite.scenarioData) return;
-
-            const isInventoryItem = inventory.items.includes(sprite);
-            
-            if (!isInventoryItem) {
-                // Check if player is in range
-                const dx = player.x - sprite.x;
-                const dy = player.y - sprite.y;
-                const distanceSq = dx * dx + dy * dy;
-                
-                if (distanceSq > INTERACTION_RANGE_SQ) {
-                    alert("Too far away to interact with this object.");
-                    return;
-                }
-            }
-            
-            const data = sprite.scenarioData;
-            let message = `${data.name}\n\n`;
-            message += `Observations: ${data.observations}\n\n`;
-            
-            // Add Bluetooth-specific information for tablets
-            if (data.type === 'tablet') {
-                const isLocked = data.locked === true;
-                message += `Status: ${isLocked ? 'Locked' : 'Unlocked'}\n`;
-                if (isLocked) {
-                    message += `Lock Type: ${data.lockType}\n`;
-                    message += `Requires: Bluetooth device with MAC ${data.mac}\n`;
-                    alert(message);
-                    handleUnlock(sprite, 'item');
-                    return;
-                }
-            }
-            
-            if (data.readable && data.text) {
-                message += `Text: ${data.text}\n\n`;
-            }
-            
-            if (data.contents && !data.locked) {
-                message += `You found the following items:\n`;
-                data.contents.forEach(item => {
-                    message += `- ${item.name}\n`;
-                });
-            }
-            
-            alert(message);
-
-            // Handle takeable items
-            if (data.takeable && !isInventoryItem) {
-                // Allow pickup if either:
-                // 1. Item is not locked, or
-                // 2. Item uses Bluetooth locking (can be carried to scanner)
-                if (!data.locked || (data.locked && data.lockType === 'bluetooth')) {
-                    console.log('Taking item:', data.name);
-                    addToInventory(sprite);
-                    
-                    // Remove from room objects if it exists there
-                    if (currentRoom && rooms[currentRoom].objects) {
-                        delete rooms[currentRoom].objects[sprite.name];
-                    }
-                } else {
-                    alert("This item is locked and cannot be picked up.");
-                }
-            }
-        }
-
-        // adds an item to the inventory
-        // removes the item from the room if it exists
-        // creates a new sprite for the item in the inventory
-        function addToInventory(sprite) {
-            if (!sprite || !sprite.scenarioData) {
-                console.warn('Invalid sprite for inventory');
-                return;
-            }
-            
-            try {
-                // Remove from room if it exists
-                if (currentRoom && 
-                    rooms[currentRoom] && 
-                    rooms[currentRoom].objects && 
-                    rooms[currentRoom].objects[sprite.name]) {
-                    
-                    const roomObj = rooms[currentRoom].objects[sprite.name];
-                    roomObj.setVisible(false);
-                    roomObj.active = false;
-                }
-                
-                const scene = sprite.scene;
-                
-                // Create new sprite for inventory
-                const inventorySprite = scene.add.sprite(
-                    inventory.items.length * 60 + 100,
-                    0,
-                    sprite.name
-                );
-                
-                inventorySprite.setScale(0.8);
-                inventorySprite.setInteractive({ useHandCursor: true, pixelPerfect: true });
-                inventorySprite.scenarioData = {
-                    ...sprite.scenarioData,
-                    foundIn: currentRoom ? gameScenario.rooms[currentRoom].name || currentRoom : 'unknown location'
-                };
-                inventorySprite.name = sprite.name;
-                
-                // Set depth higher than container
-                inventorySprite.setDepth(2003);
-
-                // Add pointer events
-                inventorySprite.on('pointerdown', function(event) {
-                    event.stopPropagation();
-                    handleObjectInteraction(this);
-                });
-                
-                inventorySprite.on('pointerover', function() {
-                    this.setTint(0xdddddd);
-                });
-                
-                inventorySprite.on('pointerout', function() {
-                    this.clearTint();
-                });
-                
-                inventory.container.add(inventorySprite);
-                inventory.items.push(inventorySprite);
-                
-                console.log('Item added to inventory:', {
-                    name: sprite.name,
-                    totalItems: inventory.items.length
-                });
-            } catch (error) {
-                console.error('Error adding item to inventory:', error);
-            }
-        }
-
-        // initializes inventory
-        // creates the background and slot outlines
-        function initializeInventory() {
-            // Reset inventory state
-            inventory.items = [];
-            
-            // Create slot outlines
-            const slotsContainer = this.add.container(110, this.cameras.main.height - 60) // Shifted 100px to the right
-                .setScrollFactor(0)
-                .setDepth(2001);
-            
-            // Create 10 slot outlines
-            for (let i = 0; i < 10; i++) {
-                const outline = this.add.rectangle(
-                    i * 60, 
-                    0,
-                    50,
-                    50,
-                    0x666666,
-                    0.3
-                );
-                outline.setStrokeStyle(1, 0x666666);
-                slotsContainer.add(outline);
-            }
-            
-            // Initialize inventory container
-            inventory.container = this.add.container(10, this.cameras.main.height - 60)
-                .setScrollFactor(0)
-                .setDepth(2001);
-            
-            console.log('Inventory initialized:', inventory); // Debug log
-        }
-
-        // runs after rooms are fully set up
-        // checks if doors are overlapping rooms and removes them if they are not
-        function validateDoorsByRoomOverlap() {
-            // First, run the existing door validation
-            Object.entries(rooms).forEach(([roomId, room]) => {
-                if (!room.doorsLayer) return;
-
-                const doorTiles = room.doorsLayer.getTilesWithin().filter(tile => tile.index !== -1);
-                
-                doorTiles.forEach(doorTile => {
-                    // Calculate world coordinates for this door tile
-                    const doorWorldX = room.doorsLayer.x + (doorTile.x * TILE_SIZE);
-                    const doorWorldY = room.doorsLayer.y + (doorTile.y * TILE_SIZE);
-                    
-                    // Create a door check area that extends in all directions
-                    const doorCheckArea = {
-                        x: doorWorldX - DOOR_ALIGN_OVERLAP,
-                        y: doorWorldY - DOOR_ALIGN_OVERLAP,
-                        width: DOOR_ALIGN_OVERLAP * 2,
-                        height: DOOR_ALIGN_OVERLAP * 2
-                    };
-                    
-                    // Track overlapping rooms and their data
-                    let overlappingRoomData = [];
-                    
-                    Object.entries(rooms).forEach(([otherId, otherRoom]) => {
-                        const otherBounds = {
-                            x: otherRoom.position.x,
-                            y: otherRoom.position.y,
-                            width: otherRoom.map.widthInPixels,
-                            height: otherRoom.map.heightInPixels
-                        };
-                        
-                        // Check if the door's check area overlaps with this room
-                        if (boundsOverlap(doorCheckArea, otherBounds)) {
-                            overlappingRoomData.push({
-                                id: otherId,
-                                locked: gameScenario.rooms[otherId].locked,
-                                lockType: gameScenario.rooms[otherId].lockType,
-                                requires: gameScenario.rooms[otherId].requires
-                            });
-                            console.log(`Door at (${doorWorldX}, ${doorWorldY}) overlaps with room ${otherId}`);
-                        }
-                    });
-                    
-                    // If door doesn't overlap exactly 2 rooms, remove it
-                    if (overlappingRoomData.length < 2) {
-                        console.log(`Removing door at (${doorWorldX}, ${doorWorldY}) - overlaps ${overlappingRoomData.length} rooms`);
-                        doorTile.index = -1;  // Remove the door tile
-                        
-                        // Restore wall collision where door was removed
-                        room.wallsLayers.forEach(wallLayer => {
-                            const wallTile = wallLayer.getTileAt(doorTile.x, doorTile.y);
-                            if (wallTile) {
-                                wallTile.setCollision(true);
-                            }
-                        });
-                    } else {
-                        // Check if any of the overlapping rooms are locked
-                        const lockedRoom = overlappingRoomData.find(room => room.locked);
-                        
-                        if (lockedRoom) {
-                            // Set the door tile properties to match the locked room
-                            if (!doorTile.properties) doorTile.properties = {};
-                            doorTile.properties.locked = true;
-                            doorTile.properties.lockType = lockedRoom.lockType;
-                            doorTile.properties.requires = lockedRoom.requires;
-                            console.log(`Door at (${doorWorldX}, ${doorWorldY}) marked as locked:`, doorTile.properties);
-                            
-                            // Ensure wall collision remains for locked doors
-                            room.wallsLayers.forEach(wallLayer => {
-                                const wallTile = wallLayer.getTileAt(doorTile.x, doorTile.y);
-                                if (wallTile) {
-                                    wallTile.setCollision(true);
-                                }
-                            });
-                        } else {
-                            // Valid unlocked door - ensure no wall collision
-                            room.wallsLayers.forEach(wallLayer => {
-                                const wallTile = wallLayer.getTileAt(doorTile.x, doorTile.y);
-                                if (wallTile) {
-                                    wallTile.setCollision(false);
-                                }
-                            });
-                        }
-                    }
-                });
-            });
-        }
-
-        function pointInRoomBounds(x, y, bounds) {
-            return (x >= bounds.x && 
-                    x <= bounds.x + bounds.width && 
-                    y >= bounds.y && 
-                    y <= bounds.height);
-        }
-
-        // Add this helper function to check if two bounds overlap
-        function boundsOverlap(bounds1, bounds2) {
-            return !(bounds1.x + bounds1.width < bounds2.x || 
-                     bounds1.x > bounds2.x + bounds2.width || 
-                     bounds1.y + bounds1.height < bounds2.y || 
-                     bounds1.y > bounds2.y + bounds2.height);
-        }
-
-        // Add this new helper function:
-        function createItemIdentifier(scenarioData) {
-            // Combine multiple properties to create a unique identifier
-            const identifierParts = [
-                scenarioData.type,
-                scenarioData.name,
-                // Add more unique properties if available
-                scenarioData.key_id,         // For keys
-                scenarioData.requires,       // For locks
-                scenarioData.text           // For readable items
-            ].filter(Boolean); // Remove any undefined/null values
-            
-            return identifierParts.join('|');
-        }
-
-        // Add this new function after the other function definitions
-        function setupDoorOverlapChecks() {
-            const DOOR_INTERACTION_RANGE = 2 * TILE_SIZE;
-            
-            Object.entries(rooms).forEach(([roomId, room]) => {
-                if (!room.doorsLayer) return;
-
-                const doorTiles = room.doorsLayer.getTilesWithin().filter(tile => tile.index !== -1);
-                
-                doorTiles.forEach(doorTile => {
-                    const worldX = room.doorsLayer.x + (doorTile.x * TILE_SIZE);
-                    const worldY = room.doorsLayer.y + (doorTile.y * TILE_SIZE);
-                    
-                    const zone = this.add.zone(worldX + TILE_SIZE/2, worldY + TILE_SIZE/2, TILE_SIZE, TILE_SIZE);
-                    zone.setInteractive({ useHandCursor: true });
-                    
-                    zone.on('pointerdown', () => {
-                        console.log('Door clicked:', { doorTile, room });
-                        const distance = Phaser.Math.Distance.Between(
-                            player.x, player.y,
-                            worldX + TILE_SIZE/2, worldY + TILE_SIZE/2
-                        );
-                        
-                        if (distance <= DOOR_INTERACTION_RANGE) {
-                            if (doorTile.properties?.locked) {
-                                console.log('Door is locked, attempting unlock');
-                                colorDoorTiles(doorTile, room);
-                                handleDoorUnlock(doorTile, room);
-                            } else {
-                                console.log('Door is not locked');
-                            }
-                        } else {
-                            console.log("Too far from door to interact");
-                        }
-                    });
-
-                    this.physics.world.enable(zone);
-                    this.physics.add.overlap(player, zone, () => {
-                        colorDoorTiles(doorTile, room);
-                    }, null, this);
-                });
-            });
-        }
-
-        function colorDoorTiles(doorTile, room) {
-            // Visual feedback for door tiles
-            const doorTiles = [
-                            room.doorsLayer.getTileAt(doorTile.x, doorTile.y - 1),
-                            room.doorsLayer.getTileAt(doorTile.x, doorTile.y),
-                            room.doorsLayer.getTileAt(doorTile.x, doorTile.y + 1)
-                        ];
-                        doorTiles.forEach(tile => {
-                    if (tile) {
-                        // Use red tint for locked doors, black for unlocked
-                        const tintColor = doorTile.properties?.locked ? 0xff0000 : 0x000000;
-                        tile.tint = tintColor;
-                        tile.tintFill = true;
-                    }
-            });
-        }
-        
-        function handleDoorUnlock(doorTile, room) {
-            console.log('handleDoorUnlock called:', { doorTile, room });
-            doorTile.layer = room.doorsLayer; // Ensure layer reference is set
-            handleUnlock(doorTile, 'door');
-        }
-
-        function handleUnlock(lockable, type) {
-            console.log('handleUnlock called:', { type, lockable });
-            
-            // Check locked state in scenarioData for items
-            const isLocked = type === 'door' ? 
-                lockable.properties?.locked : 
-                lockable.scenarioData?.locked;
-            
-            if (!isLocked) {
-                console.log('Object is not locked');
-                return;
-            }
-            
-            // Get lock requirements based on type
-            const lockRequirements = type === 'door' 
-                ? getLockRequirementsForDoor(lockable)
-                : getLockRequirementsForItem(lockable);
-            
-            console.log('Lock requirements:', lockRequirements);
-            
-            if (!lockRequirements) {
-                console.log('No lock requirements found');
-                return;
-            }
-            
-            switch(lockRequirements.lockType) {
-                case 'key':
-                    const requiredKey = lockRequirements.requires;
-                    console.log('Checking for key:', requiredKey);
-                    const hasKey = inventory.items.some(item => 
-                        item && item.scenarioData && 
-                        item.scenarioData.key_id === requiredKey
-                    );
-
-                    if (hasKey) {
-                        const keyItem = inventory.items.find(item => 
-                            item && item.scenarioData && 
-                            item.scenarioData.key_id === requiredKey
-                        );
-                        const keyName = keyItem?.scenarioData?.name || 'key';
-                        const keyLocation = keyItem?.scenarioData?.foundIn || 'your inventory';
-                        
-                        unlockTarget(lockable, type, lockable.layer); // Pass the layer here
-                        alert(`You used the ${keyName} that you found in ${keyLocation} to unlock the ${type}.`);
-                    } else {
-                        alert(`Requires key: ${requiredKey}`);
-                    }
-                    break;
-
-                case 'pin':
-                    console.log('Handling PIN lock');
-                    const pinInput = prompt(`Enter PIN code:`);
-                    if (pinInput === lockRequirements.requires) {
-                        unlockTarget(lockable, type, lockable.layer); // Pass the layer here
-                        alert(`Correct PIN! The ${type} is now unlocked.`);
-                    } else if (pinInput !== null) {
-                        alert("Incorrect PIN code.");
-                    }
-                    break;
-
-                case 'password':
-                    console.log('Handling password lock');
-                    const passwordInput = prompt(`Enter password:`);
-                    if (passwordInput === lockRequirements.requires) {
-                        unlockTarget(lockable, type, lockable.layer); // Pass the layer here
-                        alert(`Correct password! The ${type} is now unlocked.`);
-                    } else if (passwordInput !== null) {
-                        alert("Incorrect password.");
-                    }
-                    break;
-
-                case 'bluetooth':
-                    const requiredMac = lockRequirements.requires;
-                    // Find the scanner in inventory
-                    const scanner = inventory.items.find(item => 
-                        item.scenarioData?.type === "bluetooth_scanner"
-                    );
-                    
-                    if (!scanner) {
-                        alert("You need a Bluetooth scanner to unlock this device.");
-                        // Don't return here - allow the item to be picked up even without scanner
-                        if (type === 'item' && lockable.scenarioData?.takeable) {
-                            addToInventory(lockable);
-                            // Remove from room objects if it exists there
-                            if (currentRoom && rooms[currentRoom].objects) {
-                                delete rooms[currentRoom].objects[lockable.name];
-                            }
-                        }
-                        return;
-                    }
-                    
-                    const devices = getBluetoothDevicesInRange({ x: scanner.x, y: scanner.y });
-                    const matchingDevice = devices.find(d => d.mac === requiredMac && d.signalStrength >= BLUETOOTH_MIN_SIGNAL);
-                    
-                    if (matchingDevice) {
-                        unlockTarget(lockable, type, lockable.layer);
-                        alert(`Bluetooth connection established with ${matchingDevice.name}. Device unlocked.`);
-                    } else {
-                        alert("No compatible Bluetooth device in range or signal too weak.");
-                    }
-                    break;
-
-                default:
-                    alert(`Requires: ${lockRequirements.requires}`);
-            }
-        }
-
-        // Generic unlock function
-        function unlockTarget(lockable, type, layer) {
-            if (type === 'door') {
-                if (!layer) {
-                    console.error('Missing layer for door unlock');
-                    return;
-                }
-                unlockDoor(lockable, layer);
-            } else {
-                // Handle item unlocking
-                if (lockable.scenarioData) {
-                    lockable.scenarioData.locked = false;
-                } else {
-                    lockable.locked = false;
-                }
-                
-                // If the item has contents, make them accessible
-                if (lockable.scenarioData?.contents) {
-                    lockable.scenarioData.contents.forEach(item => {
-                        const sprite = createInventorySprite(item);
-                        if (sprite) {
-                            addToInventory(sprite);
-                        }
-                    });
-                }
-            }
-        }
-
-        // Helper function to create inventory sprites for unlocked container contents
-        function createInventorySprite(itemData) {
-            const scene = game.scene.scenes[0]; // Get the main scene
-            if (!scene) return null;
-            
-            // Create sprite with proper texture key based on item type
-            const sprite = scene.add.sprite(0, 0, itemData.type.toLowerCase());
-            sprite.scenarioData = itemData;
-            sprite.name = itemData.type;
-            
-            // Set interactive properties
-            sprite.setInteractive({ useHandCursor: true, pixelPerfect: true });
-            sprite.on('pointerdown', function(event) {
-                event.stopPropagation();
-                handleObjectInteraction(this);
-            });
-            
-            sprite.on('pointerover', function() {
-                this.setTint(0xdddddd);
-            });
-            
-            sprite.on('pointerout', function() {
-                this.clearTint();
-            });
-            
-            return sprite;
-        }
-
-        function unlockDoor(doorTile, doorsLayer) {
-            if (!doorsLayer) {
-                console.error('Missing doorsLayer in unlockDoor');
-                return;
-            }
-
-            // Remove lock properties from this door and adjacent door tiles
-            const doorTiles = [
-                doorsLayer.getTileAt(doorTile.x, doorTile.y - 1),
-                doorsLayer.getTileAt(doorTile.x, doorTile.y),
-                doorsLayer.getTileAt(doorTile.x, doorTile.y + 1),
-                doorsLayer.getTileAt(doorTile.x - 1, doorTile.y),
-                doorsLayer.getTileAt(doorTile.x + 1, doorTile.y)
-            ].filter(tile => tile && tile.index !== -1);
-
-            doorTiles.forEach(tile => {
-                if (tile.properties) {
-                    tile.properties.locked = false;
-                }
-            });
-            
-            // Find the room that contains this doors layer
-            const room = Object.values(rooms).find(r => r.doorsLayer === doorsLayer);
-            if (!room) {
-                console.error('Could not find room for doors layer');
-                return;
-            }
-            
-            // Process each door tile's position to remove wall collisions
-            doorTiles.forEach(tile => {
-                const worldX = doorsLayer.x + (tile.x * TILE_SIZE);
-                const worldY = doorsLayer.y + (tile.y * TILE_SIZE);
-                
-                const doorCheckArea = {
-                    x: worldX - DOOR_ALIGN_OVERLAP,
-                    y: worldY - DOOR_ALIGN_OVERLAP,
-                    width: DOOR_ALIGN_OVERLAP * 2,
-                    height: DOOR_ALIGN_OVERLAP * 2
-                };
-                
-                // Remove collision for this door in ALL overlapping rooms' wall layers
-                Object.entries(rooms).forEach(([otherId, otherRoom]) => {
-                    const otherBounds = {
-                        x: otherRoom.position.x,
-                        y: otherRoom.position.y,
-                        width: otherRoom.map.widthInPixels,
-                        height: otherRoom.map.heightInPixels
-                    };
-                    
-                    if (boundsOverlap(doorCheckArea, otherBounds)) {
-                        otherRoom.wallsLayers.forEach(wallLayer => {
-                            const wallX = Math.floor((worldX - wallLayer.x) / TILE_SIZE);
-                            const wallY = Math.floor((worldY - wallLayer.y) / TILE_SIZE);
-                            
-                            const wallTile = wallLayer.getTileAt(wallX, wallY);
-                            if (wallTile) {
-                                wallTile.setCollision(false);
-                            }
-                        });
-                    }
-                });
-            });
-            
-            // Update door visuals for all affected tiles
-            doorTiles.forEach(tile => {
-                colorDoorTiles(tile, room);
-            });
-        }
-
-        function getLockRequirementsForDoor(doorTile) {
-            console.log('Getting lock requirements for door:', doorTile);
-            
-            if (!doorTile.layer) {
-                console.error('Door tile missing layer reference');
-                return null;
-            }
-
-            const doorWorldX = doorTile.layer.x + (doorTile.x * TILE_SIZE);
-            const doorWorldY = doorTile.layer.y + (doorTile.y * TILE_SIZE);
-            
-            console.log('Door world coordinates:', { doorWorldX, doorWorldY });
-            
-            const overlappingRooms = [];
-            Object.entries(rooms).forEach(([roomId, otherRoom]) => {
-                const doorCheckArea = {
-                    x: doorWorldX - DOOR_ALIGN_OVERLAP,
-                    y: doorWorldY - DOOR_ALIGN_OVERLAP,
-                    width: DOOR_ALIGN_OVERLAP * 2,
-                    height: DOOR_ALIGN_OVERLAP * 2
-                };
-                
-                const roomBounds = {
-                    x: otherRoom.position.x,
-                    y: otherRoom.position.y,
-                    width: otherRoom.map.widthInPixels,
-                    height: otherRoom.map.heightInPixels
-                };
-                
-                if (boundsOverlap(doorCheckArea, roomBounds)) {
-                    console.log(`Room ${roomId} overlaps with door`);
-                    const roomCenterX = roomBounds.x + (roomBounds.width / 2);
-                    const roomCenterY = roomBounds.y + (roomBounds.height / 2);
-                    const distanceToPlayer = Phaser.Math.Distance.Between(
-                        player.x, player.y,
-                        roomCenterX, roomCenterY
-                    );
-                    
-                    overlappingRooms.push({
-                        id: roomId,
-                        room: otherRoom,
-                        distance: distanceToPlayer,
-                        lockType: gameScenario.rooms[roomId].lockType,
-                        requires: gameScenario.rooms[roomId].requires,
-                        locked: gameScenario.rooms[roomId].locked
-                    });
-                }
-            });
-
-            console.log('Overlapping rooms:', overlappingRooms);
-            
-            const lockedRooms = overlappingRooms
-                .filter(r => r.locked)
-                .sort((a, b) => b.distance - a.distance);
-            
-            console.log('Locked rooms:', lockedRooms);
-
-            if (lockedRooms.length > 0) {
-                const targetRoom = lockedRooms[0];
-                const requirements = {
-                    lockType: targetRoom.lockType,
-                    requires: targetRoom.requires
-                };
-                console.log('Returning lock requirements:', requirements);
-                return requirements;
-            }
-            
-            console.log('No lock requirements found');
-            return null;
-        }
-
-        function getLockRequirementsForItem(item) {
-            return {
-                lockType: item.lockType || item.scenarioData?.lockType,
-                requires: item.requires || item.scenarioData?.requires
-            };
-        }
-
-        function addBluetoothScanner() {
-            // Check if scanner already exists in inventory
-            const existingScanner = inventory.items.find(item => 
-                item.scenarioData?.type === "bluetooth_scanner"
-            );
-            
-            if (existingScanner) {
-                console.log('Bluetooth scanner already exists in inventory');
-                return;
-            }
-
-            const scannerData = {
-                type: "bluetooth_scanner",
-                name: "Bluetooth Scanner",
-                observations: "A specialized tool for detecting and analyzing Bluetooth signals",
-                isScanner: true
-            };
-
-            const scannerSprite = this.add.sprite(0, 0, 'bluetooth_scanner');
-            scannerSprite.setVisible(false);
-            scannerSprite.name = "bluetooth_scanner";
-            scannerSprite.scenarioData = scannerData;
-            scannerSprite.setInteractive({ useHandCursor: true, draggable: true });
-
-            // Add custom scan function
-            scannerSprite.customInteraction = function() {
-                const devices = getBluetoothDevicesInRange({ x: this.x, y: this.y });
-                let message = "Bluetooth Scan Results:\n\n";
-                
-                if (devices.length === 0) {
-                    message += "No devices in range.";
-                } else {
-                    devices.forEach(device => {
-                        message += `Device: ${device.name}\n`;
-                        message += `MAC: ${device.mac}\n`;
-                        message += `Signal: ${Math.round(device.signalStrength)}%\n\n`;
-                    });
-                }
-                
-                alert(message);
-                return true;
-            };
-
-            // Handle dragging
-            scannerSprite.on('drag', function(pointer, dragX, dragY) {
-                this.x = dragX;
-                this.y = dragY;
-                
-                // Check for nearby Bluetooth devices while dragging
-                const devices = getBluetoothDevicesInRange({ x: this.x, y: this.y });
-                devices.forEach(device => {
-                    if (device.signalStrength >= BLUETOOTH_MIN_SIGNAL) {
-                        const matchingItem = inventory.items.find(item => 
-                            item.scenarioData?.mac === device.mac && 
-                            item.scenarioData?.locked
-                        );
-                        if (matchingItem) {
-                            handleUnlock(matchingItem, 'item');
-                        }
-                    }
-                });
-            });
-
-            addToInventory(scannerSprite);
-        }
-
-        function calculateSignalStrength(pos1, pos2) {
-            const distance = Phaser.Math.Distance.Between(
-                pos1.x, pos1.y,
-                pos2.x, pos2.y
-            );
-            console.log('Bluetooth Distance:', distance, 'Signal:', Math.max(0, 100 - (distance / BLUETOOTH_SCAN_RANGE)));
-            return Math.max(0, 100 - (distance / BLUETOOTH_SCAN_RANGE));
-        }
-
-        function getBluetoothDevicesInRange(scannerPos) {
-            console.log('Scanning for Bluetooth devices at:', scannerPos);
-            
-            // Get all items (both in inventory and in rooms)
-            const allItems = [...inventory.items];
-            Object.values(rooms).forEach(room => {
-                if (room.objects) {
-                    allItems.push(...Object.values(room.objects));
-                }
-            });
-            
-            const devices = allItems
-                .filter(item => item && item.scenarioData?.mac)
-                .map(device => {
-                    const strength = calculateSignalStrength(scannerPos, device);
-                    console.log('Found device:', device.scenarioData.name, 'MAC:', device.scenarioData.mac, 'Strength:', strength);
-                    return {
-                        name: device.scenarioData.name,
-                        mac: device.scenarioData.mac,
-                        position: { x: device.x, y: device.y },
-                        signalStrength: strength
-                    };
-                })
-                .filter(device => device.signalStrength > 0);
-            
-            console.log('Devices in range:', devices);
-            return devices;
-        }
-
-        function createObjectSprite(scene, objectData, x, y) {
-            console.log('=== Creating Object ===');
-            console.log('Type:', objectData.type);
-            console.log('Name:', objectData.name);
-            console.log('Position:', { x, y });
-            console.log('Data:', objectData);
-            
-            const sprite = scene.add.sprite(x, y, objectData.type.toLowerCase());
-            sprite.scenarioData = objectData;
-            sprite.name = objectData.type;
-            
-            if (objectData.type === 'tablet') {
-                console.log('!!! TABLET DETECTED !!!');
-                console.log('Tablet properties:', {
-                    position: { x, y },
-                    locked: objectData.locked,
-                    lockType: objectData.lockType,
-                    mac: objectData.mac,
-                    contents: objectData.contents
-                });
-            }
-
-            // Set interactive properties
-            sprite.setInteractive({ useHandCursor: true });
-            
-            // Fix the pointer event handling
-            sprite.on('pointerdown', function() {
-                handleObjectInteraction(this);
-            });
-            
-            return sprite;
-        }
-
-    </script>
-</body>
-</html> 
