@@ -114,6 +115,7 @@ export class PasswordMinigame extends MinigameScene {
+
@@ -268,6 +270,8 @@ export class PasswordMinigame extends MinigameScene {
this.submitPassword();
} else if (keyValue === 'Escape') {
this.cancelPassword();
+ } else if (keyValue === 'Shift') {
+ this.toggleCapsLock();
} else if (keyValue === 'Backspace') {
this.passwordField.value = this.passwordField.value.slice(0, -1);
this.gameData.password = this.passwordField.value;
@@ -275,7 +279,8 @@ export class PasswordMinigame extends MinigameScene {
this.passwordField.value += ' ';
this.gameData.password = this.passwordField.value;
} else if (keyValue && keyValue.length === 1) {
- this.passwordField.value += keyValue;
+ const char = this.gameData.capsLock ? keyValue.toUpperCase() : keyValue.toLowerCase();
+ this.passwordField.value += char;
this.gameData.password = this.passwordField.value;
}
@@ -283,6 +288,18 @@ export class PasswordMinigame extends MinigameScene {
this.passwordField.focus();
}
+ toggleCapsLock() {
+ this.gameData.capsLock = !this.gameData.capsLock;
+ const shiftKey = document.getElementById('shift-key');
+ if (shiftKey) {
+ if (this.gameData.capsLock) {
+ shiftKey.classList.add('active');
+ } else {
+ shiftKey.classList.remove('active');
+ }
+ }
+ }
+
submitPassword() {
if (!this.gameState.isActive) return;
diff --git a/js/minigames/text-file/text-file-minigame.js b/js/minigames/text-file/text-file-minigame.js
new file mode 100644
index 0000000..6287090
--- /dev/null
+++ b/js/minigames/text-file/text-file-minigame.js
@@ -0,0 +1,377 @@
+import { MinigameScene } from '../framework/base-minigame.js';
+
+export class TextFileMinigame extends MinigameScene {
+ constructor(container, params) {
+ super(container, params);
+
+ // Ensure params is an object with default values
+ const safeParams = params || {};
+
+ // Initialize text file specific state
+ this.textFileData = {
+ fileName: safeParams.fileName || 'Unknown File',
+ fileContent: safeParams.fileContent || '',
+ fileType: safeParams.fileType || 'text',
+ observations: safeParams.observations || '',
+ source: safeParams.source || 'Unknown Source'
+ };
+ }
+
+ init() {
+ // Call parent init to set up basic UI structure
+ super.init();
+
+ // Customize the header
+ this.headerElement.innerHTML = `
+
📄 ${this.textFileData.fileName}
+
Viewing text file contents
+ `;
+
+ // Add notebook button to minigame controls (before cancel button)
+ if (this.controlsElement) {
+ const notebookBtn = document.createElement('button');
+ notebookBtn.className = 'minigame-button';
+ notebookBtn.id = 'minigame-notebook';
+ notebookBtn.innerHTML = '📝 Add to Notebook';
+ this.controlsElement.appendChild(notebookBtn);
+
+ // Change cancel button text to "Close"
+ const cancelBtn = document.getElementById('minigame-cancel');
+ if (cancelBtn) {
+ cancelBtn.innerHTML = 'Close';
+ }
+ }
+
+ // Set up the text file interface
+ this.setupTextFileInterface();
+
+ // Set up event listeners
+ this.setupEventListeners();
+ }
+
+ setupTextFileInterface() {
+ // Create the text file interface with Mac-style window
+ this.gameContainer.innerHTML = `
+
+
+
+
+
+
+
+
+ ${this.formatFileContent()}
+
+
+
+ ${this.textFileData.observations ? `
+
+
📋 Observations:
+
${this.textFileData.observations}
+
+ ` : ''}
+
+ `;
+
+ // Get references to important elements
+ this.fileContent = document.getElementById('file-content');
+ this.copyBtn = document.getElementById('copy-btn');
+ this.selectAllBtn = document.getElementById('select-all-btn');
+
+ // Get window control references
+ this.closeBtn = this.gameContainer.querySelector('.window-control.close');
+ this.minimizeBtn = this.gameContainer.querySelector('.window-control.minimize');
+ this.maximizeBtn = this.gameContainer.querySelector('.window-control.maximize');
+ }
+
+ formatFileContent() {
+ // Format the file content for display
+ let content = this.textFileData.fileContent;
+
+ // Escape HTML characters
+ content = content.replace(/&/g, '&')
+ .replace(//g, '>')
+ .replace(/"/g, '"')
+ .replace(/'/g, ''');
+
+ // Convert line breaks to
tags
+ content = content.replace(/\n/g, '
');
+
+ // Wrap in a pre element to preserve formatting
+ return `
${content}`;
+ }
+
+ getFileSize() {
+ // Calculate approximate file size
+ const bytes = new Blob([this.textFileData.fileContent]).size;
+ if (bytes < 1024) {
+ return `${bytes} B`;
+ } else if (bytes < 1024 * 1024) {
+ return `${(bytes / 1024).toFixed(1)} KB`;
+ } else {
+ return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+ }
+ }
+
+ setupEventListeners() {
+ // Window controls
+ this.addEventListener(this.closeBtn, 'click', () => {
+ this.complete(false);
+ });
+
+ this.addEventListener(this.minimizeBtn, 'click', () => {
+ // For now, just show a message (could implement minimize functionality later)
+ this.showSuccess("Minimize functionality not implemented", false, 2000);
+ });
+
+ this.addEventListener(this.maximizeBtn, 'click', () => {
+ // For now, just show a message (could implement maximize functionality later)
+ this.showSuccess("Maximize functionality not implemented", false, 2000);
+ });
+
+ // Copy button
+ this.addEventListener(this.copyBtn, 'click', () => {
+ this.copyToClipboard();
+ });
+
+ // Select all button
+ this.addEventListener(this.selectAllBtn, 'click', () => {
+ this.selectAllText();
+ });
+
+ // Notebook button (in minigame controls)
+ const notebookBtn = document.getElementById('minigame-notebook');
+ if (notebookBtn) {
+ this.addEventListener(notebookBtn, 'click', () => {
+ this.addToNotebook();
+ });
+ }
+
+ // Keyboard controls
+ this.addEventListener(document, 'keydown', (event) => {
+ this.handleKeyPress(event);
+ });
+
+ // Double-click to select all
+ this.addEventListener(this.fileContent, 'dblclick', () => {
+ this.selectAllText();
+ });
+ }
+
+ handleKeyPress(event) {
+ if (!this.gameState.isActive) return;
+
+ // Handle Ctrl+A for select all
+ if (event.ctrlKey && event.key === 'a') {
+ event.preventDefault();
+ this.selectAllText();
+ }
+
+ // Handle Ctrl+C for copy (when text is selected)
+ if (event.ctrlKey && event.key === 'c') {
+ // Let the default behavior handle copying selected text
+ return;
+ }
+
+ // Handle Escape to close
+ if (event.key === 'Escape') {
+ event.preventDefault();
+ this.complete(false);
+ }
+ }
+
+ copyToClipboard() {
+ try {
+ // Use the modern clipboard API if available
+ if (navigator.clipboard && window.isSecureContext) {
+ navigator.clipboard.writeText(this.textFileData.fileContent).then(() => {
+ this.showSuccess("File content copied to clipboard!", false, 2000);
+ }).catch(err => {
+ console.error('Failed to copy to clipboard:', err);
+ this.fallbackCopyToClipboard();
+ });
+ } else {
+ // Fallback for older browsers or non-secure contexts
+ this.fallbackCopyToClipboard();
+ }
+ } catch (error) {
+ console.error('Copy failed:', error);
+ this.fallbackCopyToClipboard();
+ }
+ }
+
+ fallbackCopyToClipboard() {
+ // Create a temporary textarea element
+ const textArea = document.createElement('textarea');
+ textArea.value = this.textFileData.fileContent;
+ textArea.style.position = 'fixed';
+ textArea.style.left = '-999999px';
+ textArea.style.top = '-999999px';
+ document.body.appendChild(textArea);
+
+ try {
+ textArea.focus();
+ textArea.select();
+ const successful = document.execCommand('copy');
+
+ if (successful) {
+ this.showSuccess("File content copied to clipboard!", false, 2000);
+ } else {
+ this.showFailure("Failed to copy to clipboard", false, 2000);
+ }
+ } catch (err) {
+ console.error('Fallback copy failed:', err);
+ this.showFailure("Copy not supported on this browser", false, 2000);
+ } finally {
+ document.body.removeChild(textArea);
+ }
+ }
+
+ selectAllText() {
+ // Select all text in the file content
+ const range = document.createRange();
+ range.selectNodeContents(this.fileContent);
+ const selection = window.getSelection();
+ selection.removeAllRanges();
+ selection.addRange(range);
+
+ this.showSuccess("All text selected", false, 1000);
+ }
+
+ addToNotebook() {
+ // Check if there's content to add
+ if (!this.textFileData.fileContent || this.textFileData.fileContent.trim() === '') {
+ this.showFailure("No content to add to notebook", false, 2000);
+ return;
+ }
+
+ // Create comprehensive notebook content
+ const notebookContent = this.formatContentForNotebook();
+ const notebookTitle = `Text File - ${this.textFileData.fileName}`;
+ const notebookObservations = this.textFileData.observations ||
+ `Text file "${this.textFileData.fileName}" from ${this.textFileData.source}`;
+
+ // Check if notes minigame is available
+ if (window.startNotesMinigame) {
+ // Store the text file state globally so we can return to it
+ const textFileState = {
+ fileName: this.textFileData.fileName,
+ fileContent: this.textFileData.fileContent,
+ fileType: this.textFileData.fileType,
+ observations: this.textFileData.observations,
+ source: this.textFileData.source,
+ params: this.params
+ };
+
+ window.pendingTextFileReturn = textFileState;
+
+ // Create a text file item for the notes minigame
+ const textFileItem = {
+ scenarioData: {
+ type: 'text_file',
+ name: notebookTitle,
+ text: notebookContent,
+ observations: notebookObservations,
+ important: true // Mark as important since it's from a file
+ }
+ };
+
+ // Start notes minigame - it will handle returning to text file via returnToTextFileAfterNotes
+ window.startNotesMinigame(
+ textFileItem,
+ notebookContent,
+ notebookObservations,
+ null, // Let notes minigame auto-navigate to the newly added note
+ false, // Don't auto-add to inventory
+ false // Don't auto-close
+ );
+
+ this.showSuccess("Added file content to notebook", false, 2000);
+ } else {
+ this.showFailure("Notebook not available", false, 2000);
+ }
+ }
+
+ formatContentForNotebook() {
+ let content = `Text File: ${this.textFileData.fileName}\n`;
+ content += `Source: ${this.textFileData.source}\n`;
+ content += `Type: ${this.textFileData.fileType.toUpperCase()}\n`;
+ content += `Date: ${new Date().toLocaleString()}\n\n`;
+ content += `${'='.repeat(50)}\n\n`;
+ content += `FILE CONTENTS:\n`;
+ content += `${'-'.repeat(20)}\n\n`;
+ content += this.textFileData.fileContent;
+ content += `\n\n${'='.repeat(50)}\n`;
+ content += `End of File: ${this.textFileData.fileName}`;
+
+ return content;
+ }
+
+ start() {
+ // Call parent start
+ super.start();
+
+ console.log("Text file minigame started");
+ console.log("File:", this.textFileData.fileName);
+ console.log("Content length:", this.textFileData.fileContent.length);
+ }
+
+ cleanup() {
+ // Call parent cleanup (handles event listeners)
+ super.cleanup();
+ }
+}
+
+// Function to return to text file after notes minigame (similar to container pattern)
+export function returnToTextFileAfterNotes() {
+ console.log('Returning to text file after notes minigame');
+
+ // Check if there's a pending text file return
+ if (window.pendingTextFileReturn) {
+ const textFileState = window.pendingTextFileReturn;
+
+ // Clear the pending return state
+ window.pendingTextFileReturn = null;
+
+ // Start the text file minigame with the stored state
+ if (window.MinigameFramework) {
+ window.MinigameFramework.startMinigame('text-file', null, {
+ title: `Text File - ${textFileState.fileName}`,
+ fileName: textFileState.fileName,
+ fileContent: textFileState.fileContent,
+ fileType: textFileState.fileType,
+ observations: textFileState.observations,
+ source: textFileState.source,
+ onComplete: (success, result) => {
+ console.log('Text file minigame completed:', success, result);
+ }
+ });
+ }
+ } else {
+ console.warn('No pending text file return state found');
+ }
+}
diff --git a/js/systems/interactions.js b/js/systems/interactions.js
index af060f8..ea50632 100644
--- a/js/systems/interactions.js
+++ b/js/systems/interactions.js
@@ -302,6 +302,33 @@ export function handleObjectInteraction(sprite) {
}
}
+ // For text_file type objects, use the text file minigame
+ if (data.type === 'text_file' && data.text) {
+ console.log('Text file object detected:', { type: data.type, name: data.name, text: data.text });
+ // Start the text file minigame
+ if (window.MinigameFramework) {
+ // Initialize the framework if not already done
+ if (!window.MinigameFramework.mainGameScene && window.game) {
+ window.MinigameFramework.init(window.game);
+ }
+
+ const minigameParams = {
+ title: `Text File - ${data.name || 'Unknown File'}`,
+ fileName: data.name || 'Unknown File',
+ fileContent: data.text,
+ fileType: data.fileType || 'text',
+ observations: data.observations,
+ source: data.source || 'Unknown Source',
+ onComplete: (success, result) => {
+ console.log('Text file minigame completed:', success, result);
+ }
+ };
+
+ window.MinigameFramework.startMinigame('text-file', null, minigameParams);
+ return; // Exit early since minigame handles the interaction
+ }
+ }
+
if (data.readable && data.text) {
message += `Text: ${data.text}\n`;
diff --git a/password-minigame-example.json b/password-minigame-example.json
index f38e988..ee49765 100644
--- a/password-minigame-example.json
+++ b/password-minigame-example.json
@@ -85,8 +85,10 @@
"lockType": "password",
"requires": "desktop123",
"showHint": false,
- "showKeyboard": false,
+ "showKeyboard": true,
"maxAttempts": 3,
+ "postitNote": "Password: desktop123",
+ "showPostit": true,
"locked": true,
"contents": [
{
@@ -112,7 +114,7 @@
"observations": "A digital encryption key file."
}
],
- "observations": "An office computer with desktop access. Desktop mode will be automatically enabled."
+ "observations": "An office computer with desktop access. Desktop mode will be automatically enabled. Password is on the sticky note!"
},
{
"id": "tablet_device",
@@ -127,6 +129,8 @@
"showHint": false,
"showKeyboard": true,
"maxAttempts": 3,
+ "postitNote": "Tablet password: tablet2024",
+ "showPostit": true,
"locked": true,
"contents": [
{
@@ -145,7 +149,7 @@
"observations": "Sensitive financial information."
}
],
- "observations": "An executive tablet device. Desktop mode will be automatically enabled."
+ "observations": "An executive tablet device. Desktop mode will be automatically enabled. Password is written on the sticky note."
}
],
"victoryConditions": [
diff --git a/scenarios/ceo_exfil.json b/scenarios/ceo_exfil.json
index 3deeea9..ca9fb76 100644
--- a/scenarios/ceo_exfil.json
+++ b/scenarios/ceo_exfil.json
@@ -36,23 +36,17 @@
"showKeyboard": true,
"maxAttempts": 3,
"locked": true,
- "requires": "password",
+ "requires": "secret123",
"observations": "The reception's computer, currently locked",
+ "postitNote": "Password: secret123",
+ "showPostit": true,
"contents": [
{
- "type": "notes",
- "name": "Private Note",
- "takeable": true,
+ "type": "text_file",
+ "name": "Private",
+ "takeable": false,
"readable": true,
- "text": "Closet keypad code: 7391 - Must move evidence to safe before audit",
- "observations": "A hastily written note on expensive paper"
- },
- {
- "type": "key",
- "name": "Safe Key",
- "takeable": true,
- "key_id": "safe_key:52,29,44,37",
- "observations": "A heavy-duty safe key hidden behind server equipment"
+ "text": "Closet keypad code: 7391 - Must move evidence to safe before audit"
}
]
},
@@ -144,8 +138,14 @@
"type": "pc",
"name": "Office Computer",
"takeable": false,
- "requires": "password",
- "observations": "A standard office computer"
+ "lockType": "password",
+ "requires": "office2024",
+ "showKeyboard": true,
+ "maxAttempts": 3,
+ "locked": true,
+ "postitNote": "Password: office2024",
+ "showPostit": true,
+ "observations": "A standard office computer with a sticky note on the monitor"
},
{
"type": "notes",
@@ -212,7 +212,14 @@
"type": "pc",
"name": "CEO Computer",
"takeable": false,
- "observations": "The CEO's laptop, still warm - recently used"
+ "lockType": "password",
+ "requires": "ceo2024",
+ "showKeyboard": true,
+ "maxAttempts": 3,
+ "locked": true,
+ "postitNote": "Password: ceo2024",
+ "showPostit": true,
+ "observations": "The CEO's laptop, still warm - recently used. A sticky note is attached to the screen."
},
{
"type": "suitcase",
diff --git a/test-container-interactive-items.html b/test-container-interactive-items.html
new file mode 100644
index 0000000..6c9880c
--- /dev/null
+++ b/test-container-interactive-items.html
@@ -0,0 +1,269 @@
+
+
+
+
+
+
Container Interactive Items Test
+
+
+
+
+
+
+
+
📦 Container Interactive Items Test
+
+
+
Test Instructions:
+
1. Click the test buttons below to launch different container scenarios
+
2. Test clicking on interactive items within containers
+
3. Verify that interactive items trigger their respective minigames
+
4. Test that takeable items still go to inventory
+
+
+
+
+
+
+
+
+
+
+
+
Expected Behavior:
+
• Interactive items (notes, text_file, phone, workstation) should trigger their minigames
+
• Takeable items (keys, etc.) should go to inventory
+
• After minigame completion, should return to container
+
• Container should show remaining items after interaction
+
+
+
+
+
+
+
+
+
diff --git a/test-password-minigame.html b/test-password-minigame.html
index 3af199b..a0421d0 100644
--- a/test-password-minigame.html
+++ b/test-password-minigame.html
@@ -8,6 +8,7 @@
+
+
+
+
+
📄 Text File Minigame Test
+
+
+
Test Instructions:
+
1. Click the test buttons below to launch different text file scenarios
+
2. Test the "Add to Notebook" functionality
+
3. Test copy and select all features
+
4. Test keyboard shortcuts (Ctrl+A, Ctrl+C, Escape)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Expected Behavior:
+
• Text file minigame should open with Mac-style window decorations
+
• VT323 font should be used for all text content
+
• Black text on white background (clean, readable interface)
+
• Window controls (close, minimize, maximize) should be functional
+
• "Add to Notebook" button should work (if notes minigame is available)
+
• Copy and Select All buttons should function
+
• Escape key should close the minigame
+
+
+
+
+
+
+
+
+