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 bf5be26..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"
                 }
             ]
diff --git a/index.html b/index.html
index 93820bb..252a6d8 100644
--- a/index.html
+++ b/index.html
@@ -390,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>
@@ -423,6 +714,27 @@
         <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,
@@ -808,6 +1120,9 @@
             
             // Initialize notes count
             updateNotesCount();
+            
+            // Initialize Bluetooth scanner panel
+            initializeBluetoothPanel();
         });
         
         // Function to create or update the FPS counter
@@ -852,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: [],
@@ -955,6 +1270,7 @@
             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');
@@ -2310,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] && 
@@ -2347,29 +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);
                 
-                // Use debugLog with level 3 (verbose) for detailed inventory tracking
-                debugLog('INVENTORY ITEM DETAILS', {
-                    name: sprite.name,
-                    totalItems: inventory.items.length
-                }, 3);
+                // 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;
             }
         }
 
@@ -2700,40 +3060,29 @@
 
                 case 'bluetooth':
                     if (lockable.scenarioData?.locked) {
-                        gameAlert("You need a Bluetooth scanner to unlock this device.", 'warning', 'Bluetooth Required', 4000);
-                        // 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
-                    );
-                    
-                    debugLog('BLUETOOTH DISTANCE', distance, 3);
-                    
-                    // Check if player is within range (using BLUETOOTH_SCAN_RANGE)
-                    if (distance <= BLUETOOTH_SCAN_RANGE) {
-                        debugLog('BLUETOOTH UNLOCK SUCCESS', {
-                            itemName: lockable.scenarioData?.name,
-                            itemMac: lockable.scenarioData?.mac,
-                            distance: Math.round(distance),
-                            range: BLUETOOTH_SCAN_RANGE
-                        }, 1);
-                        unlockTarget(lockable, type, lockable.layer);
-                        gameAlert("Bluetooth connection established. Device unlocked.", 'success', 'Connection Successful', 4000);
-                        return;
-                    }
-                    
-                    gameAlert("Too far from device to establish Bluetooth connection.", 'error', 'Connection Failed', 3000);
                     break;
 
                 default:
@@ -2961,6 +3310,10 @@
             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 => 
@@ -2969,28 +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) {
+                        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;
-                        debugLog('BLUETOOTH UNLOCK SUCCESS', null, 1);
+                        // 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
@@ -4617,6 +5125,699 @@
             });
         }
 
+        // 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