diff --git a/assets/rooms/room_office.json b/assets/rooms/room_office.json
index f94e3ec..b79f272 100644
--- a/assets/rooms/room_office.json
+++ b/assets/rooms/room_office.json
@@ -338,6 +338,17 @@
                  "width": 48,
                  "x": 340,
                  "y": 144
+                },
+                {
+                 "height": 48,
+                 "id": 17,
+                 "name": "lockpick",
+                 "rotation": 0,
+                 "type": "",
+                 "visible": true,
+                 "width": 48,
+                 "x": 330,
+                 "y": 144
                 }
 
                 
@@ -349,7 +360,7 @@
          "y":0
         }],
  "nextlayerid":12,
- "nextobjectid":16,
+ "nextobjectid":18,
  "orientation":"orthogonal",
  "renderorder":"right-down",
  "tiledversion":"1.11.0",
diff --git a/assets/rooms/room_reception.json b/assets/rooms/room_reception.json
index eb88f44..265cd2b 100644
--- a/assets/rooms/room_reception.json
+++ b/assets/rooms/room_reception.json
@@ -244,6 +244,17 @@
                  "width":48,
                  "x":380,
                  "y":166
+                },
+                {
+                 "height":48,
+                 "id":13,
+                 "name":"bluetooth_spoofer",
+                 "rotation":0,
+                 "type":"",
+                 "visible":true,
+                 "width":48,
+                 "x":320,
+                 "y":166
                 }
          ],
          "opacity":1,
@@ -253,7 +264,7 @@
          "y":0
         }],
  "nextlayerid":12,
- "nextobjectid":11,
+ "nextobjectid":14,
  "orientation":"orthogonal",
  "renderorder":"right-down",
  "tiledversion":"1.11.0",
diff --git a/assets/scenarios/ceo_exfil.json b/assets/scenarios/ceo_exfil.json
index d91af48..2a77d16 100644
--- a/assets/scenarios/ceo_exfil.json
+++ b/assets/scenarios/ceo_exfil.json
@@ -45,7 +45,14 @@
                     "name": "Bluetooth Scanner",
                     "takeable": true,
                     "observations": "A device for detecting nearby Bluetooth signals",
-                    "canScanBluetooth": true,
+                    "canScanBluetooth": true
+                },
+                {
+                    "type": "bluetooth_spoofer",
+                    "name": "Bluetooth Spoofer",
+                    "takeable": true,
+                    "observations": "A specialized device that can mimic Bluetooth signals from other devices",
+                    "canSpoofBluetooth": true,
                     "mac": "00:11:22:33:44:55"
                 }
             ]
@@ -141,6 +148,12 @@
                     "readable": true,
                     "text": "Large data transfers detected to unknown external IPs - All originating from CEO's office",
                     "observations": "Suspicious network activity logs"
+                },
+                {
+                    "type": "lockpick",
+                    "name": "Lock Pick Kit",
+                    "takeable": true,
+                    "observations": "A professional lock picking kit with various picks and tension wrenches"
                 }
             ]
         },
@@ -153,6 +166,7 @@
             "locked": true,
             "lockType": "key",
             "requires": "ceo_office_key",
+            "difficulty": "easy",
             "objects": [
                 {
                     "type": "pc",
@@ -167,6 +181,7 @@
                     "locked": true,
                     "lockType": "key",
                     "requires": "briefcase_key",
+                    "difficulty": "medium",
                     "observations": "An expensive leather briefcase with a sturdy lock",
                     "contents": [
                         {
@@ -212,6 +227,7 @@
                     "locked": true,
                     "lockType": "key",
                     "requires": "safe_key",
+                    "difficulty": "hard",
                     "observations": "A well-hidden wall safe behind a painting",
                     "contents": [
                         {
diff --git a/assets/sounds/lockpick_binding.mp3 b/assets/sounds/lockpick_binding.mp3
new file mode 100644
index 0000000..bdf479b
Binary files /dev/null and b/assets/sounds/lockpick_binding.mp3 differ
diff --git a/assets/sounds/lockpick_click.mp3 b/assets/sounds/lockpick_click.mp3
new file mode 100644
index 0000000..bdf479b
Binary files /dev/null and b/assets/sounds/lockpick_click.mp3 differ
diff --git a/assets/sounds/lockpick_overtension.mp3 b/assets/sounds/lockpick_overtension.mp3
new file mode 100644
index 0000000..bdf479b
Binary files /dev/null and b/assets/sounds/lockpick_overtension.mp3 differ
diff --git a/assets/sounds/lockpick_reset.mp3 b/assets/sounds/lockpick_reset.mp3
new file mode 100644
index 0000000..bdf479b
Binary files /dev/null and b/assets/sounds/lockpick_reset.mp3 differ
diff --git a/assets/sounds/lockpick_set.mp3 b/assets/sounds/lockpick_set.mp3
new file mode 100644
index 0000000..bdf479b
Binary files /dev/null and b/assets/sounds/lockpick_set.mp3 differ
diff --git a/assets/sounds/lockpick_success.mp3 b/assets/sounds/lockpick_success.mp3
new file mode 100644
index 0000000..bdf479b
Binary files /dev/null and b/assets/sounds/lockpick_success.mp3 differ
diff --git a/assets/sounds/lockpick_tension.mp3 b/assets/sounds/lockpick_tension.mp3
new file mode 100644
index 0000000..bdf479b
Binary files /dev/null and b/assets/sounds/lockpick_tension.mp3 differ
diff --git a/assets/sounds/lockpick_wrong.mp3 b/assets/sounds/lockpick_wrong.mp3
new file mode 100644
index 0000000..bdf479b
Binary files /dev/null and b/assets/sounds/lockpick_wrong.mp3 differ
diff --git a/index.html b/index.html
index 606f074..252a6d8 100644
--- a/index.html
+++ b/index.html
@@ -27,6 +27,284 @@
             display: none;
         }
 
+        /* Notification System */
+        #notification-container {
+            position: fixed;
+            top: 20px;
+            right: 20px;
+            width: 300px;
+            max-width: 80%;
+            z-index: 2000;
+            font-family: Arial, sans-serif;
+            pointer-events: none;
+        }
+
+        .notification {
+            background-color: rgba(0, 0, 0, 0.8);
+            color: white;
+            padding: 15px 20px;
+            margin-bottom: 10px;
+            border-radius: 5px;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.3);
+            transition: all 0.3s ease;
+            opacity: 0;
+            transform: translateY(-20px);
+            pointer-events: auto;
+            position: relative;
+            overflow: hidden;
+        }
+
+        .notification.show {
+            opacity: 1;
+            transform: translateY(0);
+        }
+
+        .notification.info {
+            border-left: 4px solid #3498db;
+        }
+
+        .notification.success {
+            border-left: 4px solid #2ecc71;
+        }
+
+        .notification.warning {
+            border-left: 4px solid #f39c12;
+        }
+
+        .notification.error {
+            border-left: 4px solid #e74c3c;
+        }
+
+        .notification-title {
+            font-weight: bold;
+            margin-bottom: 5px;
+            font-size: 16px;
+        }
+
+        .notification-message {
+            font-size: 14px;
+            line-height: 1.4;
+        }
+
+        .notification-close {
+            position: absolute;
+            top: 10px;
+            right: 10px;
+            cursor: pointer;
+            font-size: 16px;
+            color: #aaa;
+        }
+
+        .notification-close:hover {
+            color: white;
+        }
+
+        .notification-progress {
+            position: absolute;
+            bottom: 0;
+            left: 0;
+            height: 3px;
+            background-color: rgba(255, 255, 255, 0.5);
+            width: 100%;
+        }
+
+        /* Notes Panel */
+        #notes-panel {
+            position: fixed;
+            bottom: 80px;
+            right: 20px;
+            width: 350px;
+            max-height: 500px;
+            background-color: rgba(0, 0, 0, 0.9);
+            color: white;
+            border-radius: 5px;
+            box-shadow: 0 2px 15px rgba(0, 0, 0, 0.5);
+            z-index: 1999;
+            font-family: Arial, sans-serif;
+            display: none;
+            overflow: hidden;
+            transition: all 0.3s ease;
+            border: 1px solid #444;
+        }
+
+        #notes-header {
+            background-color: #222;
+            padding: 12px 15px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            border-bottom: 1px solid #444;
+        }
+
+        #notes-title {
+            font-weight: bold;
+            font-size: 18px;
+            color: #3498db;
+        }
+
+        #notes-close {
+            cursor: pointer;
+            font-size: 18px;
+            color: #aaa;
+            transition: color 0.2s;
+        }
+
+        #notes-close:hover {
+            color: white;
+        }
+        
+        #notes-search-container {
+            padding: 10px 15px;
+            background-color: #333;
+            border-bottom: 1px solid #444;
+        }
+        
+        #notes-search {
+            width: 100%;
+            padding: 8px 10px;
+            border: none;
+            border-radius: 3px;
+            background-color: #222;
+            color: white;
+            font-size: 14px;
+        }
+        
+        #notes-search:focus {
+            outline: none;
+            box-shadow: 0 0 0 2px rgba(52, 152, 219, 0.5);
+        }
+        
+        #notes-categories {
+            display: flex;
+            padding: 5px 15px;
+            background-color: #2c2c2c;
+            border-bottom: 1px solid #444;
+        }
+        
+        .notes-category {
+            padding: 5px 10px;
+            margin-right: 5px;
+            cursor: pointer;
+            border-radius: 3px;
+            font-size: 12px;
+            transition: all 0.2s;
+        }
+        
+        .notes-category.active {
+            background-color: #3498db;
+            color: white;
+        }
+        
+        .notes-category:hover:not(.active) {
+            background-color: #444;
+        }
+
+        #notes-content {
+            padding: 15px;
+            overflow-y: auto;
+            max-height: 350px;
+        }
+
+        .note-item {
+            margin-bottom: 15px;
+            padding-bottom: 15px;
+            border-bottom: 1px solid #444;
+            cursor: pointer;
+            transition: background-color 0.2s;
+            padding: 10px;
+            border-radius: 3px;
+        }
+
+        .note-item:hover {
+            background-color: #333;
+        }
+
+        .note-item:last-child {
+            margin-bottom: 0;
+            padding-bottom: 0;
+            border-bottom: none;
+        }
+
+        .note-title {
+            font-weight: bold;
+            margin-bottom: 5px;
+            font-size: 14px;
+            color: #3498db;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        .note-icons {
+            display: flex;
+            gap: 5px;
+        }
+        
+        .note-icon {
+            font-size: 12px;
+            color: #aaa;
+        }
+
+        .note-text {
+            font-size: 13px;
+            line-height: 1.4;
+            white-space: pre-wrap;
+            max-height: 80px;
+            overflow: hidden;
+            transition: max-height 0.3s;
+        }
+        
+        .note-item.expanded .note-text {
+            max-height: 1000px;
+        }
+        
+        .note-timestamp {
+            font-size: 11px;
+            color: #888;
+            margin-top: 5px;
+            text-align: right;
+        }
+
+        #notes-toggle {
+            position: fixed;
+            bottom: 20px;
+            right: 20px;
+            width: 60px;
+            height: 60px;
+            background-color: #3498db;
+            color: white;
+            border-radius: 50%;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            cursor: pointer;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.3);
+            z-index: 1998;
+            font-size: 28px;
+            transition: all 0.3s ease;
+        }
+
+        #notes-toggle:hover {
+            background-color: #2980b9;
+            transform: scale(1.1);
+        }
+
+        #notes-count {
+            position: absolute;
+            top: -5px;
+            right: -5px;
+            background-color: #e74c3c;
+            color: white;
+            border-radius: 50%;
+            width: 24px;
+            height: 24px;
+            font-size: 14px;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            font-weight: bold;
+        }
+
         #laptop-popup {
             display: none;
             position: fixed;
@@ -112,6 +390,297 @@
             background: rgba(0, 0, 0, 0.5);
             z-index: 999;
         }
+
+        /* Bluetooth Scanner Panel */
+        #bluetooth-panel {
+            position: fixed;
+            bottom: 80px;
+            right: 90px;
+            width: 350px;
+            max-height: 500px;
+            background-color: rgba(0, 0, 0, 0.9);
+            color: white;
+            border-radius: 5px;
+            box-shadow: 0 2px 15px rgba(0, 0, 0, 0.5);
+            z-index: 1999;
+            font-family: Arial, sans-serif;
+            display: none;
+            overflow: hidden;
+            transition: all 0.3s ease;
+            border: 1px solid #444;
+        }
+
+        #bluetooth-header {
+            background-color: #222;
+            padding: 12px 15px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            border-bottom: 1px solid #444;
+        }
+
+        #bluetooth-title {
+            font-weight: bold;
+            font-size: 18px;
+            color: #9b59b6;
+        }
+
+        #bluetooth-close {
+            cursor: pointer;
+            font-size: 18px;
+            color: #aaa;
+            transition: color 0.2s;
+        }
+
+        #bluetooth-close:hover {
+            color: white;
+        }
+        
+        #bluetooth-search-container {
+            padding: 10px 15px;
+            background-color: #333;
+            border-bottom: 1px solid #444;
+        }
+        
+        #bluetooth-search {
+            width: 100%;
+            padding: 8px 10px;
+            border: none;
+            border-radius: 3px;
+            background-color: #222;
+            color: white;
+            font-size: 14px;
+        }
+        
+        #bluetooth-search:focus {
+            outline: none;
+            box-shadow: 0 0 0 2px rgba(155, 89, 182, 0.5);
+        }
+        
+        #bluetooth-categories {
+            display: flex;
+            padding: 5px 15px;
+            background-color: #2c2c2c;
+            border-bottom: 1px solid #444;
+        }
+        
+        .bluetooth-category {
+            padding: 5px 10px;
+            margin-right: 5px;
+            cursor: pointer;
+            border-radius: 3px;
+            font-size: 12px;
+            transition: all 0.2s;
+        }
+        
+        .bluetooth-category.active {
+            background-color: #9b59b6;
+            color: white;
+        }
+        
+        .bluetooth-category:hover:not(.active) {
+            background-color: #444;
+        }
+
+        #bluetooth-content {
+            padding: 15px;
+            overflow-y: auto;
+            max-height: 350px;
+        }
+
+        .bluetooth-device {
+            margin-bottom: 15px;
+            padding-bottom: 15px;
+            border-bottom: 1px solid #444;
+            cursor: pointer;
+            transition: background-color 0.2s;
+            padding: 10px;
+            border-radius: 3px;
+        }
+
+        .bluetooth-device:hover {
+            background-color: #333;
+        }
+
+        .bluetooth-device:last-child {
+            margin-bottom: 0;
+            padding-bottom: 0;
+            border-bottom: none;
+        }
+
+        .bluetooth-device-name {
+            font-weight: bold;
+            margin-bottom: 5px;
+            font-size: 14px;
+            color: #9b59b6;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        
+        .bluetooth-device-icons {
+            display: flex;
+            gap: 5px;
+        }
+        
+        .bluetooth-device-icon {
+            font-size: 12px;
+            color: #aaa;
+        }
+
+        .bluetooth-device-details {
+            font-size: 13px;
+            line-height: 1.4;
+            white-space: pre-wrap;
+            max-height: 80px;
+            overflow: hidden;
+            transition: max-height 0.3s;
+        }
+        
+        .bluetooth-device.expanded .bluetooth-device-details {
+            max-height: 1000px;
+        }
+        
+        .bluetooth-device-timestamp {
+            font-size: 11px;
+            color: #888;
+            margin-top: 5px;
+            text-align: right;
+        }
+        
+        /* Bluetooth Signal Strength Bar */
+        .bluetooth-signal-bar-container {
+            margin: 0;
+            display: flex;
+            align-items: flex-end;
+            height: 16px;
+        }
+
+        .bluetooth-signal-bars {
+            display: flex;
+            align-items: flex-end;
+            height: 16px;
+            gap: 1px;
+        }
+
+        .bluetooth-signal-bar {
+            width: 3px;
+            background-color: #444;
+            border-radius: 1px;
+            transition: background-color 0.3s ease;
+        }
+
+        .bluetooth-signal-bar.active {
+            background-color: currentColor;
+        }
+
+        .bluetooth-signal-bar:nth-child(1) { height: 3px; }
+        .bluetooth-signal-bar:nth-child(2) { height: 6px; }
+        .bluetooth-signal-bar:nth-child(3) { height: 9px; }
+        .bluetooth-signal-bar:nth-child(4) { height: 12px; }
+        .bluetooth-signal-bar:nth-child(5) { height: 16px; }
+
+        .bluetooth-signal-text {
+            display: none;
+        }
+
+        #bluetooth-toggle {
+            position: fixed;
+            bottom: 20px;
+            right: 90px;
+            width: 60px;
+            height: 60px;
+            background-color: #9b59b6;
+            color: white;
+            border-radius: 50%;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            cursor: pointer;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.3);
+            z-index: 1998;
+            font-size: 28px;
+            transition: all 0.3s ease;
+        }
+
+        #bluetooth-toggle:hover {
+            background-color: #8e44ad;
+            transform: scale(1.1);
+        }
+
+        #bluetooth-count {
+            position: absolute;
+            top: -5px;
+            right: -5px;
+            background-color: #e74c3c;
+            color: white;
+            border-radius: 50%;
+            width: 24px;
+            height: 24px;
+            font-size: 14px;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            font-weight: bold;
+            display: none;
+        }
+
+        /* Bluetooth Pairing Button */
+        .bluetooth-pair-button {
+            display: inline-block;
+            margin-top: 8px;
+            padding: 5px 10px;
+            background-color: #9b59b6;
+            color: white;
+            border: none;
+            border-radius: 3px;
+            font-size: 12px;
+            cursor: pointer;
+            transition: background-color 0.2s;
+        }
+
+        .bluetooth-pair-button:hover {
+            background-color: #8e44ad;
+        }
+
+        .bluetooth-pair-button.paired {
+            background-color: #27ae60;
+        }
+
+        .bluetooth-pair-button.paired:hover {
+            background-color: #219653;
+        }
+
+        /* Bluetooth Unlock Button */
+        .bluetooth-unlock-button {
+            display: inline-block;
+            margin-top: 8px;
+            padding: 5px 10px;
+            background-color: #2980b9;
+            color: white;
+            border: none;
+            border-radius: 3px;
+            font-size: 12px;
+            cursor: pointer;
+            transition: background-color 0.2s;
+        }
+        
+        .bluetooth-unlock-button:hover {
+            background-color: #3498db;
+        }
+
+        /* Add a class to preserve hover state during updates */
+        .bluetooth-device.hover-preserved {
+            background-color: #333;
+        }
+
+        /* Add a more specific rule to prevent hover state from being lost when hovering over child elements */
+        .bluetooth-device:hover .bluetooth-device-name,
+        .bluetooth-device:hover .bluetooth-device-details,
+        .bluetooth-device:hover .bluetooth-device-timestamp,
+        .bluetooth-device:hover .bluetooth-pair-button {
+            pointer-events: auto;
+        }
     </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>
@@ -121,6 +690,51 @@
         <div id="loading">Loading...</div>
     </div>
 
+    <!-- Notification System -->
+    <div id="notification-container"></div>
+
+    <!-- Notes Panel -->
+    <div id="notes-panel">
+        <div id="notes-header">
+            <div id="notes-title">Notes & Information</div>
+            <div id="notes-close">×</div>
+        </div>
+        <div id="notes-search-container">
+            <input type="text" id="notes-search" placeholder="Search notes...">
+        </div>
+        <div id="notes-categories">
+            <div class="notes-category active" data-category="all">All</div>
+            <div class="notes-category" data-category="important">Important</div>
+            <div class="notes-category" data-category="unread">Unread</div>
+        </div>
+        <div id="notes-content"></div>
+    </div>
+    <div id="notes-toggle">
+        <span>📝</span>
+        <div id="notes-count">0</div>
+    </div>
+
+    <!-- Bluetooth Scanner Panel -->
+    <div id="bluetooth-panel">
+        <div id="bluetooth-header">
+            <div id="bluetooth-title">Bluetooth Scanner</div>
+            <div id="bluetooth-close">×</div>
+        </div>
+        <div id="bluetooth-search-container">
+            <input type="text" id="bluetooth-search" placeholder="Search devices...">
+        </div>
+        <div id="bluetooth-categories">
+            <div class="bluetooth-category active" data-category="all">All</div>
+            <div class="bluetooth-category" data-category="nearby">Nearby</div>
+            <div class="bluetooth-category" data-category="saved">Saved</div>
+        </div>
+        <div id="bluetooth-content"></div>
+    </div>
+    <div id="bluetooth-toggle" style="display: none;">
+        <span>📡</span>
+        <div id="bluetooth-count">0</div>
+    </div>
+
     <script>
         const config = {
             type: Phaser.AUTO,
@@ -158,6 +772,366 @@
         const hideRoomsOnExit = false;
         const hideNonAdjacentRooms = false;
 
+        // Debug system variables - moved to the top
+        let debugMode = false;
+        let debugLevel = 1; // 1 = basic, 2 = detailed, 3 = verbose
+        let visualDebugMode = false;
+        let fpsCounter = null;
+        
+        // Notes and notification system
+        const gameNotes = [];
+        let unreadNotes = 0;
+        
+        // Show a notification instead of using alert()
+        function showNotification(message, type = 'info', title = '', duration = 5000) {
+            const notificationContainer = document.getElementById('notification-container');
+            
+            // Create notification element
+            const notification = document.createElement('div');
+            notification.className = `notification ${type}`;
+            
+            // Create notification content
+            let notificationContent = '';
+            if (title) {
+                notificationContent += `<div class="notification-title">${title}</div>`;
+            }
+            notificationContent += `<div class="notification-message">${message}</div>`;
+            notificationContent += `<div class="notification-close">×</div>`;
+            
+            if (duration > 0) {
+                notificationContent += `<div class="notification-progress"></div>`;
+            }
+            
+            notification.innerHTML = notificationContent;
+            
+            // Add to container
+            notificationContainer.appendChild(notification);
+            
+            // Show notification with animation
+            setTimeout(() => {
+                notification.classList.add('show');
+            }, 10);
+            
+            // Add progress animation if duration is set
+            if (duration > 0) {
+                const progress = notification.querySelector('.notification-progress');
+                progress.style.transition = `width ${duration}ms linear`;
+                
+                // Start progress animation
+                setTimeout(() => {
+                    progress.style.width = '0%';
+                }, 10);
+                
+                // Remove notification after duration
+                setTimeout(() => {
+                    removeNotification(notification);
+                }, duration);
+            }
+            
+            // Add close button event listener
+            const closeBtn = notification.querySelector('.notification-close');
+            closeBtn.addEventListener('click', () => {
+                removeNotification(notification);
+            });
+            
+            return notification;
+        }
+        
+        // Remove a notification with animation
+        function removeNotification(notification) {
+            notification.classList.remove('show');
+            
+            // Remove from DOM after animation
+            setTimeout(() => {
+                if (notification.parentNode) {
+                    notification.parentNode.removeChild(notification);
+                }
+            }, 300);
+        }
+        
+        // Add a note to the notes panel
+        function addNote(title, text, important = false) {
+            // Check if a note with the same title and text already exists
+            const noteExists = gameNotes.some(note => note.title === title && note.text === text);
+            
+            // If the note already exists, don't add it again
+            if (noteExists) {
+                debugLog(`Note "${title}" already exists, not adding duplicate`, 2);
+                return null;
+            }
+            
+            const note = {
+                id: Date.now(),
+                title: title,
+                text: text,
+                timestamp: new Date(),
+                read: false,
+                important: important
+            };
+            
+            gameNotes.push(note);
+            updateNotesPanel();
+            updateNotesCount();
+            
+            // Show notification for new note
+            showNotification(`New note added: ${title}`, 'info', 'Note Added', 3000);
+            
+            return note;
+        }
+        
+        // Update the notes panel with current notes
+        function updateNotesPanel() {
+            const notesContent = document.getElementById('notes-content');
+            const searchTerm = document.getElementById('notes-search')?.value?.toLowerCase() || '';
+            
+            // Get active category
+            const activeCategory = document.querySelector('.notes-category.active')?.dataset.category || 'all';
+            
+            // Filter notes based on search and category
+            let filteredNotes = [...gameNotes];
+            
+            // Apply category filter
+            if (activeCategory === 'important') {
+                filteredNotes = filteredNotes.filter(note => note.important);
+            } else if (activeCategory === 'unread') {
+                filteredNotes = filteredNotes.filter(note => !note.read);
+            }
+            
+            // Apply search filter
+            if (searchTerm) {
+                filteredNotes = filteredNotes.filter(note => 
+                    note.title.toLowerCase().includes(searchTerm) || 
+                    note.text.toLowerCase().includes(searchTerm)
+                );
+            }
+            
+            // Sort notes with important ones first, then by timestamp (newest first)
+            filteredNotes.sort((a, b) => {
+                if (a.important !== b.important) {
+                    return a.important ? -1 : 1;
+                }
+                return b.timestamp - a.timestamp;
+            });
+            
+            // Clear current content
+            notesContent.innerHTML = '';
+            
+            // Add notes
+            if (filteredNotes.length === 0) {
+                if (searchTerm) {
+                    notesContent.innerHTML = '<div class="note-item">No notes match your search.</div>';
+                } else if (activeCategory !== 'all') {
+                    notesContent.innerHTML = `<div class="note-item">No ${activeCategory} notes found.</div>`;
+                } else {
+                    notesContent.innerHTML = '<div class="note-item">No notes yet.</div>';
+                }
+            } else {
+                filteredNotes.forEach(note => {
+                    const noteElement = document.createElement('div');
+                    noteElement.className = 'note-item';
+                    noteElement.dataset.id = note.id;
+                    
+                    // Format the timestamp
+                    const timestamp = new Date(note.timestamp);
+                    const formattedDate = timestamp.toLocaleDateString();
+                    const formattedTime = timestamp.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+                    
+                    let noteContent = `<div class="note-title">
+                        <span>${note.title}</span>
+                        <div class="note-icons">`;
+                    
+                    if (note.important) {
+                        noteContent += `<span class="note-icon">⭐</span>`;
+                    }
+                    if (!note.read) {
+                        noteContent += `<span class="note-icon">📌</span>`;
+                    }
+                    
+                    noteContent += `</div></div>`;
+                    noteContent += `<div class="note-text">${note.text}</div>`;
+                    noteContent += `<div class="note-timestamp">${formattedDate} ${formattedTime}</div>`;
+                    
+                    noteElement.innerHTML = noteContent;
+                    
+                    // Toggle expanded state when clicked
+                    noteElement.addEventListener('click', () => {
+                        noteElement.classList.toggle('expanded');
+                        
+                        // Mark as read when expanded
+                        if (!note.read && noteElement.classList.contains('expanded')) {
+                            note.read = true;
+                            updateNotesCount();
+                            updateNotesPanel();
+                        }
+                    });
+                    
+                    notesContent.appendChild(noteElement);
+                });
+            }
+        }
+        
+        // Update the unread notes count
+        function updateNotesCount() {
+            const notesCount = document.getElementById('notes-count');
+            unreadNotes = gameNotes.filter(note => !note.read).length;
+            
+            notesCount.textContent = unreadNotes;
+            notesCount.style.display = unreadNotes > 0 ? 'flex' : 'none';
+        }
+        
+        // Toggle the notes panel
+        function toggleNotesPanel() {
+            const notesPanel = document.getElementById('notes-panel');
+            const isVisible = notesPanel.style.display === 'block';
+            
+            notesPanel.style.display = isVisible ? 'none' : 'block';
+        }
+        
+        // Replace alert with our custom notification system
+        function gameAlert(message, type = 'info', title = '', duration = 5000) {
+            return showNotification(message, type, title, duration);
+        }
+        
+        // Debug logging function that only logs when debug mode is active
+        function debugLog(message, data = null, level = 1) {
+            if (!debugMode || debugLevel < level) return;
+            
+            // Check if the first argument is a string
+            if (typeof message === 'string') {
+                // Create the formatted debug message
+                const formattedMessage = `[DEBUG] === ${message} ===`;
+                
+                // Determine color based on message content
+                let color = '#0077FF'; // Default blue for general info
+                let fontWeight = 'bold';
+                
+                // Success messages - green
+                if (message.includes('SUCCESS') || 
+                    message.includes('UNLOCKED') || 
+                    message.includes('NOT LOCKED')) {
+                    color = '#00AA00'; // Green
+                }
+                // Error/failure messages - red
+                else if (message.includes('FAIL') || 
+                         message.includes('ERROR') || 
+                         message.includes('NO LOCK REQUIREMENTS FOUND')) {
+                    color = '#DD0000'; // Red
+                }
+                // Sensitive information - purple
+                else if (message.includes('PIN') || 
+                         message.includes('PASSWORD') || 
+                         message.includes('KEY') ||
+                         message.includes('LOCK REQUIREMENTS')) {
+                    color = '#AA00AA'; // Purple
+                }
+                
+                // Add level indicator to the message
+                const levelIndicator = level > 1 ? ` [L${level}]` : '';
+                const finalMessage = formattedMessage + levelIndicator;
+                
+                // Log with formatting
+                if (data) {
+                    console.log(`%c${finalMessage}`, `color: ${color}; font-weight: ${fontWeight};`, data);
+                } else {
+                    console.log(`%c${finalMessage}`, `color: ${color}; font-weight: ${fontWeight};`);
+                }
+            } else {
+                // If not a string, just log as is
+                console.log(message, data);
+            }
+        }
+        
+        // Function to display tension debug info only when debug mode is active
+        function logTensionDebugInfo() {
+            if (!debugMode) return; // Skip all calculations if debug mode is off
+            
+            // Your existing debug code here
+            debugLog("Tension debug information:", null, 2);
+            // Add other debug information as needed
+        }
+        
+        // Listen for backtick key to toggle debug mode
+        document.addEventListener('keydown', function(event) {
+            // Toggle debug mode with backtick
+            if (event.key === '`') {
+                if (event.shiftKey) {
+                    // Toggle visual debug mode with Shift+backtick
+                    visualDebugMode = !visualDebugMode;
+                    console.log(`%c[DEBUG] === VISUAL DEBUG MODE ${visualDebugMode ? 'ENABLED' : 'DISABLED'} ===`, 
+                               `color: ${visualDebugMode ? '#00AA00' : '#DD0000'}; font-weight: bold;`);
+                    
+                    // Update physics debug display if game exists
+                    if (game && game.scene && game.scene.scenes && game.scene.scenes[0]) {
+                        const scene = game.scene.scenes[0];
+                        if (scene.physics && scene.physics.world) {
+                            scene.physics.world.drawDebug = debugMode && visualDebugMode;
+                        }
+                    }
+                } else if (event.ctrlKey) {
+                    // Cycle through debug levels with Ctrl+backtick
+                    if (debugMode) {
+                        debugLevel = (debugLevel % 3) + 1; // Cycle through 1, 2, 3
+                        console.log(`%c[DEBUG] === DEBUG LEVEL ${debugLevel} ===`, 
+                                   `color: #0077FF; font-weight: bold;`);
+                    }
+                } else {
+                    // Regular debug mode toggle
+                    debugMode = !debugMode;
+                    console.log(`%c[DEBUG] === DEBUG MODE ${debugMode ? 'ENABLED' : 'DISABLED'} ===`, 
+                               `color: ${debugMode ? '#00AA00' : '#DD0000'}; font-weight: bold;`);
+                    
+                    // Update physics debug display if game exists
+                    if (game && game.scene && game.scene.scenes && game.scene.scenes[0]) {
+                        const scene = game.scene.scenes[0];
+                        if (scene.physics && scene.physics.world) {
+                            scene.physics.world.drawDebug = debugMode && visualDebugMode;
+                        }
+                    }
+                }
+            }
+        });
+        
+        // Initialize notes panel
+        document.addEventListener('DOMContentLoaded', function() {
+            // Set up notes toggle button
+            const notesToggle = document.getElementById('notes-toggle');
+            notesToggle.addEventListener('click', toggleNotesPanel);
+            
+            // Set up notes close button
+            const notesClose = document.getElementById('notes-close');
+            notesClose.addEventListener('click', toggleNotesPanel);
+            
+            // Set up search functionality
+            const notesSearch = document.getElementById('notes-search');
+            notesSearch.addEventListener('input', updateNotesPanel);
+            
+            // Set up category filters
+            const categories = document.querySelectorAll('.notes-category');
+            categories.forEach(category => {
+                category.addEventListener('click', () => {
+                    // Remove active class from all categories
+                    categories.forEach(c => c.classList.remove('active'));
+                    // Add active class to clicked category
+                    category.classList.add('active');
+                    // Update notes panel
+                    updateNotesPanel();
+                });
+            });
+            
+            // Initialize notes count
+            updateNotesCount();
+            
+            // Initialize Bluetooth scanner panel
+            initializeBluetoothPanel();
+        });
+        
+        // Function to create or update the FPS counter
+        function updateFPSCounter() {
+            if (fpsCounter) {
+                fpsCounter.textContent = `FPS: ${Math.round(game.loop.actualFps)}`;
+            }
+        }
+
         // Declare gameScenario as let (not const) so we can assign it later
         let gameScenario = null;  // Initialize as null
 
@@ -193,7 +1167,7 @@
         // 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
+        const BLUETOOTH_SCAN_INTERVAL = 200; // Scan every 200ms for more responsive updates
 
         const gameState = {
             biometricSamples: [],
@@ -246,6 +1220,24 @@
             REVEALED: 0x00ff00
         };
 
+        const DEBUG_MODE = {
+            get enabled() { return debugMode; },
+            set enabled(value) { debugMode = value; },
+            toggle: function() {
+                debugMode = !debugMode;
+                // No need to log here as the global event listener will handle it
+            },
+            log: function(message, data = null) {
+                if (!debugMode) return;
+                
+                if (data) {
+                    console.log(`%c[DEBUG] === ${message} ===`, 'color: #0077FF; font-weight: bold;', data);
+                } else {
+                    console.log(`%c[DEBUG] === ${message} ===`, 'color: #0077FF; font-weight: bold;');
+                }
+            }
+        };
+
         // preloads the assets
         function preload() {
             // Show loading text
@@ -278,8 +1270,10 @@
             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('bluetooth_spoofer', 'assets/objects/bluetooth_spoofer.png');
             this.load.image('tablet', 'assets/objects/tablet.png');
             this.load.image('fingerprint_kit', 'assets/objects/fingerprint_kit.png');
+            this.load.image('lockpick', 'assets/objects/lockpick.png');
 
 
             this.load.json('gameScenarioJSON', 'assets/scenarios/ceo_exfil.json');
@@ -457,14 +1451,14 @@
                     });
                     
                     if (clickedItem) {
-                        console.log('Inventory item clicked:', clickedItem.name);
+                        debugLog('INVENTORY ITEM CLICKED', { name: clickedItem.name }, 2);
                         handleObjectInteraction(clickedItem);
                         return;
                     }
                 }
                 
                 // if not clicking inventory, handle as movement
-                console.log('Click detected at:', pointer.worldX, pointer.worldY);
+                debugLog('CLICK DETECTED', { x: pointer.worldX, y: pointer.worldY }, 3);
                 movePlayerToPoint.call(this, pointer.worldX, pointer.worldY);
             });
 
@@ -508,6 +1502,9 @@
 
             // Add this to your scene's create function
             initializeSamplesUI();
+
+            // Log initial debug status
+            console.log("%cPress ` (backtick) to toggle debug mode, Ctrl+` to cycle debug levels (1-3), Shift+` for visual debug", "color: #888; font-style: italic;");
         }
 
         function update() {
@@ -536,7 +1533,12 @@
         // introduces the scenario
         function introduceScenario() {
             console.log(gameScenario.scenario_brief);
-            alert(gameScenario.scenario_brief);
+            
+            // Add scenario brief as an important note
+            addNote("Mission Brief", gameScenario.scenario_brief, true);
+            
+            // Show notification
+            gameAlert(gameScenario.scenario_brief, 'info', 'Mission Brief', 8000);
         }
 
         // initializes the rooms
@@ -589,7 +1591,7 @@
                         width: width * 48,  // tile width is 48
                         height: height * 48 // tile height is 48
                     };
-                    console.log(`Room ${roomId} dimensions:`, roomDimensions[roomId]);
+                    debugLog('ROOM DIMENSIONS', { roomId, dimensions: roomDimensions[roomId] }, 3);
                 } else {
                     console.error(`Could not find tilemap data for room ${roomId}`);
                     // Fallback to default dimensions if needed
@@ -669,7 +1671,7 @@
                         }
                     } else {
                         if (processed.has(connected)) {
-                            console.log(`Room ${connected} already processed, skipping`);
+                            debugLog('ROOM ALREADY PROCESSED', { roomId: connected }, 3);
                             return;
                         }
                         
@@ -865,10 +1867,10 @@
                         // Add click handler for all objects
                         sprite.on('pointerdown', () => {
                             if (isActiveObject) {
-                                console.log(`Clicked active object ${obj.name}`);
+                                debugLog('OBJECT CLICKED', { name: obj.name }, 2);
                                 handleObjectInteraction(sprite);
                             } else {
-                                alert("Nothing of note here");
+                                gameAlert("Nothing of note here", 'info', '', 2000);
                             }
                         });
                     });
@@ -1034,7 +2036,7 @@
                 }
                 
                 // Otherwise, handle as movement click
-                console.log('Click detected at:', worldPoint.x, worldPoint.y);
+                debugLog('CLICK DETECTED', { x: worldPoint.x, y: worldPoint.y }, 3);
                 movePlayerToPoint.call(this, worldPoint.x, worldPoint.y);
             });
         }
@@ -1445,10 +2447,14 @@
         // handles interactions with objects
         // displays the object's data in an alert
         function handleObjectInteraction(sprite) {
-            console.log('CyberChef: handleObjectInteraction called for:', sprite.name, 'Has open workstation:', !!sprite.openCryptoWorkstation);
+            // Only log detailed object interactions at debug level 2+
+            debugLog('OBJECT INTERACTION', { 
+                name: sprite.name, 
+                hasWorkstation: !!sprite.openCryptoWorkstation 
+            }, 2);
             
             if (sprite.openCryptoWorkstation && sprite.openCryptoWorkstation()) {
-                console.log('CyberChef: Crypto workstation opened');
+                debugLog('WORKSTATION OPENED', null, 1);
                 return;
             }
             
@@ -1466,7 +2472,8 @@
                 const distanceSq = dx * dx + dy * dy;
                 
                 if (distanceSq > INTERACTION_RANGE_SQ) {
-                    // alert("Too far away to interact with this object.");
+                    // Show notification instead of alert
+                    //gameAlert("Too far away to interact with this object.", 'warning', '', 2000);
                     return;
                 }
             }
@@ -1501,7 +2508,9 @@
                 data.contents.forEach(item => {
                     message += `- ${item.name}\n`;
                 });
-                alert(message);
+                
+                // Show notification instead of alert
+                gameAlert(message, 'success', 'Items Found', 5000);
                 
                 // Add all contents to inventory
                 data.contents.forEach(item => {
@@ -1520,9 +2529,9 @@
                 return;
             }
             
-            // Check for locked state in scenarioData
+            // Check if item is locked
             if (data.locked === true) {
-                console.log('Item is locked:', data);
+                debugLog('ITEM LOCKED', data, 2);
                 handleUnlock(sprite, 'item');
                 return;
             }
@@ -1532,34 +2541,79 @@
             
             if (data.readable && data.text) {
                 message += `Text: ${data.text}\n\n`;
+                
+                // Add readable text as a note
+                if (data.text.trim().length > 0) {
+                    const addedNote = addNote(data.name, data.text, data.important || false);
+                    
+                    // Only show notification if a new note was actually added (not a duplicate)
+                    if (addedNote) {
+                        gameAlert(`Added "${data.name}" to your notes.`, 'info', 'Note Added', 3000);
+                        
+                        // If this is a note in the inventory, remove it after adding to notes list
+                        if (isInventoryItem && data.type === 'notes') {
+                            // Remove from inventory after a short delay to allow the player to see the message
+                            setTimeout(() => {
+                                if (removeFromInventory(sprite)) {
+                                    gameAlert(`Removed "${data.name}" from inventory after recording in notes.`, 'success', 'Inventory Updated', 3000);
+                                }
+                            }, 1000);
+                        }
+                    }
+                }
             }
             
             if (data.takeable) {
-                message += `This item can be taken\n\n`;
+                // If it's a note type item that's already been read and added to notes,
+                // don't add it to inventory unless it has a special purpose
+                const isJustInformationalNote = 
+                    data.type === 'notes' && 
+                    data.readable && 
+                    data.text && 
+                    !data.hasSpecialPurpose; // Add this flag to notes that need to be in inventory
                 
-                if (!inventory || !Array.isArray(inventory.items)) {
-                    console.error('Inventory not properly initialized');
-                    return;
-                }
-                
-                const isInRoom = currentRoom && 
-                                rooms[currentRoom] && 
-                                rooms[currentRoom].objects && 
-                                rooms[currentRoom].objects[sprite.name];
+                if (!isJustInformationalNote) {
+                    message += `This item can be taken\n\n`;
+                    
+                    if (!inventory || !Array.isArray(inventory.items)) {
+                        console.error('Inventory not properly initialized');
+                        return;
+                    }
+                    
+                    const isInRoom = currentRoom && 
+                                    rooms[currentRoom] && 
+                                    rooms[currentRoom].objects && 
+                                    rooms[currentRoom].objects[sprite.name];
+                            
+                    const itemIdentifier = createItemIdentifier(sprite.scenarioData);
+                            
+                    const isInInventory = inventory.items.some(item => 
+                        item && createItemIdentifier(item.scenarioData) === itemIdentifier
+                    );
+                            
+                    if (isInRoom && !isInInventory) {
+                        debugLog('INVENTORY ITEM ADDED', { item: itemIdentifier }, 2);
+                        addToInventory(sprite);
+                    }
+                } else {
+                    // For informational notes, just remove them from the room after reading
+                    if (currentRoom && 
+                        rooms[currentRoom] && 
+                        rooms[currentRoom].objects && 
+                        rooms[currentRoom].objects[sprite.name]) {
                         
-                const itemIdentifier = createItemIdentifier(sprite.scenarioData);
+                        const roomObj = rooms[currentRoom].objects[sprite.name];
+                        roomObj.setVisible(false);
+                        roomObj.active = false;
                         
-                const isInInventory = inventory.items.some(item => 
-                    item && createItemIdentifier(item.scenarioData) === itemIdentifier
-                );
-                        
-                if (isInRoom && !isInInventory) {
-                    console.log('Adding item to inventory:', itemIdentifier);
-                    addToInventory(sprite);
+                        // Show notification about adding to notes instead of inventory
+                        gameAlert(`Information recorded in your notes.`, 'success', 'Note Recorded', 3000);
+                    }
                 }
             }
             
-            alert(message);
+            // Show notification instead of alert
+            gameAlert(message, 'info', data.name, 7000);
         }
 
         // adds an item to the inventory
@@ -1572,6 +2626,13 @@
             }
             
             try {
+                // Check if the item is already in the inventory
+                const isAlreadyInInventory = inventory.items.some(item => item.name === sprite.name);
+                if (isAlreadyInInventory) {
+                    console.log(`Item ${sprite.name} is already in inventory, not adding again`);
+                    return false;
+                }
+                
                 // Remove from room if it exists
                 if (currentRoom && 
                     rooms[currentRoom] && 
@@ -1609,28 +2670,66 @@
                 inventorySprite.setDepth(2003);
 
                 // Add pointer events
-                inventorySprite.on('pointerdown', function(event) {
-                    event.stopPropagation();
-                    handleObjectInteraction(this);
+                inventorySprite.on('pointerdown', function(pointer) {
+                    // Check if this is the Bluetooth scanner
+                    if (this.scenarioData.type === "bluetooth_scanner") {
+                        // Toggle the Bluetooth scanner panel
+                        toggleBluetoothPanel();
+                        return;
+                    }
+                    
+                    // Handle other inventory items as before
+                    handleItemInteraction(this, true);
                 });
                 
                 inventorySprite.on('pointerover', function() {
                     this.setTint(0xdddddd);
+                    
+                    // Show tooltip with item name
+                    const tooltipText = scene.add.text(
+                        this.x, 
+                        this.y - 40, 
+                        this.scenarioData.name, 
+                        { 
+                            fontSize: '14px',
+                            backgroundColor: '#000',
+                            padding: { x: 5, y: 3 },
+                            fixedWidth: 150,
+                            align: 'center'
+                        }
+                    ).setOrigin(0.5, 0.5).setDepth(2004);
+                    
+                    this.tooltip = tooltipText;
                 });
                 
                 inventorySprite.on('pointerout', function() {
                     this.clearTint();
+                    
+                    if (this.tooltip) {
+                        this.tooltip.destroy();
+                        this.tooltip = null;
+                    }
                 });
                 
-                inventory.container.add(inventorySprite);
+                // Add to inventory array
                 inventory.items.push(inventorySprite);
                 
-                console.log('Item added to inventory:', {
-                    name: sprite.name,
-                    totalItems: inventory.items.length
-                });
+                // Add to container
+                inventory.container.add(inventorySprite);
+                
+                // Show notification
+                gameAlert(`Added ${sprite.scenarioData.name} to inventory`, 'success', 'Item Collected', 3000);
+                
+                // If this is the Bluetooth scanner, show the toggle button
+                if (sprite.scenarioData.type === "bluetooth_scanner") {
+                    const bluetoothToggle = document.getElementById('bluetooth-toggle');
+                    bluetoothToggle.style.display = 'flex';
+                }
+                
+                return true;
             } catch (error) {
-                console.error('Error adding item to inventory:', error);
+                console.error('Error adding to inventory:', error);
+                return false;
             }
         }
 
@@ -1664,7 +2763,7 @@
                 .setScrollFactor(0)
                 .setDepth(2001);
             
-            console.log('Inventory initialized:', inventory); // Debug log
+            debugLog('INVENTORY INITIALIZED', inventory, 2); // Debug log at level 2
         }
 
         // runs after rooms are fully set up
@@ -1812,14 +2911,14 @@
                         
                         if (distance <= DOOR_INTERACTION_RANGE) {
                             if (doorTile.properties?.locked) {
-                                console.log('Door is locked, attempting unlock');
+                                debugLog('DOOR LOCKED - ATTEMPTING UNLOCK', null, 2);
                                 colorDoorTiles(doorTile, room);
                                 handleDoorUnlock(doorTile, room);
                             } else {
-                                console.log('Door is not locked');
+                                debugLog('DOOR NOT LOCKED', null, 2);
                             }
                         } else {
-                            console.log("Too far from door to interact");
+                            debugLog('DOOR TOO FAR TO INTERACT', null, 2);
                         }
                     });
 
@@ -1849,13 +2948,13 @@
         }
         
         function handleDoorUnlock(doorTile, room) {
-            console.log('handleDoorUnlock called:', { doorTile, room });
+            // No need to log here since handleUnlock will log 'UNLOCK ATTEMPT'
             doorTile.layer = room.doorsLayer; // Ensure layer reference is set
             handleUnlock(doorTile, 'door');
         }
 
         function handleUnlock(lockable, type) {
-            console.log('handleUnlock called:', { type, lockable });
+            debugLog('UNLOCK ATTEMPT', null, 2);
             
             // Check locked state in scenarioData for items
             const isLocked = type === 'door' ? 
@@ -1863,7 +2962,7 @@
                 lockable.scenarioData?.locked;
             
             if (!isLocked) {
-                console.log('Object is not locked');
+                debugLog('OBJECT NOT LOCKED', null, 2);
                 return;
             }
             
@@ -1872,17 +2971,17 @@
                 ? getLockRequirementsForDoor(lockable)
                 : getLockRequirementsForItem(lockable);
             
-            console.log('Lock requirements:', lockRequirements);
+            // Don't log lock requirements here since it's already logged in the getter functions
             
             if (!lockRequirements) {
-                console.log('No lock requirements found');
+                // Don't log here since it's already logged in the getter functions if applicable
                 return;
             }
             
             switch(lockRequirements.lockType) {
                 case 'key':
                     const requiredKey = lockRequirements.requires;
-                    console.log('Checking for key:', requiredKey);
+                    debugLog('KEY REQUIRED', requiredKey, 2);
                     const hasKey = inventory.items.some(item => 
                         item && item.scenarioData && 
                         item.scenarioData.key_id === requiredKey
@@ -1896,74 +2995,98 @@
                         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}.`);
+                        debugLog('KEY UNLOCK SUCCESS', null, 1);
+                        unlockTarget(lockable, type, lockable.layer);
+                        gameAlert(`You used the ${keyName} that you found in ${keyLocation} to unlock the ${type}.`, 'success', 'Unlock Successful', 5000);
                     } else {
-                        alert(`Requires key: ${requiredKey}`);
+                        // Check for lockpick kit
+                        const hasLockpick = inventory.items.some(item => 
+                            item && item.scenarioData && 
+                            item.scenarioData.type === 'lockpick'
+                        );
+                        
+                        if (hasLockpick) {
+                            debugLog('LOCKPICK AVAILABLE', null, 2);
+                            if (confirm("Would you like to attempt picking this lock?")) {
+                                let difficulty;
+                                
+                                // If this is a room-level lock, get difficulty from gameScenario
+                                if (lockable.properties?.requires) {
+                                    // Find which room this lock belongs to
+                                    const roomId = Object.keys(gameScenario.rooms).find(roomId => {
+                                        const room = gameScenario.rooms[roomId];
+                                        return room.requires === lockable.properties.requires;
+                                    });
+                                    difficulty = roomId ? gameScenario.rooms[roomId].difficulty : null;
+                                }
+                                
+                                // If not found, try object-level difficulty
+                                difficulty = difficulty || lockable.scenarioData?.difficulty || lockable.properties?.difficulty;
+                                debugLog('STARTING LOCKPICK MINIGAME', { difficulty }, 2);
+                                startLockpickingMinigame(lockable, game.scene.scenes[0], difficulty);
+                            }
+                        } else {
+                            debugLog('KEY NOT FOUND - FAIL', null, 2);
+                            gameAlert(`Requires key: ${requiredKey}`, 'error', 'Locked', 4000);
+                        }
                     }
                     break;
 
                 case 'pin':
-                    console.log('Handling PIN lock');
+                    debugLog('PIN CODE REQUESTED', null, 2);
                     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.`);
+                        debugLog('PIN CODE SUCCESS', null, 1);
+                        gameAlert(`Correct PIN! The ${type} is now unlocked.`, 'success', 'PIN Accepted', 4000);
                     } else if (pinInput !== null) {
-                        alert("Incorrect PIN code.");
+                        debugLog('PIN CODE FAIL', null, 2);
+                        gameAlert("Incorrect PIN code.", 'error', 'PIN Rejected', 3000);
                     }
                     break;
 
                 case 'password':
-                    console.log('Handling password lock');
+                    debugLog('PASSWORD REQUESTED', null, 2);
                     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.`);
+                        debugLog('PASSWORD SUCCESS', null, 1);
+                        gameAlert(`Correct password! The ${type} is now unlocked.`, 'success', 'Password Accepted', 4000);
                     } else if (passwordInput !== null) {
-                        alert("Incorrect password.");
+                        debugLog('PASSWORD FAIL', null, 2);
+                        gameAlert("Incorrect password.", 'error', 'Password Rejected', 3000);
                     }
                     break;
 
                 case 'bluetooth':
                     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
+                        // Try to spoof the Bluetooth device
+                        const spoofResult = spoofBluetoothDevice(lockable);
+                        
+                        if (spoofResult) {
+                            // If spoofing was successful, unlock the target
+                            unlockTarget(lockable, type, lockable.layer);
+                        }
+                        
+                        // Allow the item to be picked up even if locked
                         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];
+                            // Check if the item is already in the inventory before adding it
+                            const isAlreadyInInventory = inventory.items.some(item => item.name === lockable.name);
+                            
+                            if (!isAlreadyInInventory) {
+                                addToInventory(lockable);
+                                // Remove from room objects if it exists there
+                                if (currentRoom && rooms[currentRoom].objects) {
+                                    delete rooms[currentRoom].objects[lockable.name];
+                                }
                             }
                         }
                         return;
                     }
-                    
-                    // 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,
-                            distance: distance
-                        });
-                        unlockTarget(lockable, type, lockable.layer);
-                        alert(`Bluetooth connection established. Device unlocked.`);
-                        return;
-                    }
-                    
-                    alert("Too far from device to establish Bluetooth connection.");
                     break;
 
                 default:
-                    alert(`Requires: ${lockRequirements.requires}`);
+                    gameAlert(`Requires: ${lockRequirements.requires}`, 'warning', 'Locked', 4000);
             }
         }
 
@@ -2092,7 +3215,7 @@
         }
 
         function getLockRequirementsForDoor(doorTile) {
-            console.log('Getting lock requirements for door:', doorTile);
+            debugLog('CHECKING DOOR REQUIREMENTS', null, 3);
             
             if (!doorTile.layer) {
                 console.error('Door tile missing layer reference');
@@ -2102,7 +3225,7 @@
             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 });
+            debugLog('DOOR COORDINATES', { doorWorldX, doorWorldY }, 3);
             
             const overlappingRooms = [];
             Object.entries(rooms).forEach(([roomId, otherRoom]) => {
@@ -2121,7 +3244,7 @@
                 };
                 
                 if (boundsOverlap(doorCheckArea, roomBounds)) {
-                    console.log(`Room ${roomId} overlaps with door`);
+                    debugLog(`ROOM ${roomId} OVERLAPS WITH DOOR`, null, 3);
                     const roomCenterX = roomBounds.x + (roomBounds.width / 2);
                     const roomCenterY = roomBounds.y + (roomBounds.height / 2);
                     const distanceToPlayer = Phaser.Math.Distance.Between(
@@ -2140,13 +3263,13 @@
                 }
             });
 
-            console.log('Overlapping rooms:', overlappingRooms);
+            debugLog('OVERLAPPING ROOMS', overlappingRooms, 3);
             
             const lockedRooms = overlappingRooms
                 .filter(r => r.locked)
                 .sort((a, b) => b.distance - a.distance);
             
-            console.log('Locked rooms:', lockedRooms);
+            debugLog('LOCKED ROOMS', lockedRooms, 3);
 
             if (lockedRooms.length > 0) {
                 const targetRoom = lockedRooms[0];
@@ -2154,11 +3277,11 @@
                     lockType: targetRoom.lockType,
                     requires: targetRoom.requires
                 };
-                console.log('Returning lock requirements:', requirements);
+                debugLog('LOCK REQUIREMENTS', requirements, 2);
                 return requirements;
             }
             
-            console.log('No lock requirements found');
+            debugLog('NO LOCK REQUIREMENTS FOUND', null, 2);
             return null;
         }
 
@@ -2184,9 +3307,13 @@
             });
             
             container.scenarioData.isUnlockedButNotCollected = false;
-            alert('You collected the items from the container.');
+            gameAlert('You collected the items from the container.', 'success', 'Items Collected', 4000);
         }
 
+        // Add a throttle mechanism for Bluetooth panel updates
+        let lastBluetoothPanelUpdate = 0;
+        const BLUETOOTH_UPDATE_THROTTLE = 500; // milliseconds
+
         function checkBluetoothDevices() {
             // Find scanner in inventory
             const scanner = inventory.items.find(item => 
@@ -2195,29 +3322,183 @@
             
             if (!scanner) return;
             
-            // Find all tablets in the current room
+            // Show the Bluetooth toggle button if it's not already visible
+            const bluetoothToggle = document.getElementById('bluetooth-toggle');
+            if (bluetoothToggle.style.display === 'none') {
+                bluetoothToggle.style.display = 'flex';
+            }
+            
+            // Find all Bluetooth devices in the current room
             if (!currentRoom || !rooms[currentRoom] || !rooms[currentRoom].objects) return;
             
+            // Keep track of devices detected in this scan
+            const detectedDevices = new Set();
+            let needsUpdate = false;
+            
             Object.values(rooms[currentRoom].objects).forEach(obj => {
-                if (obj.scenarioData?.type === "tablet" && obj.scenarioData?.locked) {
+                if (obj.scenarioData?.lockType === "bluetooth") {
                     const distance = Phaser.Math.Distance.Between(
                         player.x, player.y,
                         obj.x, obj.y
                     );
                     
+                    const deviceMac = obj.scenarioData?.mac || "Unknown";
+                    
                     if (distance <= BLUETOOTH_SCAN_RANGE) {
-                        console.log('🔍 TABLET IN RANGE:', {
+                        detectedDevices.add(deviceMac);
+                        
+                        debugLog('BLUETOOTH DEVICE DETECTED', {
+                            deviceName: obj.scenarioData?.name,
+                            deviceMac: deviceMac,
                             distance: Math.round(distance),
                             range: BLUETOOTH_SCAN_RANGE
-                        });
+                        }, 2);
                         
-                        // Unlock the tablet
-                        obj.scenarioData.locked = false;
-                        console.log('🔓 TABLET UNLOCKED!');
-                        alert('Bluetooth connection established. Device unlocked.');
+                        // Add to Bluetooth scanner panel
+                        const deviceName = obj.scenarioData?.name || "Unknown Device";
+                        const signalStrength = Math.max(0, Math.round(100 - (distance / BLUETOOTH_SCAN_RANGE * 100)));
+                        const details = `Type: ${obj.scenarioData?.type || "Unknown"}\nDistance: ${Math.round(distance)} units\nSignal Strength: ${signalStrength}%`;
+                        
+                        // Check if device already exists in our list
+                        const existingDevice = bluetoothDevices.find(device => device.mac === deviceMac);
+                        
+                        if (existingDevice) {
+                            // Update existing device details with real-time data
+                            const oldSignalStrength = existingDevice.signalStrength;
+                            existingDevice.details = details;
+                            existingDevice.lastSeen = new Date();
+                            existingDevice.nearby = true;
+                            existingDevice.signalStrength = signalStrength;
+                            
+                            // Only mark for update if signal strength changed significantly
+                            if (Math.abs(oldSignalStrength - signalStrength) > 5) {
+                                needsUpdate = true;
+                            }
+                        } else {
+                            // Add as new device if not already in our list
+                            const newDevice = addBluetoothDevice(deviceName, deviceMac, details, true);
+                            if (newDevice) {
+                                newDevice.signalStrength = signalStrength;
+                                gameAlert(`Bluetooth device detected: ${deviceName} (MAC: ${deviceMac})`, 'info', 'Bluetooth Scanner', 4000);
+                                needsUpdate = true;
+                            }
+                        }
                     }
                 }
             });
+            
+            // Mark devices that weren't detected in this scan as not nearby
+            bluetoothDevices.forEach(device => {
+                if (device.nearby && !detectedDevices.has(device.mac)) {
+                    device.nearby = false;
+                    device.lastSeen = new Date();
+                    needsUpdate = true;
+                }
+            });
+            
+            // Only update the panel if needed and not too frequently
+            const now = Date.now();
+            if (needsUpdate && now - lastBluetoothPanelUpdate > BLUETOOTH_UPDATE_THROTTLE) {
+                updateBluetoothPanel();
+                updateBluetoothCount();
+                lastBluetoothPanelUpdate = now;
+            }
+        }
+
+        function spoofBluetoothDevice(target) {
+            // Find spoofer in inventory
+            const spoofer = inventory.items.find(item => 
+                item.scenarioData?.type === "bluetooth_spoofer"
+            );
+            
+            if (!spoofer) {
+                gameAlert("You need a Bluetooth spoofer to unlock this device.", 'warning', 'Bluetooth Spoofer Required', 4000);
+                return false;
+            }
+            
+            // Check if target is in inventory or in the environment
+            const isInventoryItem = inventory.items.includes(target);
+            
+            // If it's an environment object, check distance
+            if (!isInventoryItem) {
+                // Calculate distance between player and target device
+                const distance = Phaser.Math.Distance.Between(
+                    player.x, player.y,
+                    target.x, target.y
+                );
+                
+                debugLog('BLUETOOTH SPOOF ATTEMPT', {
+                    deviceName: target.scenarioData?.name,
+                    deviceMac: target.scenarioData?.mac,
+                    spooferMac: spoofer.scenarioData?.macPaired,
+                    distance: Math.round(distance),
+                    isInventoryItem: false
+                }, 2);
+                
+                // Check if player is within range
+                if (distance > BLUETOOTH_SCAN_RANGE) {
+                    gameAlert("Too far from device to establish Bluetooth connection.", 'error', 'Connection Failed', 3000);
+                    return false;
+                }
+            } else {
+                // Log attempt for inventory item
+                debugLog('BLUETOOTH SPOOF ATTEMPT', {
+                    deviceName: target.scenarioData?.name,
+                    deviceMac: target.scenarioData?.mac,
+                    spooferMac: spoofer.scenarioData?.macPaired,
+                    isInventoryItem: true,
+                    distance: 0 // Inventory items are always at distance 0
+                }, 2);
+            }
+            
+            // Normalize MAC addresses for comparison
+            const targetMac = target.scenarioData?.mac?.toLowerCase() || "";
+            const spooferMac = spoofer.scenarioData?.macPaired?.toLowerCase() || "";
+            
+            // Check if the spoofer has the correct MAC address
+            if (spooferMac && targetMac && spooferMac === targetMac) {
+                debugLog('BLUETOOTH SPOOF SUCCESS', {
+                    deviceName: target.scenarioData?.name,
+                    mac: target.scenarioData?.mac,
+                    isInventoryItem: isInventoryItem
+                }, 1);
+                
+                // Unlock the device
+                target.scenarioData.locked = false;
+                
+                // If it's an inventory item, update its appearance if needed
+                if (isInventoryItem) {
+                    // Update the item's texture if it has an unlocked version
+                    if (target.scenarioData?.unlockedTexture) {
+                        target.setTexture(target.scenarioData.unlockedTexture);
+                    }
+                    
+                    // If the item has contents, allow them to be collected
+                    if (target.scenarioData?.contents) {
+                        target.scenarioData.isUnlockedButNotCollected = true;
+                        collectContainerContents(target);
+                        
+                        // Remove the device from the bluetoothDevices array
+                        const deviceIndex = bluetoothDevices.findIndex(device => 
+                            device.mac.toLowerCase() === targetMac && device.inInventory
+                        );
+                        
+                        if (deviceIndex !== -1) {
+                            bluetoothDevices.splice(deviceIndex, 1);
+                        }
+                    }
+                }
+                
+                gameAlert("Bluetooth connection spoofed. Device unlocked.", 'success', 'Spoofing Successful', 4000);
+                
+                // Update the Bluetooth panel to reflect the unlocked state
+                updateBluetoothPanel();
+                
+                return true;
+            } else {
+                gameAlert("Bluetooth spoofer MAC address doesn't match the target device.", 'error', 'Spoofing Failed', 4000);
+                return false;
+            }
         }
 
         // Add helper function to generate fingerprint data
@@ -2243,12 +3524,13 @@
             if (scannerState.lockoutTimers[scannerId] && 
                 Date.now() < scannerState.lockoutTimers[scannerId]) {
                 const remainingTime = Math.ceil((scannerState.lockoutTimers[scannerId] - Date.now()) / 1000);
-                alert(`Scanner locked out. Try again in ${remainingTime} seconds.`);
+                gameAlert(`Scanner locked out. Try again in ${remainingTime} seconds.`, 'error', 'Scanner Locked', 4000);
                 return false;
             }
 
             if (!scanner.scenarioData?.biometricType === 'fingerprint') {
-                console.warn('Invalid scanner type');
+                debugLog('SCANNER TYPE ERROR - FAIL', scanner.scenarioData, 2);
+                gameAlert('Invalid scanner type', 'error', 'Scanner Error', 3000);
                 return false;
             }
 
@@ -2260,7 +3542,7 @@
 
             if (!validSample) {
                 handleScannerFailure(scannerId);
-                alert("No valid fingerprint sample found.");
+                gameAlert("No valid fingerprint sample found.", 'error', 'Scan Failed', 4000);
                 return false;
             }
 
@@ -2268,13 +3550,13 @@
             const qualityThreshold = 0.7;
             if (validSample.quality < qualityThreshold) {
                 handleScannerFailure(scannerId);
-                alert("Fingerprint sample quality too poor for scanning.");
+                gameAlert("Fingerprint sample quality too poor for scanning.", 'error', 'Scan Failed', 4000);
                 return false;
             }
 
             // Success case - reset failed attempts
             scannerState.failedAttempts[scannerId] = 0;
-            alert("Biometric scan successful!");
+            gameAlert("Biometric scan successful!", 'success', 'Scan Successful', 4000);
             
             // Add visual feedback
             const successEffect = scanner.scene.add.circle(
@@ -2317,23 +3599,23 @@
             // Check if we should lockout
             if (scannerState.failedAttempts[scannerId] >= MAX_FAILED_ATTEMPTS) {
                 scannerState.lockoutTimers[scannerId] = Date.now() + SCANNER_LOCKOUT_TIME;
-                alert(`Too many failed attempts. Scanner locked for ${SCANNER_LOCKOUT_TIME/1000} seconds.`);
+                gameAlert(`Too many failed attempts. Scanner locked for ${SCANNER_LOCKOUT_TIME/1000} seconds.`, 'error', 'Scanner Locked', 5000);
             } else {
                 const remainingAttempts = MAX_FAILED_ATTEMPTS - scannerState.failedAttempts[scannerId];
-                alert(`Scan failed. ${remainingAttempts} attempts remaining before lockout.`);
+                gameAlert(`Scan failed. ${remainingAttempts} attempts remaining before lockout.`, 'warning', 'Scan Failed', 4000);
             }
         }
 
         // Modify collectFingerprint to include visual feedback
         function collectFingerprint(item) {
             if (!item.scenarioData?.hasFingerprint) {
-                alert("No fingerprints found on this surface.");
+                gameAlert("No fingerprints found on this surface.", 'info', 'No Fingerprints', 3000);
                 return null;
             }
             
             // Check if player has required items
             if (!hasItemInInventory('fingerprint_kit')) {
-                alert("You need a fingerprint kit to collect samples!");
+                gameAlert("You need a fingerprint kit to collect samples!", 'warning', 'Missing Equipment', 4000);
                 return null;
             }
             
@@ -2998,6 +4280,1544 @@
             scene.input.mouse.enabled = false;
         }
 
+        function startLockpickingMinigame(lockable, currentScene, difficulty) {
+            // Create iframe container
+            const iframe = document.createElement('div');
+            iframe.style.cssText = `
+                position: fixed;
+                top: 50%;
+                left: 50%;
+                transform: translate(-50%, -50%);
+                width: 60%;
+                height: 60%;
+                background: rgba(0, 0, 0, 0.9);
+                border: 1px solid #444;
+                z-index: 1000;
+                padding: 20px;
+                border-radius: 5px;
+            `;
+            
+            // Add instructions
+            const instructions = document.createElement('div');
+            instructions.innerHTML = `
+                <h3 style="margin: 0; color: #fff; text-align: center;">Lock Picking</h3>
+                <p style="margin: 5px 0; color: #ccc; text-align: center; font-size: 14px;">
+                    Use spacebar or click to toggle tension levels. Each pin requires the right amount of tension.<br>
+                    🔵 Blue = Pin moving<br>
+                    🟢 Green = Pin set correctly<br>
+                    🔴 Red = Over-pushed (reset)<br>
+                    Set all pins in the correct order with the right tension without resetting.
+                </p>
+            `;
+            instructions.style.cssText = `
+                position: absolute;
+                top: 10px;
+                left: 50%;
+                transform: translateX(-50%);
+                width: 90%;
+            `;
+
+            // Create game container
+            const gameContainer = document.createElement('div');
+            gameContainer.style.cssText = `
+                width: 100%;
+                height: calc(100% - 60px);
+                display: flex;
+                flex-direction: column;
+                justify-content: center;
+                align-items: center;
+                gap: 20px;
+                margin-top: 40px;
+                background: #222;
+                padding: 10px;
+            `;
+
+            // Add difficulty selection
+            const difficultySelect = document.createElement('select');
+            difficultySelect.style.cssText = `
+                margin-bottom: 10px;
+                padding: 5px;
+                background: #444;
+                color: white;
+                border: 1px solid #666;
+                border-radius: 3px;
+            `;
+            const difficulties = ['Easy - Pins Visible', 'Hard - Audio Only'];
+            difficulties.forEach(diff => {
+                const option = document.createElement('option');
+                option.value = diff;
+                option.textContent = diff;
+                difficultySelect.appendChild(option);
+            });
+
+            // Add audio feedback
+            const lockSounds = {
+                click: null,      // Basic pin movement sound
+                binding: null,    // Sound when a pin is binding (correct tension)
+                set: null,        // Sound when a pin is successfully set
+                reset: null,      // Sound when pins are reset
+                wrong: null,      // Sound when wrong tension or wrong pin
+                tension: null,    // Sound when changing tension
+                success: null,    // Sound when successfully picking the lock
+                overTension: null // Sound when over-tensioning the lock
+            };
+
+            const initAudio = () => {
+                if (!lockSounds.click) {
+                    // Basic click sound (when pressing a pin)
+                    lockSounds.click = new Audio('assets/sounds/lockpick_click.mp3');
+                    
+                    // Binding sound (when a pin is binding with correct tension)
+                    lockSounds.binding = new Audio('assets/sounds/lockpick_binding.mp3');
+                    
+                    // Set sound (when a pin is successfully set)
+                    lockSounds.set = new Audio('assets/sounds/lockpick_set.mp3');
+                    
+                    // Reset sound (when pins are reset)
+                    lockSounds.reset = new Audio('assets/sounds/lockpick_reset.mp3');
+                    
+                    // Wrong sound (when using wrong tension or pressing wrong pin)
+                    lockSounds.wrong = new Audio('assets/sounds/lockpick_wrong.mp3');
+                    
+                    // Tension sound (when changing tension levels)
+                    lockSounds.tension = new Audio('assets/sounds/lockpick_tension.mp3');
+                    
+                    // Success sound (when successfully picking the lock)
+                    lockSounds.success = new Audio('assets/sounds/lockpick_success.mp3');
+                    
+                    // Over-tension sound (when applying too much tension)
+                    lockSounds.overTension = new Audio('assets/sounds/lockpick_overtension.mp3');
+                }
+            };
+
+            // Initialize audio on first interaction
+            gameContainer.addEventListener('mousedown', initAudio, { once: true });
+
+            // Add pin binding order and game state
+            const numPins = getPinCountForDifficulty(difficulty);
+            const bindingOrder = Array.from({length: numPins}, (_, i) => i)
+                .sort(() => Math.random() - 0.5);
+            
+            const gameState = {
+                tensionLevel: 1, // Start with light tension instead of none
+                pinStates: Array(numPins).fill(0), // 0 = down, 1 = moving, 2 = set
+                pinPressTime: Array(numPins).fill(0), // Track how long each pin is pressed
+                currentBindingIndex: 0,
+                hardMode: false,
+                maxPressTime: 1000, // Max time to hold a pin (ms)
+                failCount: 0,
+                maxFails: 3,
+                overTensioned: false,
+                lastPinSetTime: 0, // Track when the last pin was set
+                isActivelyPickingPin: false, // Track if we're actively working on a pin
+                tensionRequirements: Array(numPins).fill(0).map(() => {
+                    // Each pin requires a specific tension level (1, 2, or 3)
+                    const randomValue = Math.random();
+                    if (randomValue < 0.33) return 1; // Light tension
+                    if (randomValue < 0.66) return 2; // Medium tension
+                    return 3; // Heavy tension
+                })
+            };
+
+            // Create tension wrench toggle
+            const tensionWrench = document.createElement('div');
+            tensionWrench.style.cssText = `
+                width: 100px;
+                height: 30px;
+                background: ${gameState.tensionLevel === 1 ? '#666' : gameState.tensionLevel === 2 ? '#888' : '#aaa'};
+                border: 2px solid #888;
+                border-radius: 5px;
+                cursor: pointer;
+                margin-bottom: 20px;
+                text-align: center;
+                line-height: 30px;
+                color: white;
+            `;
+            tensionWrench.textContent = 'Tension: OFF';
+
+            // Function to reset pins
+            function resetPins(showVisual = true) {
+                gameState.pinStates.fill(0);
+                gameState.pinPressTime.fill(0);
+                gameState.currentBindingIndex = 0;
+                gameState.failCount++;
+
+                if (showVisual) {
+                    Array.from(pinsContainer.children).forEach(pin => {
+                        pin.style.background = '#555';
+                        if (!gameState.hardMode) {
+                            pin.style.transition = 'background-color 0.3s';
+                            pin.style.background = '#f00';
+                            setTimeout(() => pin.style.background = '#555', 300);
+                        }
+                    });
+                }
+
+                if (gameState.failCount >= gameState.maxFails) {
+                    alert("Lock picking failed! The lock is now jammed.");
+                    // Safely remove iframe if it exists in the document
+                    const existingIframe = document.querySelector('div[style*="z-index: 1000"]');
+                    if (existingIframe && existingIframe.parentNode) {
+                        existingIframe.parentNode.removeChild(existingIframe);
+                    }
+                    if (currentScene && currentScene.input && currentScene.input.mouse) {
+                        currentScene.input.mouse.enabled = true;
+                    }
+                }
+            }
+
+            // Create a single function for toggling tension
+            function toggleTension() {
+                // Toggle between 3 tension levels (light -> medium -> heavy -> light)
+                const previousTensionLevel = gameState.tensionLevel;
+                gameState.tensionLevel = (gameState.tensionLevel % 3) + 1;
+                
+                // Play tension change sound
+                if (lockSounds.tension) {
+                    lockSounds.tension.currentTime = 0;
+                    lockSounds.tension.play().catch(e => console.log('Audio play failed:', e));
+                }
+                
+                updateTensionWrench();
+                
+                // Check if we're over-tensioning - but only if we've started interacting with pins
+                // AND only if we're actively working on a pin (not just changing tension)
+                const timeSinceLastPinSet = Date.now() - gameState.lastPinSetTime;
+                const isActivelyPickingLock = gameState.isActivelyPickingPin;
+                
+                if (gameState.tensionLevel === 3 && 
+                    gameState.currentBindingIndex > 0 && 
+                    timeSinceLastPinSet > 1000 &&
+                    isActivelyPickingLock) {
+                    
+                    // 30% chance of over-tensioning with heavy pressure
+                    if (Math.random() < 0.3) {
+                        gameState.overTensioned = true;
+                        tensionWrench.style.background = '#ff3333';
+                        tensionWrench.style.transform = 'rotate(15deg)';
+                        
+                        // Play over-tension sound
+                        if (lockSounds.overTension) {
+                            lockSounds.overTension.currentTime = 0;
+                            lockSounds.overTension.play().catch(e => console.log('Audio play failed:', e));
+                        }
+                        
+                        setTimeout(() => {
+                            alert("You applied too much tension and jammed the lock!");
+                            resetPins();
+                        }, 500);
+                    }
+                }
+            }
+
+            // Add this new function to update tension wrench visuals
+            function updateTensionWrench() {
+                // Update tension wrench appearance based on level
+                switch(gameState.tensionLevel) {
+                    case 1: // Light
+                        tensionWrench.style.background = '#666';
+                        tensionWrench.style.transform = 'rotate(2deg)';
+                        tensionWrench.textContent = 'Tension: LIGHT';
+                        break;
+                    case 2: // Medium
+                        tensionWrench.style.background = '#888';
+                        tensionWrench.style.transform = 'rotate(5deg)';
+                        tensionWrench.textContent = 'Tension: MEDIUM';
+                        break;
+                    case 3: // Heavy
+                        tensionWrench.style.background = '#aaa';
+                        tensionWrench.style.transform = 'rotate(8deg)';
+                        tensionWrench.textContent = 'Tension: HEAVY';
+                        break;
+                }
+            }
+
+            // Create pins container
+            const pinsContainer = document.createElement('div');
+            pinsContainer.style.cssText = `
+                display: flex;
+                gap: 10px;
+                background: #333;
+                padding: 20px;
+                border-radius: 10px;
+            `;
+
+            // Create individual pins
+            for (let i = 0; i < numPins; i++) {
+                const pin = document.createElement('div');
+                pin.style.cssText = `
+                    width: 30px;
+                    height: 100px;
+                    background: #555;
+                    border: 2px solid #777;
+                    border-radius: 5px;
+                    cursor: pointer;
+                    position: relative;
+                    transition: transform 0.1s, background-color 0.3s;
+                `;
+
+                // Add a subtle indicator at the bottom of each pin
+                const pinIndicator = document.createElement('div');
+                pinIndicator.style.cssText = `
+                    position: absolute;
+                    bottom: 0;
+                    left: 0;
+                    width: 100%;
+                    height: 5px;
+                    background: #555;
+                    transition: background-color 0.3s;
+                `;
+                pin.appendChild(pinIndicator);
+
+                const pinNumber = document.createElement('div');
+                pinNumber.style.cssText = `
+                    position: absolute;
+                    top: -20px;
+                    width: 100%;
+                    text-align: center;
+                    color: white;
+                `;
+                pinNumber.textContent = (i + 1).toString();
+                pin.appendChild(pinNumber);
+
+                // Function to update pin appearance based on its state and binding status
+                function updatePinAppearance() {
+                    // Reset to default first
+                    pin.style.background = '#555';
+                    pinIndicator.style.background = '#555';
+                    pin.style.animation = '';
+                    pin.style.borderColor = '#777';
+                    
+                    // If the pin is set, show it as green
+                    if (gameState.pinStates[i] === 2) {
+                        pin.style.background = '#0f0';
+                        pin.style.cursor = 'default';
+                        pinIndicator.style.background = '#0f0';
+                        return;
+                    }
+                    
+                    // Get the current binding pin
+                    const bindingPin = bindingOrder[gameState.currentBindingIndex];
+                    
+                    // Generate consistent red herrings based on the current binding index
+                    // This ensures the same pins are highlighted as red herrings until the next pin is set
+                    const redHerringSeeds = [
+                        (bindingPin * 3 + 7) % numPins,
+                        (bindingPin * 5 + 3) % numPins
+                    ];
+                    
+                    // Filter out the binding pin and already set pins from red herrings
+                    const redHerrings = redHerringSeeds.filter(index => 
+                        index !== bindingPin && gameState.pinStates[index] !== 2);
+                    
+                    // If this is the current binding pin, give a subtle hint based on difficulty
+                    if (i === bindingPin) {
+                        // For easy difficulty, make the binding pin more obvious
+                        if (difficulty === 'easy') {
+                            pinIndicator.style.background = '#ff9900'; // Orange indicator for binding pin
+                            
+                            // Also show the required tension level with a color hint
+                            const requiredTension = gameState.tensionRequirements[i];
+                            if (requiredTension === 1) {
+                                pin.style.borderColor = '#66ccff'; // Light blue for light tension
+                            } else if (requiredTension === 2) {
+                                pin.style.borderColor = '#9966ff'; // Purple for medium tension
+                            } else {
+                                pin.style.borderColor = '#ff6666'; // Red for heavy tension
+                            }
+                            
+                            // Add a subtle animation
+                            pin.style.animation = 'pinWiggle 2s infinite';
+                        } 
+                        // For medium difficulty, just show which pin is binding with less obvious cues
+                        else if (difficulty === 'medium') {
+                            pinIndicator.style.background = '#ff9900'; // Orange indicator for binding pin
+                            pin.style.animation = 'pinWiggle 3s infinite';
+                        }
+                        // For hard difficulty, very subtle indication
+                        else if (difficulty === 'hard') {
+                            pin.style.animation = 'pinWiggle 4s infinite 0.5s';
+                        }
+                    }
+                    // If this is a red herring, give misleading feedback
+                    else if (redHerrings.includes(i) && gameState.currentBindingIndex > 0 && difficulty !== 'easy') {
+                        // The amount of misleading feedback depends on difficulty
+                        if (difficulty === 'medium') {
+                            // For medium, make red herrings somewhat convincing
+                            pinIndicator.style.background = '#ff9900'; // Same color as real binding pin
+                            pin.style.animation = 'pinWiggle 3.5s infinite 0.7s'; // Similar wiggle to real pin
+                            
+                            // Randomly assign fake tension indicators to confuse
+                            const fakeTension = Math.floor(Math.random() * 3) + 1;
+                            if (fakeTension === 1) {
+                                pin.style.borderColor = '#66ccff';
+                            } else if (fakeTension === 2) {
+                                pin.style.borderColor = '#9966ff';
+                            } else {
+                                pin.style.borderColor = '#ff6666';
+                            }
+                        }
+                        else if (difficulty === 'hard') {
+                            // For hard, make red herrings very convincing
+                            pin.style.animation = 'pinWiggle 4s infinite 0.3s';
+                            
+                            // On hard, sometimes make a red herring more convincing than the real pin
+                            if (Math.random() < 0.5) {
+                                pinIndicator.style.background = '#ff9900';
+                            }
+                        }
+                    }
+                }
+
+                // Add the wiggle animation to the document
+                if (!document.getElementById('pinWiggleAnimation')) {
+                    const style = document.createElement('style');
+                    style.id = 'pinWiggleAnimation';
+                    style.textContent = `
+                        @keyframes pinWiggle {
+                            0% { transform: translateY(0); }
+                            15% { transform: translateY(-2px); }
+                            30% { transform: translateY(0); }
+                            45% { transform: translateY(-1px); }
+                            60% { transform: translateY(0); }
+                            75% { transform: translateY(-0.5px); }
+                            100% { transform: translateY(0); }
+                        }
+                    `;
+                    document.head.appendChild(style);
+                }
+
+                // Update all pins whenever a pin state changes
+                function updateAllPins() {
+                    // Get the current binding pin
+                    const bindingPin = bindingOrder[gameState.currentBindingIndex];
+                    
+                    // Generate consistent red herrings based on the current binding index
+                    const redHerringSeeds = [
+                        (bindingPin * 3 + 7) % numPins,
+                        (bindingPin * 5 + 3) % numPins
+                    ];
+                    
+                    // Filter out the binding pin and already set pins from red herrings
+                    const redHerrings = redHerringSeeds.filter(index => 
+                        index !== bindingPin && gameState.pinStates[index] !== 2);
+                    
+                    Array.from(pinsContainer.children).forEach((pin, index) => {
+                        // Find the indicator within this pin
+                        const indicator = pin.querySelector('div:first-child');
+                        
+                        // Reset styles first
+                        pin.style.background = '#555';
+                        pin.style.animation = '';
+                        pin.style.borderColor = '#777';
+                        if (indicator) indicator.style.background = '#555';
+                        
+                        // Update based on current game state
+                        if (gameState.pinStates[index] === 2) {
+                            pin.style.background = '#0f0';
+                            pin.style.cursor = 'default';
+                            if (indicator) indicator.style.background = '#0f0';
+                        } else {
+                            pin.style.cursor = 'pointer';
+                            
+                            // Check if this is the binding pin
+                            if (index === bindingPin && !gameState.hardMode) {
+                                if (difficulty === 'easy') {
+                                    if (indicator) indicator.style.background = '#ff9900';
+                                    
+                                    // Show tension hint
+                                    const requiredTension = gameState.tensionRequirements[index];
+                                    if (requiredTension === 1) {
+                                        pin.style.borderColor = '#66ccff';
+                                    } else if (requiredTension === 2) {
+                                        pin.style.borderColor = '#9966ff';
+                                    } else {
+                                        pin.style.borderColor = '#ff6666';
+                                    }
+                                    
+                                    pin.style.animation = 'pinWiggle 2s infinite';
+                                } 
+                                else if (difficulty === 'medium') {
+                                    if (indicator) indicator.style.background = '#ff9900';
+                                    pin.style.animation = 'pinWiggle 3s infinite';
+                                }
+                                else if (difficulty === 'hard') {
+                                    pin.style.animation = 'pinWiggle 4s infinite 0.5s';
+                                }
+                            }
+                            // Check if this is a red herring, but only for medium and hard difficulties
+                            else if (redHerrings.includes(index) && gameState.currentBindingIndex > 0 && difficulty !== 'easy') {
+                                if (difficulty === 'medium') {
+                                    if (indicator) indicator.style.background = '#ff9900';
+                                    pin.style.animation = 'pinWiggle 3.5s infinite 0.7s';
+                                    
+                                    const fakeTension = Math.floor(Math.random() * 3) + 1;
+                                    if (fakeTension === 1) {
+                                        pin.style.borderColor = '#66ccff';
+                                    } else if (fakeTension === 2) {
+                                        pin.style.borderColor = '#9966ff';
+                                    } else {
+                                        pin.style.borderColor = '#ff6666';
+                                    }
+                                }
+                                else if (difficulty === 'hard') {
+                                    pin.style.animation = 'pinWiggle 4s infinite 0.3s';
+                                    if (Math.random() < 0.5 && indicator) {
+                                        indicator.style.background = '#ff9900';
+                                    }
+                                }
+                            }
+                        }
+                    });
+                }
+
+                // Call updatePinAppearance initially and whenever the game state changes
+                updatePinAppearance();
+
+                let pressStartTime = 0;
+                let pressTimer = null;
+
+                function checkPinPress() {
+                    if (pressStartTime === 0) return;
+                    
+                    const pressDuration = Date.now() - pressStartTime;
+                    if (pressDuration > gameState.maxPressTime) {
+                        // Clear the timer first before calling resetPins
+                        clearInterval(pressTimer);
+                        pressTimer = null;
+                        resetPins();
+                    }
+                }
+
+                pin.onmousedown = () => {
+                    // First check if this pin is already set
+                    const pinIndex = Array.from(pinsContainer.children).indexOf(pin);
+                    if (gameState.pinStates[pinIndex] === 2) {
+                        // Pin is already set, don't allow interaction
+                        return;
+                    }
+                    
+                    // Set the flag to indicate we're actively picking a pin
+                    gameState.isActivelyPickingPin = true;
+                    
+                    // Play basic click sound
+                    if (lockSounds.click) {
+                        lockSounds.click.currentTime = 0;
+                        lockSounds.click.play().catch(e => console.log('Audio play failed:', e));
+                    }
+                    
+                    pressStartTime = Date.now();
+                    pressTimer = setInterval(checkPinPress, 100);
+                    
+                    pin.style.transform = 'translateY(-10px)';
+                    
+                    // Each pin has different tension requirements
+                    const bindingPin = bindingOrder[gameState.currentBindingIndex];
+                    const requiredTension = gameState.tensionRequirements[pinIndex];
+                    
+                    // Check if this is the current binding pin
+                    if (pinIndex === bindingPin) {
+                        // This pin needs exactly the right tension level
+                        const correctTension = (gameState.tensionLevel === requiredTension);
+                        
+                        if (correctTension && !gameState.overTensioned) {
+                            // Play binding sound - correct pin with correct tension
+                            if (lockSounds.binding) {
+                                lockSounds.binding.currentTime = 0;
+                                lockSounds.binding.play().catch(e => console.log('Audio play failed:', e));
+                            }
+                            
+                            if (!gameState.hardMode) {
+                                pin.style.background = '#00f';
+                            }
+                            
+                            // Start a timer to set the pin
+                            setTimeout(() => {
+                                if (pressStartTime !== 0) { // Still pressing
+                                    // Double-check tension is still correct
+                                    const stillCorrectTension = (gameState.tensionLevel === requiredTension);
+                                    
+                                    if (stillCorrectTension && !gameState.overTensioned) {
+                                        gameState.pinStates[pinIndex] = 2;
+                                        gameState.currentBindingIndex++;
+                                        gameState.lastPinSetTime = Date.now();
+                                        
+                                        // Play set sound - pin successfully set
+                                        if (lockSounds.set) {
+                                            lockSounds.set.currentTime = 0;
+                                            lockSounds.set.play().catch(e => console.log('Audio play failed:', e));
+                                        }
+                                        
+                                        if (!gameState.hardMode) {
+                                            pin.style.background = '#0f0';
+                                            pinIndicator.style.background = '#0f0';
+                                        }
+                                        
+                                        // Update all pins to show new binding state
+                                        updateAllPins();
+                                        
+                                        checkWinCondition();
+                                    }
+                                }
+                            }, 500);
+                        } else if (gameState.tensionLevel > 0) {
+                            // Wrong tension but trying - give feedback
+                            // Play wrong sound - wrong tension on correct pin
+                            if (lockSounds.wrong) {
+                                lockSounds.wrong.currentTime = 0;
+                                lockSounds.wrong.play().catch(e => console.log('Audio play failed:', e));
+                            }
+                            
+                            if (!gameState.hardMode) {
+                                pin.style.background = '#00f';
+                            }
+                            
+                            // Start counting towards potential reset
+                            gameState.pinPressTime[pinIndex] = Date.now();
+                        }
+                    } else if (gameState.tensionLevel > 0 && gameState.pinStates[pinIndex] !== 2) {
+                        // Wrong pin - give feedback
+                        if (lockSounds.wrong) {
+                            lockSounds.wrong.currentTime = 0;
+                            lockSounds.wrong.play().catch(e => console.log('Audio play failed:', e));
+                        }
+                        
+                        if (!gameState.hardMode) {
+                            pin.style.background = '#00f';
+                        }
+                        // Start counting towards potential reset
+                        gameState.pinPressTime[pinIndex] = Date.now();
+                    }
+                };
+
+                pin.onmouseup = pin.onmouseleave = () => {
+                    // Clear the flag to indicate we're no longer actively picking a pin
+                    gameState.isActivelyPickingPin = false;
+                    
+                    pressStartTime = 0;
+                    if (pressTimer) {
+                        clearInterval(pressTimer);
+                        pressTimer = null;
+                    }
+                    
+                    pin.style.transform = 'translateY(0)';
+                    if (gameState.pinStates[i] !== 2) {
+                        pin.style.background = '#555';
+                        // Update appearance to show binding status
+                        updatePinAppearance();
+                    }
+                };
+
+                pinsContainer.appendChild(pin);
+            }
+
+            difficultySelect.onchange = () => {
+                gameState.hardMode = difficultySelect.value.includes('Hard');
+                Array.from(pinsContainer.children).forEach(pin => {
+                    pin.style.opacity = gameState.hardMode ? '0.1' : '1';
+                });
+            };
+
+            // Add components to game container
+            gameContainer.appendChild(difficultySelect);
+            gameContainer.appendChild(tensionWrench);
+            gameContainer.appendChild(pinsContainer);
+
+            // Add close button
+            const closeButton = document.createElement('button');
+            closeButton.textContent = 'X';
+            closeButton.style.cssText = `
+                position: absolute;
+                right: 10px;
+                top: 10px;
+                background: none;
+                border: none;
+                color: white;
+                font-size: 20px;
+                cursor: pointer;
+            `;
+            closeButton.onclick = () => {
+                document.body.removeChild(iframe);
+                if (currentScene && currentScene.input && currentScene.input.mouse) {
+                    currentScene.input.mouse.enabled = true;
+                }
+            };
+
+            // Assemble the interface
+            iframe.appendChild(closeButton);
+            iframe.appendChild(instructions);
+            iframe.appendChild(gameContainer);
+            document.body.appendChild(iframe);
+            
+            // Disable game movement
+            if (currentScene && currentScene.input && currentScene.input.mouse) {
+                currentScene.input.mouse.enabled = false;
+            }
+
+            // Add this function before the pin creation loop
+            function checkWinCondition() {
+                if (gameState.currentBindingIndex >= numPins) {
+                    // Play success sound
+                    if (lockSounds.success) {
+                        lockSounds.success.currentTime = 0;
+                        lockSounds.success.play().catch(e => console.log('Audio play failed:', e));
+                    }
+                    
+                    console.log('Lock picked successfully:', lockable);
+                    
+                    // Create success message
+                    const successMessage = document.createElement('div');
+                    successMessage.style.cssText = `
+                        position: absolute;
+                        top: 50%;
+                        left: 50%;
+                        transform: translate(-50%, -50%);
+                        background: rgba(0, 0, 0, 0.8);
+                        color: #0f0;
+                        padding: 20px;
+                        border-radius: 10px;
+                        font-size: 24px;
+                        text-align: center;
+                        z-index: 1002;
+                    `;
+                    successMessage.textContent = "Lock successfully picked!";
+                    iframe.appendChild(successMessage);
+                    
+                    // Disable further interaction
+                    gameContainer.style.pointerEvents = 'none';
+                    
+                    setTimeout(() => {
+                        // For doors, we need to check properties and handle differently
+                        if (lockable && lockable.properties && lockable.properties.locked) {
+                            console.log('Unlocking door tile:', lockable);
+                            unlockDoor(lockable, lockable.layer);
+                        } 
+                        // For containers and other lockable items
+                        else if (lockable && lockable.scenarioData) {
+                            console.log('Unlocking container:', lockable.scenarioData);
+                            lockable.scenarioData.locked = false;
+                            
+                            // Set the flag to indicate the container is unlocked but contents not collected
+                            if (lockable.scenarioData.contents && lockable.scenarioData.contents.length > 0) {
+                                lockable.scenarioData.isUnlockedButNotCollected = true;
+                                debugLog('Container unlocked and ready for collection', lockable.scenarioData, 1);
+                            }
+                        }
+                        
+                        // Remove the minigame
+                        document.body.removeChild(iframe);
+                        if (currentScene && currentScene.input && currentScene.input.mouse) {
+                            currentScene.input.mouse.enabled = true;
+                        }
+                    }, 1500);
+                    
+                    return true;
+                }
+                return false;
+            }
+
+            // Use the toggleTension function for both click and keyboard events
+            tensionWrench.onclick = toggleTension;
+
+            document.addEventListener('keydown', function(event) {
+                // Only process if the lockpicking minigame is active
+                if (!document.querySelector('div[style*="z-index: 1000"]')) return;
+                
+                if (event.code === 'Space') {
+                    event.preventDefault(); // Prevent page scrolling
+                    toggleTension();
+                }
+            });
+
+            // Keep only the table debug function
+            function logTensionDebugInfo() {
+                // Only show debug info if debug mode is enabled
+                if (!DEBUG_MODE.enabled) return;
+                
+                DEBUG_MODE.log("=== LOCKPICKING DEBUG INFO ===");
+                DEBUG_MODE.log("Pin binding order and tension requirements:");
+                
+                const tableData = [];
+                
+                for (let orderIndex = 0; orderIndex < numPins; orderIndex++) {
+                    const pinIndex = bindingOrder[orderIndex];
+                    const requiredTension = gameState.tensionRequirements[pinIndex];
+                    let tensionNeeded;
+                    
+                    switch(requiredTension) {
+                        case 1: tensionNeeded = 'Light'; break;
+                        case 2: tensionNeeded = 'Medium'; break;
+                        case 3: tensionNeeded = 'Heavy'; break;
+                        default: tensionNeeded = 'Unknown';
+                    }
+                    
+                    tableData.push({
+                        'Binding Order': orderIndex + 1,
+                        'Pin #': pinIndex + 1,
+                        'Tension Required': tensionNeeded
+                    });
+                }
+                
+                console.table(tableData);
+            }
+
+            // Call this function instead of addTensionDebugDisplay
+            logTensionDebugInfo();
+        }
+
+        // Add this function to get pin count based on difficulty
+        function getPinCountForDifficulty(difficulty) {
+            switch(difficulty?.toLowerCase()) {
+                case 'easy':
+                    return 3;
+                case 'medium':
+                    return 5;
+                case 'hard':
+                    return 7;
+                default:
+                    return 5; // Default to medium difficulty
+            }
+        }
+
+        // removes an item from the inventory
+        function removeFromInventory(sprite) {
+            if (!sprite || !inventory.items) {
+                return false;
+            }
+            
+            try {
+                // Find the index of the sprite in the inventory
+                const index = inventory.items.indexOf(sprite);
+                
+                if (index === -1) {
+                    return false; // Item not found in inventory
+                }
+                
+                // Remove from container
+                inventory.container.remove(sprite);
+                
+                // Remove from items array
+                inventory.items.splice(index, 1);
+                
+                // Destroy the sprite
+                sprite.destroy();
+                
+                // Rearrange remaining items
+                rearrangeInventoryItems();
+                
+                // Log the removal
+                debugLog('INVENTORY ITEM REMOVED', {
+                    name: sprite.name,
+                    totalItems: inventory.items.length
+                }, 2);
+                
+                return true;
+            } catch (error) {
+                console.error('Error removing item from inventory:', error);
+                return false;
+            }
+        }
+        
+        // Rearrange inventory items after removal
+        function rearrangeInventoryItems() {
+            inventory.items.forEach((item, index) => {
+                item.x = index * 60 + 100;
+            });
+        }
+
+        // Bluetooth scanner system
+        const bluetoothDevices = [];
+        let newBluetoothDevices = 0;
+        
+        // Add a Bluetooth device to the scanner panel
+        function addBluetoothDevice(name, mac, details = "", nearby = true) {
+            // Check if a device with the same MAC already exists
+            const deviceExists = bluetoothDevices.some(device => device.mac === mac);
+            
+            // If the device already exists, update its nearby status
+            if (deviceExists) {
+                const existingDevice = bluetoothDevices.find(device => device.mac === mac);
+                existingDevice.nearby = nearby;
+                existingDevice.lastSeen = new Date();
+                updateBluetoothPanel();
+                return null;
+            }
+            
+            const device = {
+                id: Date.now(),
+                name: name,
+                mac: mac,
+                details: details,
+                nearby: nearby,
+                saved: false,
+                firstSeen: new Date(),
+                lastSeen: new Date()
+            };
+            
+            bluetoothDevices.push(device);
+            updateBluetoothPanel();
+            updateBluetoothCount();
+            
+            // Show notification for new device
+            showNotification(`New Bluetooth device detected: ${name}`, 'info', 'Bluetooth Scanner', 3000);
+            
+            return device;
+        }
+        
+        // Update the Bluetooth scanner panel with current devices
+        function updateBluetoothPanel() {
+            const bluetoothContent = document.getElementById('bluetooth-content');
+            const searchTerm = document.getElementById('bluetooth-search')?.value?.toLowerCase() || '';
+            
+            // Get active category
+            const activeCategory = document.querySelector('.bluetooth-category.active')?.dataset.category || 'all';
+            
+            // Store the currently hovered device, if any
+            const hoveredDevice = document.querySelector('.bluetooth-device:hover');
+            const hoveredDeviceId = hoveredDevice ? hoveredDevice.dataset.id : null;
+            
+            // Add Bluetooth-locked items from inventory to the main bluetoothDevices array
+            inventory.items.forEach(item => {
+                if (item.scenarioData?.lockType === "bluetooth" && item.scenarioData?.locked) {
+                    // Check if this device is already in our list
+                    const deviceMac = item.scenarioData?.mac || "Unknown";
+                    
+                    // Normalize MAC address format (ensure lowercase for comparison)
+                    const normalizedMac = deviceMac.toLowerCase();
+                    
+                    // Check if device already exists in our list
+                    const existingDeviceIndex = bluetoothDevices.findIndex(device => 
+                        device.mac.toLowerCase() === normalizedMac
+                    );
+                    
+                    if (existingDeviceIndex === -1) {
+                        // Add as a new device
+                        const deviceName = item.scenarioData?.name || item.name || "Unknown Device";
+                        const details = `Type: ${item.scenarioData?.type || "Unknown"}\nLocation: Inventory\nStatus: Locked`;
+                        
+                        const newDevice = {
+                            id: `inv_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                            name: deviceName,
+                            mac: deviceMac,
+                            details: details,
+                            lastSeen: new Date(),
+                            nearby: true, // Always nearby since it's in inventory
+                            saved: true,  // Auto-save inventory items
+                            signalStrength: 100, // Max strength for inventory items
+                            inInventory: true // Mark as inventory item
+                        };
+                        
+                        // Add to the main bluetoothDevices array
+                        bluetoothDevices.push(newDevice);
+                        console.log('Added inventory device to bluetoothDevices:', newDevice);
+                    } else {
+                        // Update existing device
+                        const existingDevice = bluetoothDevices[existingDeviceIndex];
+                        existingDevice.inInventory = true;
+                        existingDevice.nearby = true;
+                        existingDevice.signalStrength = 100;
+                        existingDevice.lastSeen = new Date();
+                        existingDevice.details = `Type: ${item.scenarioData?.type || "Unknown"}\nLocation: Inventory\nStatus: Locked`;
+                        console.log('Updated existing device with inventory info:', existingDevice);
+                    }
+                }
+            });
+            
+            // Filter devices based on search and category
+            let filteredDevices = [...bluetoothDevices];
+            
+            // Apply category filter
+            if (activeCategory === 'nearby') {
+                filteredDevices = filteredDevices.filter(device => device.nearby);
+            } else if (activeCategory === 'saved') {
+                filteredDevices = filteredDevices.filter(device => device.saved);
+            }
+            
+            // Apply search filter
+            if (searchTerm) {
+                filteredDevices = filteredDevices.filter(device => 
+                    device.name.toLowerCase().includes(searchTerm) || 
+                    device.mac.toLowerCase().includes(searchTerm) ||
+                    device.details.toLowerCase().includes(searchTerm)
+                );
+            }
+            
+            // Sort devices with nearby ones first, then by signal strength (highest first for nearby), then by last seen (newest first)
+            filteredDevices.sort((a, b) => {
+                // Inventory items first
+                if (a.inInventory !== b.inInventory) {
+                    return a.inInventory ? -1 : 1;
+                }
+                
+                // Then nearby items
+                if (a.nearby !== b.nearby) {
+                    return a.nearby ? -1 : 1;
+                }
+                
+                // For nearby devices, sort by signal strength
+                if (a.nearby && b.nearby && a.signalStrength !== b.signalStrength) {
+                    return b.signalStrength - a.signalStrength;
+                }
+                
+                return new Date(b.lastSeen) - new Date(a.lastSeen);
+            });
+            
+            // Clear current content
+            bluetoothContent.innerHTML = '';
+            
+            // Add devices
+            if (filteredDevices.length === 0) {
+                if (searchTerm) {
+                    bluetoothContent.innerHTML = '<div class="bluetooth-device">No devices match your search.</div>';
+                } else if (activeCategory !== 'all') {
+                    bluetoothContent.innerHTML = `<div class="bluetooth-device">No ${activeCategory} devices found.</div>`;
+                } else {
+                    bluetoothContent.innerHTML = '<div class="bluetooth-device">No devices detected yet.</div>';
+                }
+            } else {
+                filteredDevices.forEach(device => {
+                    const deviceElement = document.createElement('div');
+                    deviceElement.className = 'bluetooth-device';
+                    deviceElement.dataset.id = device.id;
+                    
+                    // If this was the hovered device, add the hover class
+                    if (hoveredDeviceId && device.id === hoveredDeviceId) {
+                        deviceElement.classList.add('hover-preserved');
+                    }
+                    
+                    // Format the timestamp
+                    const timestamp = new Date(device.lastSeen);
+                    const formattedDate = timestamp.toLocaleDateString();
+                    const formattedTime = timestamp.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+                    
+                    // Get signal color based on strength
+                    const getSignalColor = (strength) => {
+                        if (strength >= 80) return '#00cc00'; // Strong - green
+                        if (strength >= 50) return '#cccc00'; // Medium - yellow
+                        return '#cc5500'; // Weak - orange
+                    };
+                    
+                    let deviceContent = `<div class="bluetooth-device-name">
+                        <span>${device.name}</span>
+                        <div class="bluetooth-device-icons">`;
+                    
+                    if (device.nearby && typeof device.signalStrength === 'number') {
+                        const signalColor = getSignalColor(device.signalStrength);
+                        
+                        // Calculate how many bars should be active based on signal strength
+                        const activeBars = Math.ceil(device.signalStrength / 20); // 0-20% = 1 bar, 21-40% = 2 bars, etc.
+                        
+                        deviceContent += `<div class="bluetooth-signal-bar-container">
+                            <div class="bluetooth-signal-bars">`;
+                        
+                        for (let i = 1; i <= 5; i++) {
+                            const isActive = i <= activeBars;
+                            deviceContent += `<div class="bluetooth-signal-bar ${isActive ? 'active' : ''}" style="color: ${signalColor};"></div>`;
+                        }
+                        
+                        deviceContent += `</div></div>`;
+                    } else if (device.nearby) {
+                        // Fallback if signal strength not available
+                        deviceContent += `<span class="bluetooth-device-icon">📶</span>`;
+                    }
+
+                    if (device.saved) {
+                        deviceContent += `<span class="bluetooth-device-icon">💾</span>`;
+                    }
+                    
+                    if (device.inInventory) {
+                        deviceContent += `<span class="bluetooth-device-icon">🎒</span>`;
+                    }
+
+                    deviceContent += `</div></div>`;
+                    deviceContent += `<div class="bluetooth-device-details">MAC: ${device.mac}\n${device.details}</div>`;
+
+                    // Add pairing button only if device is nearby and player has a Bluetooth spoofer
+                    if (device.nearby) {
+                        // Check if player has a Bluetooth spoofer in inventory
+                        const spoofer = inventory.items.find(item => 
+                            item.scenarioData?.type === "bluetooth_spoofer"
+                        );
+                        
+                        if (spoofer) {
+                            // Check if this device is already paired with (MAC address programmed to spoofer)
+                            const isPaired = spoofer.scenarioData?.macPaired === device.mac;
+                            const buttonClass = isPaired ? 'bluetooth-pair-button paired' : 'bluetooth-pair-button';
+                            const buttonText = isPaired ? 'MAC Address Paired' : 'Pair MAC Address';
+                            
+                            deviceContent += `<button class="${buttonClass}" data-mac="${device.mac}">${buttonText}</button>`;
+                            
+                            // If device is paired, add a hint about using it to unlock
+                            if (isPaired) {
+                                deviceContent += `<div style="font-size: 11px; color: #27ae60; margin-top: 4px;">
+                                    You can now use this MAC address to unlock matching Bluetooth locks
+                                </div>`;
+                                
+                                // If this is an inventory item, add an unlock button
+                                if (device.inInventory) {
+                                    deviceContent += `<button class="bluetooth-unlock-button" data-mac="${device.mac}">Unlock Device</button>`;
+                                }
+                            }
+                        }
+                    }
+
+                    deviceContent += `<div class="bluetooth-device-timestamp">Last seen: ${formattedDate} ${formattedTime}</div>`;
+
+                    deviceElement.innerHTML = deviceContent;
+                    
+                    // Toggle expanded state when clicked
+                    deviceElement.addEventListener('click', (event) => {
+                        // Don't toggle if clicking on the pair button
+                        if (event.target.classList.contains('bluetooth-pair-button') || 
+                            event.target.closest('.bluetooth-pair-button')) {
+                            return;
+                        }
+                        
+                        deviceElement.classList.toggle('expanded');
+                        
+                        // Mark as saved when expanded
+                        if (!device.saved && deviceElement.classList.contains('expanded')) {
+                            device.saved = true;
+                            updateBluetoothCount();
+                            updateBluetoothPanel();
+                        }
+                    });
+                    
+                    bluetoothContent.appendChild(deviceElement);
+                });
+            }
+        }
+        
+        // Update the new Bluetooth devices count
+        function updateBluetoothCount() {
+            const bluetoothCount = document.getElementById('bluetooth-count');
+            newBluetoothDevices = bluetoothDevices.filter(device => !device.saved && device.nearby).length;
+            
+            bluetoothCount.textContent = newBluetoothDevices;
+            bluetoothCount.style.display = newBluetoothDevices > 0 ? 'flex' : 'none';
+        }
+        
+        // Toggle the Bluetooth scanner panel
+        function toggleBluetoothPanel() {
+            const bluetoothPanel = document.getElementById('bluetooth-panel');
+            const isVisible = bluetoothPanel.style.display === 'block';
+            
+            bluetoothPanel.style.display = isVisible ? 'none' : 'block';
+        }
+        
+        // Initialize Bluetooth scanner panel
+        function initializeBluetoothPanel() {
+            // Set up Bluetooth toggle button
+            const bluetoothToggle = document.getElementById('bluetooth-toggle');
+            bluetoothToggle.addEventListener('click', toggleBluetoothPanel);
+            
+            // Set up Bluetooth close button
+            const bluetoothClose = document.getElementById('bluetooth-close');
+            bluetoothClose.addEventListener('click', toggleBluetoothPanel);
+            
+            // Set up search functionality
+            const bluetoothSearch = document.getElementById('bluetooth-search');
+            bluetoothSearch.addEventListener('input', updateBluetoothPanel);
+            
+            // Set up category filters
+            const categories = document.querySelectorAll('.bluetooth-category');
+            categories.forEach(category => {
+                category.addEventListener('click', () => {
+                    // Remove active class from all categories
+                    categories.forEach(c => c.classList.remove('active'));
+                    // Add active class to clicked category
+                    category.classList.add('active');
+                    // Update Bluetooth panel
+                    updateBluetoothPanel();
+                });
+            });
+            
+            // Set up global event delegation for the pairing buttons
+            document.addEventListener('click', function(event) {
+                if (event.target.classList.contains('bluetooth-pair-button')) {
+                    const mac = event.target.dataset.mac;
+                    console.log('Attempting to pair with device MAC:', mac);
+                    
+                    // Find the device in our list
+                    const device = bluetoothDevices.find(device => device.mac === mac);
+                    console.log('Found device:', device);
+                    
+                    if (device) {
+                        attemptPairingWithDevice(mac);
+                    } else {
+                        gameAlert("Device not found in Bluetooth devices list.", 'error', 'Pairing Failed', 3000);
+                    }
+                    
+                    event.stopPropagation(); // Prevent device expanding/collapsing when clicking the button
+                }
+                
+                // Handle unlock button clicks
+                if (event.target.classList.contains('bluetooth-unlock-button')) {
+                    const mac = event.target.dataset.mac;
+                    console.log('Attempting to unlock device MAC:', mac);
+                    
+                    // Find the inventory item with this MAC address
+                    const item = inventory.items.find(item => 
+                        item.scenarioData?.mac === mac && 
+                        item.scenarioData?.lockType === "bluetooth" && 
+                        item.scenarioData?.locked
+                    );
+                    console.log('Found inventory item:', item);
+                    
+                    if (item) {
+                        unlockInventoryDeviceByMac(mac);
+                    } else {
+                        gameAlert("Device not found in inventory.", 'error', 'Unlock Failed', 3000);
+                    }
+                    
+                    event.stopPropagation(); // Prevent device expanding/collapsing when clicking the button
+                }
+            });
+            
+            // Initialize Bluetooth count
+            updateBluetoothCount();
+        }
+        
+        // Function to unlock a Bluetooth-locked inventory item by MAC address
+        function unlockInventoryDeviceByMac(mac) {
+            console.log('Attempting to unlock inventory device with MAC:', mac);
+            
+            // Normalize MAC address for comparison
+            const normalizedMac = mac.toLowerCase();
+            
+            // Find the inventory item with this MAC address
+            const item = inventory.items.find(item => 
+                item.scenarioData?.mac?.toLowerCase() === normalizedMac && 
+                item.scenarioData?.lockType === "bluetooth" && 
+                item.scenarioData?.locked
+            );
+            
+            if (!item) {
+                console.error('Inventory item not found with MAC:', mac);
+                gameAlert("Device not found in inventory.", 'error', 'Unlock Failed', 3000);
+                return;
+            }
+            
+            console.log('Found inventory item to unlock:', item);
+            
+            // Attempt to spoof the device
+            const success = spoofBluetoothDevice(item);
+            
+            // If successful, remove the device from the bluetoothDevices array
+            if (success) {
+                // Find the device in the bluetoothDevices array
+                const deviceIndex = bluetoothDevices.findIndex(device => 
+                    device.mac.toLowerCase() === normalizedMac && device.inInventory
+                );
+                
+                // Remove it if found
+                if (deviceIndex !== -1) {
+                    console.log('Removing unlocked device from bluetoothDevices array');
+                    bluetoothDevices.splice(deviceIndex, 1);
+                    
+                    // Update the Bluetooth panel to reflect the changes
+                    updateBluetoothPanel();
+                }
+            }
+        }
+
+        // Function to handle pairing attempts with Bluetooth devices
+        function attemptPairingWithDevice(mac) {
+            console.log('Attempting to pair with MAC:', mac);
+            console.log('All Bluetooth devices:', bluetoothDevices);
+            
+            // Find the device in our list (case-insensitive comparison)
+            const normalizedMac = mac.toLowerCase();
+            const device = bluetoothDevices.find(device => device.mac.toLowerCase() === normalizedMac);
+            
+            if (!device) {
+                console.error('Device not found with MAC:', mac);
+                gameAlert("Device not found.", 'error', 'Pairing Failed', 3000);
+                return;
+            }
+            
+            console.log('Found device for pairing:', device);
+            
+            // Find spoofer in inventory
+            const spoofer = inventory.items.find(item => 
+                item.scenarioData?.type === "bluetooth_spoofer"
+            );
+            
+            if (!spoofer) {
+                gameAlert("You need a Bluetooth spoofer to pair with this device.", 'warning', 'Spoofer Required', 3000);
+                return;
+            }
+            
+            // Check if player is close enough to the device (using the proximity from real-time scanning)
+            // Skip proximity check for inventory items
+            if (!device.nearby && !device.inInventory) {
+                gameAlert("You need to be closer to the device to pair with it.", 'warning', 'Too Far', 3000);
+                return;
+            }
+            
+            // Check if this device is already paired with
+            if (spoofer.scenarioData?.macPaired && spoofer.scenarioData.macPaired.toLowerCase() === normalizedMac) {
+                gameAlert(`This device's MAC address (${mac}) is already programmed into your spoofer.`, 'info', 'Already Paired', 3000);
+                return;
+            }
+            
+            // Launch the MAC address pairing minigame
+            startBluetoothPairingMinigame(device);
+        }
+
+        // Bluetooth MAC Address Pairing Minigame
+        function startBluetoothPairingMinigame(device) {
+            // Create minigame container
+            const minigameContainer = document.createElement('div');
+            minigameContainer.style.cssText = `
+                position: fixed;
+                top: 50%;
+                left: 50%;
+                transform: translate(-50%, -50%);
+                width: 60%;
+                height: 60%;
+                background: rgba(0, 0, 0, 0.9);
+                border: 1px solid #444;
+                z-index: 1000;
+                padding: 20px;
+                border-radius: 5px;
+                display: flex;
+                flex-direction: column;
+                align-items: center;
+            `;
+            
+            // Add instructions
+            const instructions = document.createElement('div');
+            instructions.innerHTML = `
+                <h3 style="margin: 0; color: #fff; text-align: center;">MAC Address Spoofing</h3>
+                <p style="margin: 5px 0; color: #ccc; text-align: center; font-size: 14px;">
+                    Align the signal frequencies to match the target device's MAC address pattern.<br>
+                    Drag the sliders to adjust each frequency band until all segments turn green.<br>
+                    When all segments are aligned, the MAC address will be successfully paired.
+                </p>
+            `;
+            instructions.style.cssText = `
+                position: absolute;
+                top: 10px;
+                left: 50%;
+                transform: translateX(-50%);
+                width: 90%;
+            `;
+
+            // Create device info display
+            const deviceInfo = document.createElement('div');
+            deviceInfo.innerHTML = `
+                <div style="color: #9b59b6; font-weight: bold; margin-bottom: 5px;">Target Device: ${device.name}</div>
+                <div style="color: #aaa; font-size: 12px;">MAC Address: ${device.mac}</div>
+            `;
+            deviceInfo.style.cssText = `
+                margin-top: 70px;
+                text-align: center;
+                width: 100%;
+            `;
+
+            // Create signal visualization
+            const signalVisualization = document.createElement('div');
+            signalVisualization.style.cssText = `
+                width: 90%;
+                height: 120px;
+                background: #111;
+                border: 1px solid #333;
+                margin: 20px 0;
+                position: relative;
+                overflow: hidden;
+            `;
+
+            // Create frequency bands (6 for MAC address octets)
+            const frequencyBands = document.createElement('div');
+            frequencyBands.style.cssText = `
+                display: flex;
+                width: 90%;
+                justify-content: space-between;
+                margin-bottom: 30px;
+            `;
+
+            // Create sliders for each frequency band
+            const sliders = [];
+            const targetValues = [];
+            const currentValues = [];
+            const segments = [];
+            
+            // Parse MAC address to generate target values
+            const macParts = device.mac.split(':');
+            
+            for (let i = 0; i < 6; i++) {
+                // Convert hex to decimal for target value (0-100 range)
+                const hexValue = macParts[i] || '00';
+                const decimalValue = parseInt(hexValue, 16);
+                const targetValue = Math.round((decimalValue / 255) * 100);
+                targetValues.push(targetValue);
+                
+                // Start with random values
+                const initialValue = Math.floor(Math.random() * 100);
+                currentValues.push(initialValue);
+                
+                // Create slider container
+                const sliderContainer = document.createElement('div');
+                sliderContainer.style.cssText = `
+                    display: flex;
+                    flex-direction: column;
+                    align-items: center;
+                    width: 40px;
+                `;
+                
+                // Create slider
+                const slider = document.createElement('input');
+                slider.type = 'range';
+                slider.min = 0;
+                slider.max = 100;
+                slider.value = initialValue;
+                slider.style.cssText = `
+                    width: 120px;
+                    transform: rotate(-90deg);
+                    margin: 50px 0;
+                `;
+                
+                // Create segment in visualization
+                const segment = document.createElement('div');
+                segment.style.cssText = `
+                    position: absolute;
+                    bottom: 0;
+                    left: ${i * (100/6)}%;
+                    width: ${100/6}%;
+                    height: ${initialValue}%;
+                    background: #cc5500;
+                    transition: height 0.2s, background-color 0.3s;
+                `;
+                segments.push(segment);
+                signalVisualization.appendChild(segment);
+                
+                // Create label
+                const label = document.createElement('div');
+                label.textContent = hexValue.toUpperCase();
+                label.style.cssText = `
+                    color: #aaa;
+                    font-size: 12px;
+                    margin-top: 10px;
+                `;
+                
+                // Add event listener to slider
+                slider.addEventListener('input', (e) => {
+                    const value = parseInt(e.target.value);
+                    currentValues[i] = value;
+                    segment.style.height = `${value}%`;
+                    
+                    // Check if this segment is aligned correctly
+                    const isAligned = Math.abs(value - targetValues[i]) <= 5;
+                    segment.style.backgroundColor = isAligned ? '#00cc00' : '#cc5500';
+                    
+                    // Check if all segments are aligned
+                    checkCompletion();
+                });
+                
+                sliders.push(slider);
+                sliderContainer.appendChild(slider);
+                sliderContainer.appendChild(label);
+                frequencyBands.appendChild(sliderContainer);
+            }
+            
+            // Create status message
+            const statusMessage = document.createElement('div');
+            statusMessage.style.cssText = `
+                color: #aaa;
+                font-size: 14px;
+                margin-top: 15px;
+                text-align: center;
+            `;
+            statusMessage.textContent = 'Align all frequency bands...';
+            
+            // Create cancel button
+            const cancelButton = document.createElement('button');
+            cancelButton.textContent = 'Cancel';
+            cancelButton.style.cssText = `
+                background-color: #555;
+                color: white;
+                border: none;
+                border-radius: 3px;
+                padding: 8px 15px;
+                margin-top: 20px;
+                cursor: pointer;
+                font-size: 14px;
+            `;
+            cancelButton.addEventListener('click', () => {
+                endMinigame(false);
+            });
+            
+            // Add all elements to container
+            minigameContainer.appendChild(instructions);
+            minigameContainer.appendChild(deviceInfo);
+            minigameContainer.appendChild(signalVisualization);
+            minigameContainer.appendChild(frequencyBands);
+            minigameContainer.appendChild(statusMessage);
+            minigameContainer.appendChild(cancelButton);
+            
+            // Add container to document
+            document.body.appendChild(minigameContainer);
+            
+            // Function to check if all segments are aligned
+            function checkCompletion() {
+                const allAligned = currentValues.every((value, index) => 
+                    Math.abs(value - targetValues[index]) <= 5
+                );
+                
+                if (allAligned) {
+                    statusMessage.textContent = 'MAC Address pattern matched!';
+                    statusMessage.style.color = '#00cc00';
+                    
+                    // Add success animation
+                    segments.forEach(segment => {
+                        segment.style.backgroundColor = '#00cc00';
+                    });
+                    
+                    // End minigame with success after a short delay
+                    setTimeout(() => {
+                        endMinigame(true);
+                    }, 1500);
+                }
+            }
+            
+            // Function to end minigame
+            function endMinigame(success) {
+                // Remove minigame container
+                document.body.removeChild(minigameContainer);
+                
+                // Call callback with result
+                if (success) {
+                    // Find spoofer in inventory
+                    const spoofer = inventory.items.find(item => 
+                        item.scenarioData?.type === "bluetooth_spoofer"
+                    );
+                    
+                    if (spoofer) {
+                        console.log('Programming spoofer with MAC address:', device.mac);
+                        
+                        // Program the spoofer with the target MAC address
+                        spoofer.scenarioData.macPaired = device.mac;
+                        
+                        // Show success message
+                        gameAlert(`Successfully programmed spoofer with MAC address: ${device.mac}`, 'success', 'Pairing Complete', 4000);
+                        debugLog('BLUETOOTH SPOOFER PROGRAMMED', {
+                            deviceName: device.name,
+                            deviceMac: device.mac
+                        }, 1);
+                        
+                        // Update the UI to show the pairing was successful
+                        device.paired = true;
+                        
+                        // Update the Bluetooth panel to reflect the pairing
+                        updateBluetoothPanel();
+                    }
+                } else {
+                    gameAlert('Pairing canceled.', 'info', 'Pairing Canceled', 3000);
+                }
+            }
+        }
+
     </script>
 </body>
 </html> 
\ No newline at end of file