- Drag to dust the surface and reveal fingerprints.
- 🔍 Gray = Light dusting
- 🟢 Green = Fingerprint found!
- ⚠️ White = Over-dusted (avoid this)
- Find all fingerprints with minimal over-dusting.
-
- `;
- instructions.style.cssText = `
- position: absolute;
- top: 10px;
- left: 50%;
- transform: translateX(-50%);
- width: 90%;
- `;
-
- // Add progress display
- const progressText = document.createElement('div');
- progressText.style.cssText = `
- position: absolute;
- bottom: 10px;
- left: 50%;
- transform: translateX(-50%);
- color: white;
- text-align: center;
- font-size: 16px;
- `;
-
- // Generate fingerprint pattern
- const gridSize = 20;
- const fingerprintCells = new Set();
- const centerX = Math.floor(gridSize / 2);
- const centerY = Math.floor(gridSize / 2);
-
- // Create a larger pattern (about 50 cells) spread around the center
- for (let i = 0; i < 50; i++) {
- const x = centerX + Math.floor(Math.random() * 10 - 5); // Increased spread
- const y = centerY + Math.floor(Math.random() * 10 - 5); // Increased spread
- if (x >= 0 && x < gridSize && y >= 0 && y < gridSize) {
- fingerprintCells.add(`${x},${y}`);
- }
- }
-
- // If we didn't get enough cells, add more until we reach target
- while (fingerprintCells.size < 50) {
- const x = centerX + Math.floor(Math.random() * 12 - 6);
- const y = centerY + Math.floor(Math.random() * 12 - 6);
- if (x >= 0 && x < gridSize && y >= 0 && y < gridSize) {
- fingerprintCells.add(`${x},${y}`);
- }
- }
-
- // Track progress
- let revealedPrints = 0;
- let totalPrints = fingerprintCells.size;
- let overDusted = 0;
-
- // Create grid cells
- for (let y = 0; y < gridSize; y++) {
- for (let x = 0; x < gridSize; x++) {
- const cell = document.createElement('div');
- cell.style.cssText = `
- width: 100%;
- height: 100%;
- background: black;
- position: relative;
- cursor: pointer;
- `;
- cell.dataset.x = x;
- cell.dataset.y = y;
- cell.dataset.dustLevel = '0';
- cell.dataset.hasFingerprint = fingerprintCells.has(`${x},${y}`);
-
- gameContainer.appendChild(cell);
- }
- }
-
- // Add dragging interaction at container level
- let isDragging = false;
- let lastDustTime = {}; // Track last dust time for each cell
-
- gameContainer.addEventListener('mousedown', () => isDragging = true);
- gameContainer.addEventListener('mouseup', () => isDragging = false);
- gameContainer.addEventListener('mouseleave', () => isDragging = false);
- gameContainer.addEventListener('mousemove', (e) => {
- if (!isDragging) return;
+ // Initialize the framework
+ init: function(mainScene) {
+ this.mainGameScene = mainScene;
- // Get the cell element under the cursor
- const cell = document.elementFromPoint(e.clientX, e.clientY);
- if (cell && cell.dataset.dustLevel !== undefined) {
- const cellId = `${cell.dataset.x},${cell.dataset.y}`;
- const currentTime = Date.now();
- const dustLevel = parseInt(cell.dataset.dustLevel);
+ // Create container for all minigames if it doesn't exist
+ if (!document.getElementById('minigame-container')) {
+ const container = document.createElement('div');
+ container.id = 'minigame-container';
+ document.body.appendChild(container);
- // Only allow dusting every 100ms for each cell
- if (!lastDustTime[cellId] || currentTime - lastDustTime[cellId] > 100) {
- if (dustLevel < 3) {
- // Increment dust level with 33% chance after level 1
- if (dustLevel < 1 || Math.random() < 0.33) {
- cell.dataset.dustLevel = (dustLevel + 1).toString();
- updateCellColor(cell);
- checkProgress();
- }
- lastDustTime[cellId] = currentTime;
- }
- }
- }
- });
-
- function updateCellColor(cell) {
- const dustLevel = parseInt(cell.dataset.dustLevel);
- const hasFingerprint = cell.dataset.hasFingerprint === 'true';
-
- if (dustLevel === 0) {
- cell.style.background = 'black';
- }
- else if (dustLevel === 1) {
- cell.style.background = '#444';
- }
- else if (dustLevel === 2) {
- cell.style.background = hasFingerprint ? '#0f0' : '#888';
- }
- else {
- cell.style.background = '#ccc';
- }
- }
-
- function checkProgress() {
- revealedPrints = 0;
- overDusted = 0;
-
- gameContainer.childNodes.forEach(cell => {
- const dustLevel = parseInt(cell.dataset.dustLevel);
- const hasFingerprint = cell.dataset.hasFingerprint === 'true';
-
- if (hasFingerprint && dustLevel === 2) revealedPrints++;
- if (dustLevel === 3) overDusted++;
- });
-
- const requiredPrints = Math.ceil(totalPrints * 0.4); // 40% requirement
- progressText.innerHTML = `
-
- Over-dusted: ${overDusted}/25 max
-
- `;
-
- // Check fail condition first
- if (overDusted >= 25) {
- // Show failure message
- const failureMessage = document.createElement('div');
- failureMessage.style.cssText = `
- position: absolute;
- top: 50%;
- left: 50%;
- transform: translate(-50%, -50%);
- background: rgba(0, 0, 0, 0.9);
- padding: 20px;
- border-radius: 5px;
- color: #f00;
- font-size: 20px;
- text-align: center;
- z-index: 1001;
- `;
- failureMessage.textContent = "Too many over-dusted areas!";
- iframe.appendChild(failureMessage);
-
- // Disable further interaction
- isDragging = false;
- gameContainer.style.pointerEvents = 'none';
-
- setTimeout(() => {
- document.body.removeChild(iframe);
- scene.input.mouse.enabled = true;
- }, 1500);
- return;
- }
-
- // Check win condition (existing code)
- if (revealedPrints >= requiredPrints && overDusted < 25) {
- // Show 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.9);
- padding: 20px;
- border-radius: 5px;
- color: #0f0;
- font-size: 20px;
- text-align: center;
- z-index: 1001;
- `;
- successMessage.textContent = "Fingerprint successfully collected!";
- iframe.appendChild(successMessage);
-
- // Disable further interaction
- isDragging = false;
- gameContainer.style.pointerEvents = 'none';
-
- setTimeout(() => {
- // Add fingerprint to gameState
- if (!gameState.biometricSamples) {
- gameState.biometricSamples = [];
- }
-
- const sample = {
- id: generateFingerprintData(item),
- type: 'fingerprint',
- owner: item.scenarioData.fingerprintOwner,
- quality: Math.random() * 0.3 + 0.7, // Random quality between 0.7 and 1.0
- data: generateFingerprintData(item),
- timestamp: Date.now()
- };
-
- gameState.biometricSamples.push(sample);
-
- // Remove the minigame
- document.body.removeChild(iframe);
- scene.input.mouse.enabled = true;
-
- // Mark item as collected
- if (item.scenarioData) {
- item.scenarioData.hasFingerprint = false;
- }
-
- // Update the biometrics panel and count
- updateBiometricsPanel();
- updateBiometricsCount();
-
- // Show notification
- gameAlert(`Collected ${sample.owner}'s fingerprint sample`, 'success', 'Sample Acquired', 3000);
- }, 1500);
- }
- }
-
- // 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);
- scene.input.mouse.enabled = true;
- };
-
- // Assemble the interface
- iframe.appendChild(closeButton);
- iframe.appendChild(instructions);
- iframe.appendChild(gameContainer);
- iframe.appendChild(progressText);
- document.body.appendChild(iframe);
-
- // Disable game movement
- const scene = item.scene;
- 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 = `
-
- Use spacebar or click to toggle tension levels. Each pin requires the right amount of tension.
- 🔵 Blue = Pin moving
- 🟢 Green = Pin set correctly
- 🔴 Red = Over-pushed (reset)
- Set all pins in the correct order with the right tension without resetting.
-
- `;
- 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 (1)
- 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: #666;
- border: 2px solid #888;
- border-radius: 5px;
- cursor: pointer;
- margin-bottom: 20px;
- text-align: center;
- line-height: 30px;
- color: white;
- transform: rotate(2deg);
- `;
- tensionWrench.textContent = 'Tension: LIGHT';
-
- // 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')) {
+ // Add base styles
const style = document.createElement('style');
- style.id = 'pinWiggleAnimation';
+ style.id = 'minigame-framework-styles';
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); }
+ /* Framework base styles */
+ #minigame-container {
+ position: fixed;
+ top: 0;
+ left: 0;
+ width: 100%;
+ height: 100%;
+ z-index: 1000;
+ display: none;
+ pointer-events: all;
+ }
+
+ #minigame-overlay {
+ position: fixed;
+ top: 0;
+ left: 0;
+ width: 100%;
+ height: 100%;
+ background: rgba(0, 0, 0, 0.5);
+ z-index: 1001;
+ pointer-events: all;
+ }
+
+ .minigame-scene {
+ position: fixed;
+ top: 50%;
+ left: 50%;
+ transform: translate(-50%, -50%);
+ background: #222;
+ color: white;
+ border-radius: 10px;
+ box-shadow: 0 0 20px rgba(0,0,0,0.5);
+ z-index: 1002;
+ pointer-events: all;
+ }
+
+ /* Common minigame UI elements */
+ .minigame-close {
+ background: #555;
+ color: white;
+ border: none;
+ padding: 10px 20px;
+ border-radius: 5px;
+ cursor: pointer;
+ margin-top: 10px;
+ align-self: center;
+ }
+
+ .minigame-header {
+ position: absolute;
+ top: 0;
+ left: 0;
+ width: 100%;
+ background: rgba(30, 30, 30, 0.9);
+ padding: 10px;
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ z-index: 5;
+ }
+
+ .minigame-header h3 {
+ margin: 0 0 8px 0;
+ color: #fff;
+ text-align: center;
+ }
+
+ .minigame-header p {
+ margin: 5px 0;
+ color: #ccc;
+ text-align: center;
+ font-size: 12px;
+ }
+
+ .minigame-success-message {
+ position: absolute;
+ top: 50%;
+ left: 50%;
+ transform: translate(-50%, -50%);
+ background: rgba(0, 0, 0, 0.9);
+ padding: 20px;
+ border-radius: 5px;
+ color: #0f0;
+ font-size: 20px;
+ text-align: center;
+ z-index: 1003;
+ box-shadow: 0 0 20px rgba(0, 255, 0, 0.3);
+ }
+
+ .minigame-failure-message {
+ position: absolute;
+ top: 50%;
+ left: 50%;
+ transform: translate(-50%, -50%);
+ background: rgba(0, 0, 0, 0.9);
+ padding: 20px;
+ border-radius: 5px;
+ color: #f00;
+ font-size: 20px;
+ text-align: center;
+ z-index: 1003;
+ box-shadow: 0 0 20px rgba(255, 0, 0, 0.3);
+ }
+
+ .minigame-tool-button {
+ background-color: #444;
+ color: white;
+ border: none;
+ border-radius: 3px;
+ padding: 5px 10px;
+ cursor: pointer;
+ opacity: 0.7;
+ transition: opacity 0.2s, background-color 0.2s;
+ }
+
+ .minigame-tool-button.active {
+ opacity: 1;
+ }
+
+ .minigame-progress-container {
+ height: 6px;
+ width: 100%;
+ background: #333;
+ border-radius: 3px;
+ overflow: hidden;
+ }
+
+ .minigame-progress-bar {
+ height: 100%;
+ width: 0%;
+ background: #2ecc71;
+ transition: width 0.3s;
+ }
+
+ .minigame-scene.success {
+ border: 2px solid #33cc33;
+ }
+
+ .minigame-scene.failure {
+ border: 2px solid #cc3333;
}
`;
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));
+ // Launch a minigame
+ startMinigame: function(minigameId, params = {}) {
+ // Don't allow multiple minigames at once
+ if (this.activeMinigame) {
+ console.warn('A minigame is already running!');
+ return false;
+ }
+
+ // Get the minigame scene constructor
+ const MinigameScene = this.scenes[minigameId];
+ if (!MinigameScene) {
+ console.error(`Minigame "${minigameId}" not found!`);
+ return false;
+ }
+
+ // Pause the main game
+ if (this.mainGameScene) {
+ // Pause Phaser scene
+ if (this.mainGameScene.scene && typeof this.mainGameScene.scene.pause === 'function') {
+ this.mainGameScene.scene.pause();
}
+ }
+
+ // Show the minigame container
+ const container = document.getElementById('minigame-container');
+ container.style.display = 'block';
+
+ // Create overlay
+ const overlay = document.createElement('div');
+ overlay.id = 'minigame-overlay';
+ container.appendChild(overlay);
+
+ // Create scene element
+ const sceneElement = document.createElement('div');
+ sceneElement.className = 'minigame-scene';
+ sceneElement.id = `minigame-scene-${minigameId}`;
+ container.appendChild(sceneElement);
+
+ // Instantiate the minigame scene
+ this.activeMinigame = new MinigameScene(sceneElement, {
+ ...params,
+ onComplete: (success, result) => {
+ this.endMinigame(success, result);
+ if (params.onComplete) params.onComplete(success, result);
+ }
+ });
+
+ // Initialize and start the minigame
+ this.activeMinigame.init();
+ this.activeMinigame.start();
+
+ return true;
+ },
+
+ // End the active minigame
+ endMinigame: function(success = false, result = null) {
+ if (!this.activeMinigame) return;
+
+ // Call the minigame's cleanup method
+ if (typeof this.activeMinigame.cleanup === 'function') {
+ this.activeMinigame.cleanup();
+ }
+
+ // Remove the minigame elements
+ const container = document.getElementById('minigame-container');
+ container.innerHTML = '';
+ container.style.display = 'none';
+
+ // Unpause the main game
+ if (this.mainGameScene) {
+ // Resume Phaser scene
+ if (this.mainGameScene.scene && typeof this.mainGameScene.scene.resume === 'function') {
+ this.mainGameScene.scene.resume();
+ }
+ }
+
+ this.activeMinigame = null;
+ },
+
+ // Register a new minigame scene
+ registerScene: function(id, sceneClass) {
+ if (!this.scenes) this.scenes = {};
+ this.scenes[id] = sceneClass;
+ },
+
+ // Base class for minigame scenes
+ MinigameScene: class {
+ constructor(container, params = {}) {
+ this.container = container;
+ this.params = params;
- console.log('Lock picked successfully:', lockable);
+ // Common game state management
+ this.gameState = {
+ isActive: false,
+ isDragging: false,
+ mousePosition: { x: 0, y: 0 },
+ mouseDown: false,
+ mouseButtonsPressed: [false, false, false],
+ keyState: {},
+ success: false,
+ gameComplete: false,
+ startTime: 0,
+ elapsedTime: 0
+ };
- // Create success message
- const successMessage = document.createElement('div');
- successMessage.style.cssText = `
+ // Bind event handlers to the instance
+ this._handleMouseDown = this._handleMouseDown.bind(this);
+ this._handleMouseUp = this._handleMouseUp.bind(this);
+ this._handleMouseMove = this._handleMouseMove.bind(this);
+ this._handleMouseLeave = this._handleMouseLeave.bind(this);
+ this._handleKeyDown = this._handleKeyDown.bind(this);
+ this._handleKeyUp = this._handleKeyUp.bind(this);
+
+ // Store event listeners for cleanup
+ this._eventListeners = [];
+ }
+
+ init() {
+ console.log(`Initializing minigame scene`);
+
+ // Ensure the scene container is visible
+ this.container.style.display = 'flex';
+
+ // Create standard layout elements
+ this.createLayout();
+
+ // Add escape key handler
+ this.escHandler = (e) => {
+ if (e.key === 'Escape' && this.gameState.isActive) {
+ this.complete(false);
+ }
+ };
+ document.addEventListener('keydown', this.escHandler);
+
+ // Setup common event handling
+ this.setupEventHandling();
+
+ // Record start time
+ this.gameState.startTime = Date.now();
+ }
+
+ // Create standard layout for minigames
+ createLayout() {
+ // Create and add the header
+ this.headerElement = document.createElement('div');
+ this.headerElement.className = 'minigame-header';
+ this.container.appendChild(this.headerElement);
+
+ // Create the main game container
+ this.gameContainer = document.createElement('div');
+ this.gameContainer.className = 'minigame-game-container';
+ this.gameContainer.style.cssText = `
+ width: 80%;
+ height: 80%;
+ margin: 70px auto 20px auto;
+ background: #1a1a1a;
+ border-radius: 5px;
+ box-shadow: 0 0 15px rgba(0, 0, 0, 0.5) inset;
+ position: relative;
+ overflow: hidden;
+ `;
+ this.container.appendChild(this.gameContainer);
+
+ // Create message container for notifications, success/failure
+ this.messageContainer = document.createElement('div');
+ this.messageContainer.className = 'minigame-message-container';
+ this.messageContainer.style.cssText = `
+ position: absolute;
+ top: 0;
+ left: 0;
+ width: 100%;
+ height: 100%;
+ pointer-events: none;
+ z-index: 1000;
+ `;
+ this.container.appendChild(this.messageContainer);
+
+ // Create progress display
+ this.progressContainer = document.createElement('div');
+ this.progressContainer.style.cssText = `
+ position: absolute;
+ bottom: 15px;
+ left: 50%;
+ transform: translateX(-50%);
+ color: white;
+ text-align: center;
+ font-size: 16px;
+ background: rgba(0, 0, 0, 0.6);
+ padding: 5px 15px;
+ border-radius: 15px;
+ z-index: 10;
+ width: 80%;
+ max-width: 500px;
+ `;
+ this.container.appendChild(this.progressContainer);
+
+ // Create standard close button
+ const closeButton = document.createElement('button');
+ closeButton.textContent = '✕';
+ closeButton.style.cssText = `
+ position: absolute;
+ right: 10px;
+ top: 10px;
+ background: none;
+ border: none;
+ color: white;
+ font-size: 20px;
+ cursor: pointer;
+ z-index: 100;
+ `;
+ closeButton.onclick = () => this.complete(false);
+ this.container.appendChild(closeButton);
+ }
+
+ // Set up common event handling for mouse, touch, keyboard
+ setupEventHandling() {
+ // Mouse events
+ this.addEventListenerWithCleanup(this.gameContainer, 'mousedown', this._handleMouseDown);
+ this.addEventListenerWithCleanup(document, 'mouseup', this._handleMouseUp);
+ this.addEventListenerWithCleanup(this.gameContainer, 'mousemove', this._handleMouseMove);
+ this.addEventListenerWithCleanup(this.gameContainer, 'mouseleave', this._handleMouseLeave);
+
+ // Keyboard events
+ this.addEventListenerWithCleanup(document, 'keydown', this._handleKeyDown);
+ this.addEventListenerWithCleanup(document, 'keyup', this._handleKeyUp);
+
+ // Prevent context menu
+ this.addEventListenerWithCleanup(this.gameContainer, 'contextmenu', (e) => e.preventDefault());
+ }
+
+ // Utility to add event listener and track it for cleanup
+ addEventListenerWithCleanup(element, eventType, handler, options) {
+ element.addEventListener(eventType, handler, options);
+ this._eventListeners.push({ element, eventType, handler });
+ }
+
+ // Event handlers
+ _handleMouseDown(e) {
+ console.log("Mouse down in framework handler");
+ this.gameState.mouseDown = true;
+ this.gameState.mouseButtonsPressed[e.button] = true;
+ this.gameState.isDragging = true;
+
+ // Call subclass handler if it exists
+ if (typeof this.handleMouseDown === 'function') {
+ this.handleMouseDown(e);
+ }
+ }
+
+ _handleMouseUp(e) {
+ console.log("Mouse up in framework handler");
+ this.gameState.mouseDown = false;
+ this.gameState.mouseButtonsPressed[e.button] = false;
+ this.gameState.isDragging = false;
+
+ // Call subclass handler if it exists
+ if (typeof this.handleMouseUp === 'function') {
+ this.handleMouseUp(e);
+ }
+ }
+
+ _handleMouseMove(e) {
+ // Update mouse position
+ const rect = this.gameContainer.getBoundingClientRect();
+ this.gameState.mousePosition = {
+ x: e.clientX - rect.left,
+ y: e.clientY - rect.top,
+ clientX: e.clientX,
+ clientY: e.clientY,
+ screenX: e.screenX,
+ screenY: e.screenY
+ };
+
+ // Call subclass handler if it exists
+ if (typeof this.handleMouseMove === 'function') {
+ this.handleMouseMove(e);
+ }
+ }
+
+ _handleMouseLeave(e) {
+ this.gameState.isDragging = false;
+
+ // Call subclass handler if it exists
+ if (typeof this.handleMouseLeave === 'function') {
+ this.handleMouseLeave(e);
+ }
+ }
+
+ _handleKeyDown(e) {
+ this.gameState.keyState[e.code] = true;
+
+ // Call subclass handler if it exists
+ if (typeof this.handleKeyDown === 'function') {
+ this.handleKeyDown(e);
+ }
+ }
+
+ _handleKeyUp(e) {
+ this.gameState.keyState[e.code] = false;
+
+ // Call subclass handler if it exists
+ if (typeof this.handleKeyUp === 'function') {
+ this.handleKeyUp(e);
+ }
+ }
+
+ // Message display system
+ showMessage(message, type = 'info', duration = 0) {
+ // Create a message element
+ const messageElement = document.createElement('div');
+ messageElement.className = `minigame-message minigame-message-${type}`;
+ messageElement.innerHTML = message;
+
+ // Style based on type
+ let styles = `
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;
+ border-radius: 5px;
text-align: center;
- z-index: 1002;
+ z-index: 1001;
+ pointer-events: all;
+ max-width: 90%;
+ transition: opacity 0.3s;
`;
- 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';
+ switch(type) {
+ case 'success':
+ messageElement.className = 'minigame-success-message';
+ break;
+ case 'failure':
+ case 'error':
+ messageElement.className = 'minigame-failure-message';
+ break;
+ default:
+ styles += `
+ background: rgba(0, 0, 0, 0.8);
+ color: white;
+ box-shadow: 0 0 10px rgba(0, 0, 0, 0.5);
+ `;
}
- tableData.push({
- 'Binding Order': orderIndex + 1,
- 'Pin #': pinIndex + 1,
- 'Tension Required': tensionNeeded
- });
+ // Apply styles
+ messageElement.style.cssText = styles;
+
+ // Add to the message container
+ this.messageContainer.appendChild(messageElement);
+
+ // Auto-remove after duration, if specified
+ if (duration > 0) {
+ setTimeout(() => {
+ messageElement.style.opacity = '0';
+ setTimeout(() => {
+ if (messageElement.parentNode) {
+ messageElement.parentNode.removeChild(messageElement);
+ }
+ }, 300);
+ }, duration);
+ }
+
+ return messageElement;
}
- console.table(tableData);
+ // Success/failure methods
+ showSuccess(message, autoComplete = true, delay = 2000) {
+ this.gameState.success = true;
+ this.gameState.gameComplete = true;
+ this.container.classList.add('success');
+
+ // Create success message
+ const successMessage = this.showMessage(message, 'success');
+
+ // Auto-complete after delay
+ if (autoComplete) {
+ setTimeout(() => {
+ this.complete(true);
+ }, delay);
+ }
+
+ return successMessage;
+ }
+
+ showFailure(message, autoComplete = true, delay = 2000) {
+ this.gameState.success = false;
+ this.gameState.gameComplete = true;
+ this.container.classList.add('failure');
+
+ // Create failure message
+ const failureMessage = this.showMessage(message, 'failure');
+
+ // Auto-complete after delay
+ if (autoComplete) {
+ setTimeout(() => {
+ this.complete(false);
+ }, delay);
+ }
+
+ return failureMessage;
+ }
+
+ // Progress updates
+ updateProgress(current, total, label = '') {
+ const percentage = Math.min(100, Math.max(0, (current / total) * 100));
+
+ this.progressContainer.innerHTML = `
+ ${label ? `
+ Difficulty: ${this.difficulty.charAt(0).toUpperCase() + this.difficulty.slice(1)}
+ Pins: ${this.pinCount}
+
+ `;
- // Remove from items array
- inventory.items.splice(index, 1);
+ // Use the framework's success message system
+ this.showSuccess(successHTML, true, 2000);
- // Destroy the sprite
- sprite.destroy();
+ // Store lockable for the result
+ this.gameResult = { lockable: this.lockable };
+ }
+
+ lockPickingFailure() {
+ // Show failure message
+ const failureHTML = `
+
- You can now use this MAC address to unlock matching Bluetooth locks
-
`;
-
- // If this is an inventory item, add an unlock button
- if (device.inInventory) {
- deviceContent += `
- Align the signal frequencies to match the target device's MAC address pattern.
- Drag the sliders to adjust each frequency band until all segments turn green.
- When all segments are aligned, the MAC address will be successfully paired.
-
- `;
- 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 = `
-
@@ -6249,27 +6221,6 @@
sampleElement.innerHTML = sampleContent;
- // Add spoof button if not already spoofed
- if (!sample.isSpoofed && hasItemInInventory('spoofing_kit')) {
- const spoofButton = document.createElement('button');
- spoofButton.textContent = 'Create Spoof';
- spoofButton.style.cssText = `
- margin-top: 10px;
- padding: 5px 10px;
- background: #e74c3c;
- border: none;
- color: white;
- border-radius: 3px;
- cursor: pointer;
- width: 100%;
- `;
- spoofButton.onclick = (event) => {
- event.stopPropagation(); // Prevent toggling expand/collapse
- createSpoofedSampleUI(sample);
- };
- sampleElement.appendChild(spoofButton);
- }
-
// Toggle expanded state when clicked
sampleElement.addEventListener('click', () => {
sampleElement.classList.toggle('expanded');
@@ -6279,51 +6230,6 @@
});
}
- // Function to create spoofed sample with UI
- function createSpoofedSampleUI(sample) {
- // Find the sample element
- const sampleElement = document.querySelector(`.biometric-sample[data-id="${sample.id}"]`);
- if (!sampleElement) return;
-
- // Disable any existing spoof buttons
- const existingButton = sampleElement.querySelector('button');
- if (existingButton) {
- existingButton.disabled = true;
- existingButton.textContent = 'Creating spoof...';
- }
-
- // Add progress bar
- const progressBar = document.createElement('div');
- progressBar.className = 'biometric-quality-bar';
-
- const progress = document.createElement('div');
- progress.className = 'biometric-quality-fill';
- progress.style.width = '0%';
- progress.style.background = '#e67e22';
-
- progressBar.appendChild(progress);
- sampleElement.appendChild(progressBar);
-
- // Animate progress
- let currentProgress = 0;
- const interval = setInterval(() => {
- currentProgress += 2;
- progress.style.width = `${currentProgress}%`;
- }, SPOOFING_TIME / 50);
-
- // Create spoof after delay
- setTimeout(() => {
- clearInterval(interval);
- const spoofedSample = createSpoofedSample(sample);
- if (spoofedSample) {
- gameState.biometricSamples.push(spoofedSample);
- updateBiometricsPanel(); // Refresh UI
- updateBiometricsCount(); // Update count
- gameAlert("Successfully created spoofed sample.", 'success', 'Spoofing Complete', 3000);
- }
- }, SPOOFING_TIME);
- }
-
// Update the biometrics count
function updateBiometricsCount() {
const biometricsCount = document.getElementById('biometrics-count');
@@ -6353,15 +6259,21 @@
function initializeBiometricsPanel() {
// Set up biometrics toggle button
const biometricsToggle = document.getElementById('biometrics-toggle');
- biometricsToggle.addEventListener('click', toggleBiometricsPanel);
+ if (biometricsToggle) {
+ biometricsToggle.addEventListener('click', toggleBiometricsPanel);
+ }
// Set up biometrics close button
const biometricsClose = document.getElementById('biometrics-close');
- biometricsClose.addEventListener('click', toggleBiometricsPanel);
+ if (biometricsClose) {
+ biometricsClose.addEventListener('click', toggleBiometricsPanel);
+ }
// Set up search functionality
const biometricsSearch = document.getElementById('biometrics-search');
- biometricsSearch.addEventListener('input', updateBiometricsPanel);
+ if (biometricsSearch) {
+ biometricsSearch.addEventListener('input', updateBiometricsPanel);
+ }
// Set up category filters
const categories = document.querySelectorAll('.biometrics-category');
@@ -6398,24 +6310,6 @@
const biometricsPanel = document.getElementById('biometrics-panel');
biometricsPanel.style.display = 'none';
}
-
- // Override createSpoofedSample to add timestamp
- const originalCreateSpoofedSample = createSpoofedSample;
- createSpoofedSample = function(sample) {
- const spoofedSample = originalCreateSpoofedSample(sample);
- if (spoofedSample) {
- spoofedSample.timestamp = Date.now();
- }
- return spoofedSample;
- };
-
- // We don't need this duplicate initialization since we already added it to the existing DOMContentLoaded handler
- // document.addEventListener('DOMContentLoaded', function() {
- // // Existing initialization...
- //
- // // Initialize biometrics panel
- // initializeBiometricsPanel();
- // });
// Function to drop an inventory item
function dropInventoryItem(item) {
@@ -6549,6 +6443,724 @@
popup.style.display = 'flex';
}
+ // Add this function to handle biometric matching near the other utility functions
+ function performBiometricMatch(lockable, ownerFingerprint, qualityThreshold, type) {
+ // Get available biometric samples - assuming they're stored in a global variable
+ // This may need to be adjusted based on how your biometric samples are actually stored
+ const availableSamples = biometricSamples || [];
+
+ if (!availableSamples || availableSamples.length === 0) {
+ $("#biometric-status").text("No fingerprint samples available.");
+ gameAlert("No fingerprint samples found in database.", 'error', 'Scan Failed', 3000);
+ return;
+ }
+
+ // Find if we have the owner's fingerprint
+ const matchingSample = availableSamples.find(sample => sample.id === ownerFingerprint);
+
+ if (!matchingSample) {
+ // No matching sample found
+ $("#biometric-status").text("No match found. Access denied.");
+ gameAlert("Biometric authentication failed.", 'error', 'Access Denied', 3000);
+
+ setTimeout(function() {
+ $("#biometrics-panel").hide();
+ }, 2000);
+ return;
+ }
+
+ // Check quality against threshold
+ const sampleQuality = matchingSample.quality || 0;
+
+ if (sampleQuality >= qualityThreshold) {
+ // Successful match with sufficient quality
+ $("#biometric-status").text("Match found! Unlocking...");
+
+ setTimeout(function() {
+ // Unlock the target
+ unlockTarget(lockable, type, lockable.layer);
+ $("#biometrics-panel").hide();
+
+ // Play unlock sound if available
+ if (typeof playSound === 'function') {
+ playSound("unlock");
+ }
+
+ gameAlert(`Biometric match confirmed. ${type.charAt(0).toUpperCase() + type.slice(1)} unlocked.`, 'success', 'Access Granted', 4000);
+ debugLog('BIOMETRIC AUTHENTICATION SUCCESS', null, 1);
+ }, 1500);
+ } else {
+ // Match found but quality insufficient
+ $("#biometric-status").text("Sample quality insufficient. Access denied.");
+ gameAlert(`Biometric sample quality too low (${sampleQuality}/${qualityThreshold} required).`, 'error', 'Low Quality Sample', 3000);
+ debugLog('BIOMETRIC AUTHENTICATION FAILED - LOW QUALITY', null, 2);
+
+ setTimeout(function() {
+ $("#biometrics-panel").hide();
+ }, 2000);
+ }
+ }
+
+ // Function to find a matching Bluetooth device in the current room
+ function findMatchingBluetoothDevice(device) {
+ if (!device.scenarioData?.mac || !currentRoom) return null;
+
+ const targetMac = device.scenarioData.mac;
+ const roomObjects = Object.values(rooms[currentRoom].objects || {});
+
+ // Find any object in the current room with a matching MAC address
+ return roomObjects.find(obj =>
+ obj.scenarioData?.mac &&
+ obj.scenarioData.mac === targetMac &&
+ obj.name !== device.name // Ensure it's not the same device
+ );
+ }
+
+ // Dusting Minigame Scene implementation
+ class DustingMinigame extends MinigameFramework.MinigameScene {
+ constructor(container, params) {
+ super(container, params);
+
+ this.item = params.item;
+
+ // Game state variables - using framework's gameState as base
+ this.difficultySettings = {
+ easy: {
+ requiredCoverage: 0.3, // 30% of prints
+ maxOverDusted: 50, // Increased due to more cells
+ fingerprints: 60, // Increased proportionally
+ pattern: 'simple'
+ },
+ medium: {
+ requiredCoverage: 0.4, // 40% of prints
+ maxOverDusted: 40, // Increased due to more cells
+ fingerprints: 75, // Increased proportionally
+ pattern: 'medium'
+ },
+ hard: {
+ requiredCoverage: 0.5, // 50% of prints
+ maxOverDusted: 25, // Increased due to more cells
+ fingerprints: 90, // Increased proportionally
+ pattern: 'complex'
+ }
+ };
+
+ this.currentDifficulty = this.item.scenarioData.fingerprintDifficulty;
+ this.gridSize = 30;
+ this.fingerprintCells = new Set();
+ this.revealedPrints = 0;
+ this.overDusted = 0;
+ this.lastDustTime = {};
+
+ // Tools configuration
+ this.tools = [
+ { name: 'Fine', size: 1, color: '#3498db', radius: 0 }, // Only affects current cell
+ { name: 'Medium', size: 2, color: '#2ecc71', radius: 1 }, // Affects current cell and adjacent
+ { name: 'Wide', size: 3, color: '#e67e22', radius: 2 } // Affects current cell and 2 cells around
+ ];
+ this.currentTool = this.tools[1]; // Start with medium brush
+ }
+
+ init() {
+ // Call parent init to set up common components
+ super.init();
+
+ console.log("Dusting minigame initializing");
+
+ // Set container dimensions
+ this.container.style.width = '75%';
+ this.container.style.height = '75%';
+ this.container.style.padding = '20px';
+
+ // Set up header content
+ this.headerElement.innerHTML = `
+
Fingerprint Dusting
+
Drag to dust the surface and reveal fingerprints. Avoid over-dusting!
+ `;
+
+ // Configure game container
+ this.gameContainer.style.cssText = `
+ width: 80%;
+ height: 80%;
+ max-width: 600px;
+ max-height: 600px;
+ display: grid;
+ grid-template-columns: repeat(30, 1fr);
+ grid-template-rows: repeat(30, 1fr);
+ gap: 1px;
+ background: #1a1a1a;
+ padding: 5px;
+ margin: 70px auto 20px auto;
+ border-radius: 5px;
+ box-shadow: 0 0 15px rgba(0, 0, 0, 0.5) inset;
+ position: relative;
+ overflow: hidden;
+ cursor: crosshair;
+ `;
+
+ // Add background texture/pattern for a more realistic surface
+ const gridBackground = document.createElement('div');
+ gridBackground.style.cssText = `
+ position: absolute;
+ top: 0;
+ left: 0;
+ width: 100%;
+ height: 100%;
+ opacity: 0.3;
+ pointer-events: none;
+ z-index: 0;
+ `;
+
+ // Create the grid pattern using encoded SVG
+ const svgGrid = `data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='100' height='100' viewBox='0 0 100 100'%3E%3Crect width='100' height='100' fill='%23111'/%3E%3Cpath d='M0 50h100M50 0v100' stroke='%23222' stroke-width='0.5'/%3E%3Cpath d='M25 0v100M75 0v100M0 25h100M0 75h100' stroke='%23191919' stroke-width='0.3'/%3E%3C/svg%3E`;
+
+ gridBackground.style.backgroundImage = `url('${svgGrid}')`;
+ this.gameContainer.appendChild(gridBackground);
+
+ // Add tool selection
+ const toolsContainer = document.createElement('div');
+ toolsContainer.style.cssText = `
+ position: absolute;
+ bottom: 15px;
+ left: 15px;
+ display: flex;
+ gap: 10px;
+ z-index: 10;
+ flex-wrap: wrap;
+ max-width: 30%;
+ `;
+
+ this.tools.forEach(tool => {
+ const toolButton = document.createElement('button');
+ toolButton.className = `minigame-tool-button ${tool.name === this.currentTool.name ? 'active' : ''}`;
+ toolButton.textContent = tool.name;
+ toolButton.style.backgroundColor = tool.color;
+
+ toolButton.addEventListener('click', () => {
+ document.querySelectorAll('.minigame-tool-button').forEach(btn => {
+ btn.classList.remove('active');
+ });
+ toolButton.classList.add('active');
+ this.currentTool = tool;
+ });
+
+ toolsContainer.appendChild(toolButton);
+ });
+ this.container.appendChild(toolsContainer);
+
+ // Create particle container for dust effects
+ this.particleContainer = document.createElement('div');
+ this.particleContainer.style.cssText = `
+ position: absolute;
+ top: 0;
+ left: 0;
+ width: 100%;
+ height: 100%;
+ pointer-events: none;
+ z-index: 5;
+ overflow: hidden;
+ `;
+ this.container.appendChild(this.particleContainer);
+
+ // Generate fingerprint pattern and set up cells
+ this.fingerprintCells = this.generateFingerprint(this.currentDifficulty);
+ this.setupGrid();
+
+ // Total prints and required prints calculations
+ this.totalPrints = this.fingerprintCells.size;
+ this.requiredPrints = Math.ceil(this.totalPrints * this.difficultySettings[this.currentDifficulty].requiredCoverage);
+
+ // Check initial progress
+ this.checkProgress();
+ }
+
+ // Set up the grid of cells
+ setupGrid() {
+ // Clear any existing cells
+ while (this.gameContainer.firstChild) {
+ this.gameContainer.removeChild(this.gameContainer.firstChild);
+ }
+
+ // Create grid cells
+ for (let y = 0; y < this.gridSize; y++) {
+ for (let x = 0; x < this.gridSize; x++) {
+ const cell = document.createElement('div');
+ cell.style.cssText = `
+ width: 100%;
+ height: 100%;
+ background: black;
+ position: relative;
+ transition: background-color 0.1s;
+ cursor: pointer;
+ `;
+ cell.dataset.x = x;
+ cell.dataset.y = y;
+ cell.dataset.dustLevel = '0';
+ cell.dataset.hasFingerprint = this.fingerprintCells.has(`${x},${y}`) ? 'true' : 'false';
+
+ this.gameContainer.appendChild(cell);
+ }
+ }
+ }
+
+ // Override the framework's mouse event handlers
+ handleMouseMove(e) {
+ if (!this.gameState.isDragging) return;
+
+ // Get the cell element under the cursor
+ const cell = document.elementFromPoint(e.clientX, e.clientY);
+ if (!cell || !cell.dataset || cell.dataset.dustLevel === undefined) return;
+
+ // Get current cell coordinates
+ const centerX = parseInt(cell.dataset.x);
+ const centerY = parseInt(cell.dataset.y);
+
+ // Get a list of cells to dust based on the brush radius
+ const cellsToDust = [];
+ const radius = this.currentTool.radius;
+
+ // Add the current cell and cells within radius
+ for (let y = centerY - radius; y <= centerY + radius; y++) {
+ for (let x = centerX - radius; x <= centerX + radius; x++) {
+ // Skip cells outside the grid
+ if (x < 0 || x >= this.gridSize || y < 0 || y >= this.gridSize) continue;
+
+ // For medium brush, use a diamond pattern (taxicab distance)
+ if (this.currentTool.size === 2) {
+ // Manhattan distance: |x1-x2| + |y1-y2|
+ const distance = Math.abs(x - centerX) + Math.abs(y - centerY);
+ if (distance > radius) continue; // Skip if too far away
+ }
+ // For wide brush, use a circle pattern (Euclidean distance)
+ else if (this.currentTool.size === 3) {
+ // Euclidean distance: √[(x1-x2)² + (y1-y2)²]
+ const distance = Math.sqrt(Math.pow(x - centerX, 2) + Math.pow(y - centerY, 2));
+ if (distance > radius) continue; // Skip if too far away
+ }
+
+ // Find this cell in the DOM
+ const targetCell = this.gameContainer.querySelector(`[data-x="${x}"][data-y="${y}"]`);
+ if (targetCell) {
+ cellsToDust.push(targetCell);
+ }
+ }
+ }
+
+ // Get cell position for particles (center cell)
+ const cellRect = cell.getBoundingClientRect();
+ const particleContainerRect = this.particleContainer.getBoundingClientRect();
+ const cellCenterX = (cellRect.left + cellRect.width / 2) - particleContainerRect.left;
+ const cellCenterY = (cellRect.top + cellRect.height / 2) - particleContainerRect.top;
+
+ // Process all cells to dust
+ cellsToDust.forEach(targetCell => {
+ const cellId = `${targetCell.dataset.x},${targetCell.dataset.y}`;
+ const currentTime = Date.now();
+ const dustLevel = parseInt(targetCell.dataset.dustLevel);
+
+ // Tool intensity affects dusting rate and particle effects
+ const toolIntensity = this.currentTool.size / 3; // 0.33 to 1
+
+ // Only allow dusting every 50-150ms for each cell (based on tool size)
+ const cooldown = 150 - (toolIntensity * 100); // 50ms for wide brush, 150ms for fine
+
+ if (!this.lastDustTime[cellId] || currentTime - this.lastDustTime[cellId] > cooldown) {
+ if (dustLevel < 3) {
+ // Increment dust level with a probability based on tool intensity
+ const dustProbability = toolIntensity * 0.5 + 0.1; // 0.1-0.6 chance based on tool
+
+ if (dustLevel < 1 || Math.random() < dustProbability) {
+ targetCell.dataset.dustLevel = (dustLevel + 1).toString();
+ this.updateCellColor(targetCell);
+
+ // Create dust particles for the current cell or at a position calculated for surrounding cells
+ if (targetCell === cell) {
+ // Center cell - use the already calculated position
+ const hasFingerprint = targetCell.dataset.hasFingerprint === 'true';
+ let particleColor = dustLevel === 1 ? '#666' : (hasFingerprint ? '#1aff1a' : '#aaa');
+ this.createDustParticles(cellCenterX, cellCenterY, toolIntensity, particleColor);
+ } else {
+ // For surrounding cells, calculate their relative position from the center cell
+ const targetCellRect = targetCell.getBoundingClientRect();
+ const targetCellX = (targetCellRect.left + targetCellRect.width / 2) - particleContainerRect.left;
+ const targetCellY = (targetCellRect.top + targetCellRect.height / 2) - particleContainerRect.top;
+
+ const hasFingerprint = targetCell.dataset.hasFingerprint === 'true';
+ let particleColor = dustLevel === 1 ? '#666' : (hasFingerprint ? '#1aff1a' : '#aaa');
+
+ // Create fewer particles for surrounding cells
+ const reducedIntensity = toolIntensity * 0.6;
+ this.createDustParticles(targetCellX, targetCellY, reducedIntensity, particleColor);
+ }
+ }
+ this.lastDustTime[cellId] = currentTime;
+ }
+ }
+ });
+
+ // Update progress after dusting
+ this.checkProgress();
+ }
+
+ // Use the framework's mouseDown handler directly
+ handleMouseDown(e) {
+ // Just start dusting immediately
+ this.handleMouseMove(e);
+ }
+
+ createDustParticles(x, y, intensity, color) {
+ const numParticles = Math.floor(5 + intensity * 5); // 5-10 particles based on intensity
+
+ for (let i = 0; i < numParticles; i++) {
+ const particle = document.createElement('div');
+ const size = Math.random() * 3 + 1; // 1-4px
+ const angle = Math.random() * Math.PI * 2;
+ const distance = Math.random() * 20 * intensity;
+ const duration = Math.random() * 1000 + 500; // 500-1500ms
+
+ particle.style.cssText = `
+ position: absolute;
+ width: ${size}px;
+ height: ${size}px;
+ background: ${color};
+ border-radius: 50%;
+ opacity: ${Math.random() * 0.3 + 0.3};
+ top: ${y}px;
+ left: ${x}px;
+ transform: translate(-50%, -50%);
+ pointer-events: none;
+ z-index: 6;
+ `;
+
+ this.particleContainer.appendChild(particle);
+
+ // Animate the particle
+ const animation = particle.animate([
+ {
+ transform: 'translate(-50%, -50%)',
+ opacity: particle.style.opacity
+ },
+ {
+ transform: `translate(
+ calc(-50% + ${Math.cos(angle) * distance}px),
+ calc(-50% + ${Math.sin(angle) * distance}px)
+ )`,
+ opacity: 0
+ }
+ ], {
+ duration: duration,
+ easing: 'cubic-bezier(0.25, 1, 0.5, 1)'
+ });
+
+ animation.onfinish = () => {
+ particle.remove();
+ };
+ }
+ }
+
+ updateCellColor(cell) {
+ const dustLevel = parseInt(cell.dataset.dustLevel);
+ const hasFingerprint = cell.dataset.hasFingerprint === 'true';
+
+ if (dustLevel === 0) {
+ cell.style.background = 'black';
+ cell.style.boxShadow = 'none';
+ }
+ else if (dustLevel === 1) {
+ cell.style.background = '#444';
+ cell.style.boxShadow = 'inset 0 0 3px rgba(255,255,255,0.2)';
+ }
+ else if (dustLevel === 2) {
+ if (hasFingerprint) {
+ cell.style.background = '#0f0';
+ cell.style.boxShadow = 'inset 0 0 5px rgba(0,255,0,0.5), 0 0 5px rgba(0,255,0,0.3)';
+ } else {
+ cell.style.background = '#888';
+ cell.style.boxShadow = 'inset 0 0 4px rgba(255,255,255,0.3)';
+ }
+ }
+ else {
+ cell.style.background = '#ccc';
+ cell.style.boxShadow = 'inset 0 0 5px rgba(255,255,255,0.5)';
+ }
+ }
+
+ checkProgress() {
+ this.revealedPrints = 0;
+ this.overDusted = 0;
+
+ this.gameContainer.childNodes.forEach(cell => {
+ if (cell.dataset) { // Check if it's a cell element
+ const dustLevel = parseInt(cell.dataset.dustLevel || '0');
+ const hasFingerprint = cell.dataset.hasFingerprint === 'true';
+
+ if (hasFingerprint && dustLevel === 2) this.revealedPrints++;
+ if (dustLevel === 3) this.overDusted++;
+ }
+ });
+
+ // Update progress display
+ this.progressContainer.innerHTML = `
+
+ Found: ${this.revealedPrints}/${this.requiredPrints} required prints
+
+ Over-dusted: ${this.overDusted}/${this.difficultySettings[this.currentDifficulty].maxOverDusted} max
+
+
+
+ `;
+
+ // Check fail condition first
+ if (this.overDusted >= this.difficultySettings[this.currentDifficulty].maxOverDusted) {
+ this.showFinalFailure("Too many over-dusted areas!");
+ return;
+ }
+
+ // Check win condition
+ if (this.revealedPrints >= this.requiredPrints) {
+ this.showFinalSuccess();
+ }
+ }
+
+ showFinalSuccess() {
+ // Calculate quality based on dusting precision
+ const dustPenalty = this.overDusted / this.difficultySettings[this.currentDifficulty].maxOverDusted; // 0-1
+ const coverageBonus = this.revealedPrints / this.totalPrints; // 0-1
+
+ // Higher quality for more coverage and less over-dusting
+ const quality = 0.7 + (coverageBonus * 0.25) - (dustPenalty * 0.15);
+ const qualityPercentage = Math.round(quality * 100);
+ const qualityRating = qualityPercentage >= 95 ? 'Perfect' :
+ qualityPercentage >= 85 ? 'Excellent' :
+ qualityPercentage >= 75 ? 'Good' : 'Acceptable';
+
+ // Build success message with detailed stats
+ const successHTML = `
+
Fingerprint successfully collected!
+
Quality: ${qualityRating} (${qualityPercentage}%)
+
+ Prints revealed: ${this.revealedPrints}/${this.totalPrints}
+ Over-dusted areas: ${this.overDusted}
+ Difficulty: ${this.currentDifficulty.charAt(0).toUpperCase() + this.currentDifficulty.slice(1)}
+
+ `;
+
+ // Use the framework's success message system
+ this.showSuccess(successHTML, true, 2000);
+
+ // Disable further interaction
+ this.gameContainer.style.pointerEvents = 'none';
+
+ // Store result for onComplete callback
+ this.gameResult = {
+ quality: quality,
+ rating: qualityRating
+ };
+ }
+
+ showFinalFailure(reason) {
+ // Build failure message
+ const failureHTML = `
+
${reason}
+
Try again with more careful dusting.
+ `;
+
+ // Use the framework's failure message system
+ this.showFailure(failureHTML, true, 2000);
+
+ // Disable further interaction
+ this.gameContainer.style.pointerEvents = 'none';
+ }
+
+ start() {
+ super.start();
+ console.log("Dusting minigame started");
+
+ // Disable game movement in the main scene
+ if (this.params.scene) {
+ this.params.scene.input.mouse.enabled = false;
+ }
+ }
+
+ complete(success) {
+ // Call parent complete with result
+ super.complete(success, this.gameResult);
+ }
+
+ generateFingerprint(difficulty) {
+ // Existing fingerprint generation logic remains the same
+ const pattern = this.difficultySettings[difficulty].pattern;
+ const numPrints = this.difficultySettings[difficulty].fingerprints;
+ const newFingerprintCells = new Set();
+ const centerX = Math.floor(this.gridSize / 2);
+ const centerY = Math.floor(this.gridSize / 2);
+
+ if (pattern === 'simple') {
+ // Simple oval-like pattern
+ for (let i = 0; i < numPrints; i++) {
+ const angle = (i / numPrints) * Math.PI * 2;
+ const distance = 5 + Math.random() * 3;
+ const x = Math.floor(centerX + Math.cos(angle) * distance);
+ const y = Math.floor(centerY + Math.sin(angle) * distance);
+
+ if (x >= 0 && x < this.gridSize && y >= 0 && y < this.gridSize) {
+ newFingerprintCells.add(`${x},${y}`);
+
+ // Add a few adjacent cells to make it less sparse
+ for (let j = 0; j < 2; j++) {
+ const nx = x + Math.floor(Math.random() * 3) - 1;
+ const ny = y + Math.floor(Math.random() * 3) - 1;
+ if (nx >= 0 && nx < this.gridSize && ny >= 0 && ny < this.gridSize) {
+ newFingerprintCells.add(`${nx},${ny}`);
+ }
+ }
+ }
+ }
+ } else if (pattern === 'medium') {
+ // Medium complexity - spiral pattern with variations
+ for (let i = 0; i < numPrints; i++) {
+ const t = i / numPrints * 5;
+ const distance = 2 + t * 0.8;
+ const noise = Math.random() * 2 - 1;
+ const x = Math.floor(centerX + Math.cos(t * Math.PI * 2) * (distance + noise));
+ const y = Math.floor(centerY + Math.sin(t * Math.PI * 2) * (distance + noise));
+
+ if (x >= 0 && x < this.gridSize && y >= 0 && y < this.gridSize) {
+ newFingerprintCells.add(`${x},${y}`);
+ }
+ }
+
+ // Add whorls and arches
+ for (let i = 0; i < 20; i++) {
+ const angle = (i / 20) * Math.PI * 2;
+ const distance = 7;
+ const x = Math.floor(centerX + Math.cos(angle) * distance);
+ const y = Math.floor(centerY + Math.sin(angle) * distance);
+
+ if (x >= 0 && x < this.gridSize && y >= 0 && y < this.gridSize) {
+ newFingerprintCells.add(`${x},${y}`);
+ }
+ }
+ } else {
+ // Complex pattern - detailed whorls and ridge patterns
+ for (let i = 0; i < numPrints; i++) {
+ // Main loop - create a complex whorl pattern
+ const t = i / numPrints * 8;
+ const distance = 2 + t * 0.6;
+ const noise = Math.sin(t * 5) * 1.5;
+ const x = Math.floor(centerX + Math.cos(t * Math.PI * 2) * (distance + noise));
+ const y = Math.floor(centerY + Math.sin(t * Math.PI * 2) * (distance + noise));
+
+ if (x >= 0 && x < this.gridSize && y >= 0 && y < this.gridSize) {
+ newFingerprintCells.add(`${x},${y}`);
+ }
+
+ // Add bifurcations and ridge endings
+ if (i % 5 === 0) {
+ const bifAngle = t * Math.PI * 2 + Math.PI/4;
+ const bx = Math.floor(x + Math.cos(bifAngle) * 1);
+ const by = Math.floor(y + Math.sin(bifAngle) * 1);
+ if (bx >= 0 && bx < this.gridSize && by >= 0 && by < this.gridSize) {
+ newFingerprintCells.add(`${bx},${by}`);
+ }
+ }
+ }
+
+ // Add delta patterns
+ for (let d = 0; d < 3; d++) {
+ const deltaAngle = (d / 3) * Math.PI * 2;
+ const deltaX = Math.floor(centerX + Math.cos(deltaAngle) * 8);
+ const deltaY = Math.floor(centerY + Math.sin(deltaAngle) * 8);
+
+ for (let r = 0; r < 5; r++) {
+ for (let a = 0; a < 3; a++) {
+ const rayAngle = deltaAngle + (a - 1) * Math.PI/4;
+ const rx = Math.floor(deltaX + Math.cos(rayAngle) * r);
+ const ry = Math.floor(deltaY + Math.sin(rayAngle) * r);
+ if (rx >= 0 && rx < this.gridSize && ry >= 0 && ry < this.gridSize) {
+ newFingerprintCells.add(`${rx},${ry}`);
+ }
+ }
+ }
+ }
+ }
+
+ // Ensure we have at least the minimum number of cells
+ while (newFingerprintCells.size < numPrints) {
+ const x = centerX + Math.floor(Math.random() * 12 - 6);
+ const y = centerY + Math.floor(Math.random() * 12 - 6);
+ if (x >= 0 && x < this.gridSize && y >= 0 && y < this.gridSize) {
+ newFingerprintCells.add(`${x},${y}`);
+ }
+ }
+
+ return newFingerprintCells;
+ }
+
+ cleanup() {
+ super.cleanup();
+
+ // Re-enable game movement
+ if (this.params.scene) {
+ this.params.scene.input.mouse.enabled = true;
+ }
+ }
+ }
+
+ // Register the dusting minigame with the framework
+ MinigameFramework.registerScene('dusting', DustingMinigame);
+
+ // Replacement for the startDustingMinigame function
+ function startDustingMinigame(item) {
+ // Initialize the framework if not already done
+ if (!MinigameFramework.mainGameScene) {
+ MinigameFramework.init(item.scene);
+ }
+
+ // Start the dusting minigame
+ MinigameFramework.startMinigame('dusting', {
+ item: item,
+ scene: item.scene,
+ onComplete: (success, result) => {
+ if (success) {
+ debugLog('DUSTING SUCCESS', result, 1);
+
+ // Add fingerprint to gameState
+ if (!gameState.biometricSamples) {
+ gameState.biometricSamples = [];
+ }
+
+ const sample = {
+ id: generateFingerprintData(item),
+ type: 'fingerprint',
+ owner: item.scenarioData.fingerprintOwner,
+ quality: result.quality, // Quality between 0.7 and ~1.0
+ data: generateFingerprintData(item),
+ timestamp: Date.now()
+ };
+
+ gameState.biometricSamples.push(sample);
+
+ // Mark item as collected
+ if (item.scenarioData) {
+ item.scenarioData.hasFingerprint = false;
+ }
+
+ // Update the biometrics panel and count
+ updateBiometricsPanel();
+ updateBiometricsCount();
+
+ // Show notification
+ gameAlert(`Collected ${sample.owner}'s fingerprint sample (${result.rating} quality)`, 'success', 'Sample Acquired', 3000);
+ } else {
+ debugLog('DUSTING FAILED', null, 2);
+ gameAlert(`Failed to collect the fingerprint sample.`, 'error', 'Dusting Failed', 3000);
+ }
+ }
+ });
+ }