From 81f35998dcff72c55e052ec1ffbedfc38366fd34 Mon Sep 17 00:00:00 2001
From: Damian-I <d.d.idzinski@gmail.com>
Date: Tue, 18 Feb 2025 15:19:02 +0000
Subject: [PATCH 1/7] Add tablet object to reception room and game scenario

- Load tablet image asset
- Add tablet object to reception room JSON
- Include tablet with locked status and contents in game scenario
- Add meeting notes and master key to tablet contents
---
 assets/rooms/room_reception.json | 12 ++++++++++++
 assets/scenarios/ceo_exfil.json  | 25 +++++++++++++++++++++++++
 index.html                       |  1 +
 3 files changed, 38 insertions(+)

diff --git a/assets/rooms/room_reception.json b/assets/rooms/room_reception.json
index 38d006c..3601459 100644
--- a/assets/rooms/room_reception.json
+++ b/assets/rooms/room_reception.json
@@ -222,6 +222,18 @@
                  "width":48,
                  "x":236.666666666667,
                  "y":168.666666666667
+                },
+                {
+                 "gid":242,
+                 "height":48,
+                 "id":11,
+                 "name":"tablet",
+                 "rotation":0,
+                 "type":"",
+                 "visible":true,
+                 "width":48,
+                 "x":384,
+                 "y":336
                 }],
          "opacity":1,
          "type":"objectgroup",
diff --git a/assets/scenarios/ceo_exfil.json b/assets/scenarios/ceo_exfil.json
index ead7d23..3f863ae 100644
--- a/assets/scenarios/ceo_exfil.json
+++ b/assets/scenarios/ceo_exfil.json
@@ -30,6 +30,31 @@
                     "takeable": false,
                     "requires": "password",
                     "observations": "The reception's computer, currently locked"
+                },
+                {
+                    "type": "tablet",
+                    "name": "Forgotten Tablet",
+                    "observations": "A tablet device left behind by someone. It seems to be locked.",
+                    "locked": true,
+                    "lockType": "pin",
+                    "requires": "1234",
+                    "contents": [
+                        {
+                            "type": "notes",
+                            "name": "Meeting Notes",
+                            "observations": "Confidential meeting notes about upcoming projects",
+                            "readable": true,
+                            "text": "Project Aurora launch scheduled for Q3. Security concerns need to be addressed.",
+                            "takeable": true
+                        },
+                        {
+                            "type": "key",
+                            "name": "Master Key",
+                            "observations": "A key with high security markings",
+                            "takeable": true,
+                            "key_id": "master_key"
+                        }
+                    ]
                 }
             ]
         },
diff --git a/index.html b/index.html
index f793cca..9dc6315 100644
--- a/index.html
+++ b/index.html
@@ -222,6 +222,7 @@
             this.load.image('safe', 'assets/objects/safe.png');
             this.load.image('book', 'assets/objects/book.png');
             this.load.image('workstation', 'assets/objects/workstation.png');
+            this.load.image('tablet', 'assets/objects/tablet.png');
 
             this.load.json('gameScenarioJSON', 'assets/scenarios/ceo_exfil.json');
             gameScenario = this.cache.json.get('gameScenarioJSON');

From 6c9db12f494867b42fb50bdbda2c40cc634d4ec6 Mon Sep 17 00:00:00 2001
From: Damian-I <d.d.idzinski@gmail.com>
Date: Tue, 18 Feb 2025 16:19:37 +0000
Subject: [PATCH 2/7] Update game assets and scenario with bluetooth scanner
 and tablet adjustments

- Add bluetooth scanner image asset
- Modify tablet object in reception room JSON
- Simplify tablet scenario contents and positioning
- Adjust tablet object properties in game scenario
---
 assets/objects/bluetooth_scanner.png | Bin 0 -> 5700 bytes
 assets/objects/tablet.png            | Bin 0 -> 6061 bytes
 assets/objects/workstation.png       | Bin 0 -> 5704 bytes
 assets/rooms/room_reception.json     |   8 ++++----
 assets/scenarios/ceo_exfil.json      |  22 +++-------------------
 index.html                           |   2 ++
 6 files changed, 9 insertions(+), 23 deletions(-)
 create mode 100644 assets/objects/bluetooth_scanner.png
 create mode 100644 assets/objects/tablet.png
 create mode 100644 assets/objects/workstation.png

diff --git a/assets/objects/bluetooth_scanner.png b/assets/objects/bluetooth_scanner.png
new file mode 100644
index 0000000000000000000000000000000000000000..cd0be1afb970a4193d0f752694b802f2f1b925ef
GIT binary patch
literal 5700
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
R-LP_3&hYf7pLO57^FM{B+5Z3l

literal 0
HcmV?d00001

diff --git a/assets/objects/tablet.png b/assets/objects/tablet.png
new file mode 100644
index 0000000000000000000000000000000000000000..2af66bc7817242c7f3bc3846f32dfcf4e888d95b
GIT binary patch
literal 6061
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
RYyRsG3sW1D3M22B{{WeZlD7Z=

literal 0
HcmV?d00001

diff --git a/assets/objects/workstation.png b/assets/objects/workstation.png
new file mode 100644
index 0000000000000000000000000000000000000000..00ab4684072a7bd430ef6c32da9b364b480e8f30
GIT binary patch
literal 5704
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
RFO@rUhP#*BDVK;X{{?$3?z8{^

literal 0
HcmV?d00001

diff --git a/assets/rooms/room_reception.json b/assets/rooms/room_reception.json
index 3601459..5874416 100644
--- a/assets/rooms/room_reception.json
+++ b/assets/rooms/room_reception.json
@@ -224,7 +224,6 @@
                  "y":168.666666666667
                 },
                 {
-                 "gid":242,
                  "height":48,
                  "id":11,
                  "name":"tablet",
@@ -232,9 +231,10 @@
                  "type":"",
                  "visible":true,
                  "width":48,
-                 "x":384,
-                 "y":336
-                }],
+                 "x":340,
+                 "y":168
+                }
+         ],
          "opacity":1,
          "type":"objectgroup",
          "visible":true,
diff --git a/assets/scenarios/ceo_exfil.json b/assets/scenarios/ceo_exfil.json
index 3f863ae..efad55b 100644
--- a/assets/scenarios/ceo_exfil.json
+++ b/assets/scenarios/ceo_exfil.json
@@ -33,28 +33,12 @@
                 },
                 {
                     "type": "tablet",
-                    "name": "Forgotten Tablet",
-                    "observations": "A tablet device left behind by someone. It seems to be locked.",
+                    "name": "Tablet Device",
+                    "takeable": true,
                     "locked": true,
                     "lockType": "pin",
                     "requires": "1234",
-                    "contents": [
-                        {
-                            "type": "notes",
-                            "name": "Meeting Notes",
-                            "observations": "Confidential meeting notes about upcoming projects",
-                            "readable": true,
-                            "text": "Project Aurora launch scheduled for Q3. Security concerns need to be addressed.",
-                            "takeable": true
-                        },
-                        {
-                            "type": "key",
-                            "name": "Master Key",
-                            "observations": "A key with high security markings",
-                            "takeable": true,
-                            "key_id": "master_key"
-                        }
-                    ]
+                    "observations": "A locked tablet device"
                 }
             ]
         },
diff --git a/index.html b/index.html
index 9dc6315..b842023 100644
--- a/index.html
+++ b/index.html
@@ -222,8 +222,10 @@
             this.load.image('safe', 'assets/objects/safe.png');
             this.load.image('book', 'assets/objects/book.png');
             this.load.image('workstation', 'assets/objects/workstation.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');
         }

From 5ae7000adb1e592c9e36f7cb389e4e7fbed1ce18 Mon Sep 17 00:00:00 2001
From: Damian-I <d.d.idzinski@gmail.com>
Date: Tue, 18 Feb 2025 16:20:48 +0000
Subject: [PATCH 3/7] Add bluetooth scanner to reception room and game scenario

- Add bluetooth scanner object to reception room JSON
- Include bluetooth scanner in game scenario with description
- Position bluetooth scanner near other interactive objects
---
 assets/rooms/room_reception.json | 11 +++++++++++
 assets/scenarios/ceo_exfil.json  |  6 ++++++
 2 files changed, 17 insertions(+)

diff --git a/assets/rooms/room_reception.json b/assets/rooms/room_reception.json
index 5874416..018fc41 100644
--- a/assets/rooms/room_reception.json
+++ b/assets/rooms/room_reception.json
@@ -233,6 +233,17 @@
                  "width":48,
                  "x":340,
                  "y":168
+                },
+                {
+                 "height":48,
+                 "id":12,
+                 "name":"bluetooth_scanner",
+                 "rotation":0,
+                 "type":"",
+                 "visible":true,
+                 "width":48,
+                 "x":380,
+                 "y":166
                 }
          ],
          "opacity":1,
diff --git a/assets/scenarios/ceo_exfil.json b/assets/scenarios/ceo_exfil.json
index efad55b..4134eb0 100644
--- a/assets/scenarios/ceo_exfil.json
+++ b/assets/scenarios/ceo_exfil.json
@@ -39,6 +39,12 @@
                     "lockType": "pin",
                     "requires": "1234",
                     "observations": "A locked tablet device"
+                },
+                {
+                    "type": "bluetooth_scanner",
+                    "name": "Bluetooth Scanner",
+                    "takeable": true,
+                    "observations": "A device for detecting nearby Bluetooth signals"
                 }
             ]
         },

From 791230c72cbc6bd82070d7e9da3423da26f76307 Mon Sep 17 00:00:00 2001
From: Damian-I <d.d.idzinski@gmail.com>
Date: Tue, 18 Feb 2025 16:29:37 +0000
Subject: [PATCH 4/7] Added the same MAC address to the scanner as the tablet

---
 assets/scenarios/ceo_exfil.json | 11 ++++---
 index.html                      | 52 ++++++++++++++++++---------------
 2 files changed, 35 insertions(+), 28 deletions(-)

diff --git a/assets/scenarios/ceo_exfil.json b/assets/scenarios/ceo_exfil.json
index 4134eb0..1282d4e 100644
--- a/assets/scenarios/ceo_exfil.json
+++ b/assets/scenarios/ceo_exfil.json
@@ -36,15 +36,18 @@
                     "name": "Tablet Device",
                     "takeable": true,
                     "locked": true,
-                    "lockType": "pin",
-                    "requires": "1234",
-                    "observations": "A locked tablet device"
+                    "lockType": "bluetooth",
+                    "requires": "00:11:22:33:44:55",
+                    "mac": "00:11:22:33:44:55",
+                    "observations": "A locked tablet device that requires Bluetooth pairing"
                 },
                 {
                     "type": "bluetooth_scanner",
                     "name": "Bluetooth Scanner",
                     "takeable": true,
-                    "observations": "A device for detecting nearby Bluetooth signals"
+                    "observations": "A device for detecting nearby Bluetooth signals",
+                    "canScanBluetooth": true,
+                    "mac": "00:11:22:33:44:55"
                 }
             ]
         },
diff --git a/index.html b/index.html
index b842023..2231b21 100644
--- a/index.html
+++ b/index.html
@@ -222,9 +222,8 @@
             this.load.image('safe', 'assets/objects/safe.png');
             this.load.image('book', 'assets/objects/book.png');
             this.load.image('workstation', 'assets/objects/workstation.png');
-            this.load.image('bluetooth_scanner', 'assets/objects/bluetooth_scanner.png');
             this.load.image('tablet', 'assets/objects/tablet.png');
-
+            this.load.image('bluetooth_scanner', 'assets/objects/bluetooth_scanner.png');
 
             this.load.json('gameScenarioJSON', 'assets/scenarios/ceo_exfil.json');
             gameScenario = this.cache.json.get('gameScenarioJSON');
@@ -1406,10 +1405,22 @@
             }
             
             const data = sprite.scenarioData;
+            let message = `${data.name}\n\n`;
+            message += `Observations: ${data.observations}\n\n`;
             
-            // Check if this is an unlocked container that hasn't been collected yet
-            if (data.isUnlockedButNotCollected && data.contents) {
-                let message = `You found the following items:\n`;
+            // Check for locked state in scenarioData
+            if (data.locked === true) {
+                console.log('Item is locked:', data);
+                handleUnlock(sprite, 'item');
+                return;
+            }
+            
+            if (data.readable && data.text) {
+                message += `Text: ${data.text}\n\n`;
+            }
+            
+            if (data.contents && data.contents.length > 0) {
+                message += `You found the following items:\n`;
                 data.contents.forEach(item => {
                     message += `- ${item.name}\n`;
                 });
@@ -1425,27 +1436,12 @@
                         addToInventory(contentSprite);
                     }
                 });
-                
+            
                 // Clear contents after adding to inventory
                 data.contents = [];
-                data.isUnlockedButNotCollected = false;
                 return;
             }
             
-            // Check for locked state in scenarioData
-            if (data.locked === true) {
-                console.log('Item is locked:', data);
-                handleUnlock(sprite, 'item');
-                return;
-            }
-            
-            let message = `${data.name}\n\n`;
-            message += `Observations: ${data.observations}\n\n`;
-            
-            if (data.readable && data.text) {
-                message += `Text: ${data.text}\n\n`;
-            }
-            
             if (data.takeable) {
                 message += `This item can be taken\n\n`;
                 
@@ -1842,7 +1838,7 @@
             }
         }
 
-        // Modify the unlockTarget function
+        // Generic unlock function
         function unlockTarget(lockable, type, layer) {
             if (type === 'door') {
                 if (!layer) {
@@ -1857,15 +1853,23 @@
                     // Set new state for containers with contents
                     if (lockable.scenarioData.contents) {
                         lockable.scenarioData.isUnlockedButNotCollected = true;
-                        return; // Return early to prevent automatic collection
                     }
                 } else {
                     lockable.locked = false;
                     if (lockable.contents) {
                         lockable.isUnlockedButNotCollected = true;
-                        return; // Return early to prevent automatic collection
                     }
                 }
+                
+                // 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);
+                        }
+                    });
+                }
             }
         }
 

From a94b8fe40ca05aac20364e4e1ed57b66b890ce9f Mon Sep 17 00:00:00 2001
From: Damian-I <d.d.idzinski@gmail.com>
Date: Tue, 18 Feb 2025 16:47:27 +0000
Subject: [PATCH 5/7] Added unlocking funcitonality when scanner is in the
 inventory

---
 assets/scenarios/ceo_exfil.json |    1 -
 index.html                      |  100 +-
 indexbt.html                    | 2080 +++++++++++++++++++++++++++++++
 3 files changed, 2152 insertions(+), 29 deletions(-)
 create mode 100644 indexbt.html

diff --git a/assets/scenarios/ceo_exfil.json b/assets/scenarios/ceo_exfil.json
index 1282d4e..701d051 100644
--- a/assets/scenarios/ceo_exfil.json
+++ b/assets/scenarios/ceo_exfil.json
@@ -37,7 +37,6 @@
                     "takeable": true,
                     "locked": true,
                     "lockType": "bluetooth",
-                    "requires": "00:11:22:33:44:55",
                     "mac": "00:11:22:33:44:55",
                     "observations": "A locked tablet device that requires Bluetooth pairing"
                 },
diff --git a/index.html b/index.html
index 2231b21..77d5cae 100644
--- a/index.html
+++ b/index.html
@@ -222,8 +222,9 @@
             this.load.image('safe', 'assets/objects/safe.png');
             this.load.image('book', 'assets/objects/book.png');
             this.load.image('workstation', 'assets/objects/workstation.png');
-            this.load.image('tablet', 'assets/objects/tablet.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');
@@ -1405,22 +1406,10 @@
             }
             
             const data = sprite.scenarioData;
-            let message = `${data.name}\n\n`;
-            message += `Observations: ${data.observations}\n\n`;
             
-            // Check for locked state in scenarioData
-            if (data.locked === true) {
-                console.log('Item is locked:', data);
-                handleUnlock(sprite, 'item');
-                return;
-            }
-            
-            if (data.readable && data.text) {
-                message += `Text: ${data.text}\n\n`;
-            }
-            
-            if (data.contents && data.contents.length > 0) {
-                message += `You found the following items:\n`;
+            // Check if this is an unlocked container that hasn't been collected yet
+            if (data.isUnlockedButNotCollected && data.contents) {
+                let message = `You found the following items:\n`;
                 data.contents.forEach(item => {
                     message += `- ${item.name}\n`;
                 });
@@ -1436,12 +1425,27 @@
                         addToInventory(contentSprite);
                     }
                 });
-            
+                
                 // Clear contents after adding to inventory
                 data.contents = [];
+                data.isUnlockedButNotCollected = false;
                 return;
             }
             
+            // Check for locked state in scenarioData
+            if (data.locked === true) {
+                console.log('Item is locked:', data);
+                handleUnlock(sprite, 'item');
+                return;
+            }
+            
+            let message = `${data.name}\n\n`;
+            message += `Observations: ${data.observations}\n\n`;
+            
+            if (data.readable && data.text) {
+                message += `Text: ${data.text}\n\n`;
+            }
+            
             if (data.takeable) {
                 message += `This item can be taken\n\n`;
                 
@@ -1833,12 +1837,60 @@
                     }
                     break;
 
+                case 'bluetooth':
+                    const requiredMac = lockRequirements.requires;
+                    // Find the scanner in inventory
+                    const scanner = inventory.items.find(item => 
+                        item.scenarioData?.type === "bluetooth_scanner"
+                    );
+                    
+                    console.log('Bluetooth unlock attempt:', {
+                        itemName: lockable.scenarioData?.name,
+                        itemMac: lockable.scenarioData?.mac,
+                        hasScanner: !!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;
+                    }
+                    
+                    // If scanner is in inventory, automatically unlock the device
+                    if (inventory.items.includes(scanner)) {
+                        console.log('Bluetooth unlock success: Scanner in inventory', {
+                            itemName: lockable.scenarioData?.name,
+                            itemMac: lockable.scenarioData?.mac
+                        });
+                        unlockTarget(lockable, type, lockable.layer);
+                        alert(`Using Bluetooth scanner from inventory to unlock device.`);
+                        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
+        // Modify the unlockTarget function
         function unlockTarget(lockable, type, layer) {
             if (type === 'door') {
                 if (!layer) {
@@ -1853,23 +1905,15 @@
                     // Set new state for containers with contents
                     if (lockable.scenarioData.contents) {
                         lockable.scenarioData.isUnlockedButNotCollected = true;
+                        return; // Return early to prevent automatic collection
                     }
                 } else {
                     lockable.locked = false;
                     if (lockable.contents) {
                         lockable.isUnlockedButNotCollected = true;
+                        return; // Return early to prevent automatic collection
                     }
                 }
-                
-                // 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);
-                        }
-                    });
-                }
             }
         }
 
diff --git a/indexbt.html b/indexbt.html
new file mode 100644
index 0000000..b420d81
--- /dev/null
+++ b/indexbt.html
@@ -0,0 +1,2080 @@
+<!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;
+                    }
+                    
+                    // If scanner is in inventory, automatically unlock the device
+                    if (inventory.items.includes(scanner)) {
+                        unlockTarget(lockable, type, lockable.layer);
+                        alert(`Using Bluetooth scanner from inventory to unlock device.`);
+                        return;
+                    }
+                    
+                    // Otherwise check signal strength based on position
+                    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> 

From 1889b1b1d91304221bb126d093ffd3a768323d99 Mon Sep 17 00:00:00 2001
From: Damian-I <d.d.idzinski@gmail.com>
Date: Tue, 18 Feb 2025 17:01:17 +0000
Subject: [PATCH 6/7] Implement Bluetooth device scanning and proximity-based
 unlocking

- Add Bluetooth scanning constants and interval-based scanning
- Modify object interaction to check for Bluetooth device proximity
- Implement proximity-based unlocking for tablets
- Add debug logging for Bluetooth scanning and device detection
- Adjust tablet and scanner positioning in reception room

----
Fixed broken funcitons of previous bluetooth
---
 assets/rooms/room_reception.json |  4 +-
 index.html                       | 87 ++++++++++++++++++++++----------
 indexbt.html                     |  8 ---
 3 files changed, 62 insertions(+), 37 deletions(-)

diff --git a/assets/rooms/room_reception.json b/assets/rooms/room_reception.json
index 018fc41..eb88f44 100644
--- a/assets/rooms/room_reception.json
+++ b/assets/rooms/room_reception.json
@@ -231,8 +231,8 @@
                  "type":"",
                  "visible":true,
                  "width":48,
-                 "x":340,
-                 "y":168
+                 "x":430,
+                 "y":380
                 },
                 {
                  "height":48,
diff --git a/index.html b/index.html
index 77d5cae..290608d 100644
--- a/index.html
+++ b/index.html
@@ -190,6 +190,10 @@
         const INTERACTION_RANGE = 2 * TILE_SIZE;
         const INTERACTION_RANGE_SQ = INTERACTION_RANGE * INTERACTION_RANGE;
 
+        // Bluetooth constants
+        const BLUETOOTH_SCAN_RANGE = TILE_SIZE * 2; // 2 tiles range for Bluetooth scanning
+        let lastBluetoothScan = 0; // Track last scan time
+        const BLUETOOTH_SCAN_INTERVAL = 500; // Scan every 500ms
 
         // preloads the assets
         function preload() {
@@ -461,6 +465,13 @@
             // checks for room transitions
             checkRoomTransitions.call(this);
             
+            // Check for Bluetooth devices
+            const currentTime = this.time.now;
+            if (currentTime - lastBluetoothScan >= BLUETOOTH_SCAN_INTERVAL) {
+                checkBluetoothDevices.call(this);
+                lastBluetoothScan = currentTime;
+            }
+            
             // 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);
@@ -1838,19 +1849,7 @@
                     break;
 
                 case 'bluetooth':
-                    const requiredMac = lockRequirements.requires;
-                    // Find the scanner in inventory
-                    const scanner = inventory.items.find(item => 
-                        item.scenarioData?.type === "bluetooth_scanner"
-                    );
-                    
-                    console.log('Bluetooth unlock attempt:', {
-                        itemName: lockable.scenarioData?.name,
-                        itemMac: lockable.scenarioData?.mac,
-                        hasScanner: !!scanner
-                    });
-                    
-                    if (!scanner) {
+                    if (lockable.scenarioData?.locked) {
                         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) {
@@ -1863,26 +1862,27 @@
                         return;
                     }
                     
-                    // If scanner is in inventory, automatically unlock the device
-                    if (inventory.items.includes(scanner)) {
-                        console.log('Bluetooth unlock success: Scanner in inventory', {
+                    // Calculate distance between player and tablet
+                    const distance = Phaser.Math.Distance.Between(
+                        player.x, player.y,
+                        lockable.x, lockable.y
+                    );
+                    
+                    console.log('Distance to tablet:', distance);
+                    
+                    // Check if player is within range (using BLUETOOTH_SCAN_RANGE)
+                    if (distance <= BLUETOOTH_SCAN_RANGE) {
+                        console.log('Bluetooth unlock success: Player in range', {
                             itemName: lockable.scenarioData?.name,
-                            itemMac: lockable.scenarioData?.mac
+                            itemMac: lockable.scenarioData?.mac,
+                            distance: distance
                         });
                         unlockTarget(lockable, type, lockable.layer);
-                        alert(`Using Bluetooth scanner from inventory to unlock device.`);
+                        alert(`Bluetooth connection established. Device unlocked.`);
                         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.");
-                    }
+                    alert("Too far from device to establish Bluetooth connection.");
                     break;
 
                 default:
@@ -2110,6 +2110,39 @@
             alert('You collected the items from the container.');
         }
 
+        function checkBluetoothDevices() {
+            // Find scanner in inventory
+            const scanner = inventory.items.find(item => 
+                item.scenarioData?.type === "bluetooth_scanner"
+            );
+            
+            if (!scanner) return;
+            
+            // Find all tablets in the current room
+            if (!currentRoom || !rooms[currentRoom] || !rooms[currentRoom].objects) return;
+            
+            Object.values(rooms[currentRoom].objects).forEach(obj => {
+                if (obj.scenarioData?.type === "tablet" && obj.scenarioData?.locked) {
+                    const distance = Phaser.Math.Distance.Between(
+                        player.x, player.y,
+                        obj.x, obj.y
+                    );
+                    
+                    if (distance <= BLUETOOTH_SCAN_RANGE) {
+                        console.log('🔍 TABLET IN RANGE:', {
+                            distance: Math.round(distance),
+                            range: BLUETOOTH_SCAN_RANGE
+                        });
+                        
+                        // Unlock the tablet
+                        obj.scenarioData.locked = false;
+                        console.log('🔓 TABLET UNLOCKED!');
+                        alert('Bluetooth connection established. Device unlocked.');
+                    }
+                }
+            });
+        }
+
     </script>
 </body>
 </html> 
\ No newline at end of file
diff --git a/indexbt.html b/indexbt.html
index b420d81..50c3784 100644
--- a/indexbt.html
+++ b/indexbt.html
@@ -1711,14 +1711,6 @@
                         return;
                     }
                     
-                    // If scanner is in inventory, automatically unlock the device
-                    if (inventory.items.includes(scanner)) {
-                        unlockTarget(lockable, type, lockable.layer);
-                        alert(`Using Bluetooth scanner from inventory to unlock device.`);
-                        return;
-                    }
-                    
-                    // Otherwise check signal strength based on position
                     const devices = getBluetoothDevicesInRange({ x: scanner.x, y: scanner.y });
                     const matchingDevice = devices.find(d => d.mac === requiredMac && d.signalStrength >= BLUETOOTH_MIN_SIGNAL);
                     

From 168e729bd4b677e75809dcaba930235aefa1c65c Mon Sep 17 00:00:00 2001
From: Damian Idzinski <45018439+Damian-I@users.noreply.github.com>
Date: Tue, 18 Feb 2025 17:11:12 +0000
Subject: [PATCH 7/7] Delete indexbt.html

---
 indexbt.html | 2072 --------------------------------------------------
 1 file changed, 2072 deletions(-)
 delete mode 100644 indexbt.html

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>