mousehunt-improved 0.97.1

package/src/utils/settings.js

@@ -0,0 +1,260 @@
+import { safeJsonParse } from './json';
+
+let inSafeMode = null;
+
+/**
+ * Check if the extension is in safe mode.
+ *
+ * Safe mode changes settings to defaults. To enable safe mode, add `?safe-mode` to the URL.
+ *
+ * @return {boolean} Whether the extension is in safe mode or not.
+ */
+const isSafeMode = () => {
+  if (null === inSafeMode) {
+    inSafeMode = window.location.search.includes('safe-mode');
+  }
+
+  return inSafeMode;
+};
+
+/**
+ * Parse an encoded value.
+ *
+ * @param {string} value The value to parse.
+ *
+ * @return {string} The parsed value.
+ */
+const parseEncodedValue = (value) => {
+  if ('string' !== typeof value) {
+    return value;
+  }
+
+  if (value.startsWith('data:text/css;base64,')) {
+    return atob(value.replace('data:text/css;base64,', ''));
+  }
+
+  if (value.startsWith('data:text/plain;base64,')) {
+    return atob(value.replace('data:text/plain;base64,', ''));
+  }
+
+  return value;
+};
+
+/**
+ * Get the saved settings.
+ *
+ * @param {string}  key          The key to get.
+ * @param {boolean} defaultValue The default value.
+ * @param {string}  identifier   The identifier for the settings.
+ *
+ * @return {Object} The saved settings.
+ */
+const getSettingDirect = (key = null, defaultValue = null, identifier = 'mousehunt-improved-settings') => {
+  if (isSafeMode()) {
+    return defaultValue;
+  }
+
+  // Grab the local storage data.
+  let settings = safeJsonParse(localStorage.getItem(identifier), {}, (error) => {
+    console.error('Error parsing settings:', error); // eslint-disable-line no-console
+  });
+
+  if (! settings || 'object' !== typeof settings) {
+    settings = {};
+  }
+
+  if (0 === Object.keys(settings).length) {
+    const backup = localStorage.getItem('mousehunt-improved-settings-backup');
+    if (backup) {
+      const parsedBackup = safeJsonParse(backup, {}, (error) => {
+        console.error('Error parsing settings backup:', error); // eslint-disable-line no-console
+      });
+
+      if (parsedBackup && 'object' === typeof parsedBackup) {
+        settings = parsedBackup;
+      }
+    }
+  }
+
+  // If we didn't get a key passed in, we want all the settings.
+  if (! key) {
+    return settings;
+  }
+
+  // If the key contains a period, then it's a group and key, otherwise it's just a key.
+  if (! key.includes('.')) {
+    if (settings[key] === undefined) {
+      return defaultValue;
+    }
+
+    return parseEncodedValue(settings[key]);
+  }
+
+  const groupAndKey = getGroupAndKey(key);
+
+  if (! groupAndKey.group) {
+    if (settings[groupAndKey.key] === undefined) {
+      return defaultValue;
+    }
+
+    return parseEncodedValue(settings[groupAndKey.key]);
+  }
+
+  const groupSettings = settings[groupAndKey.group] || {};
+
+  if (groupSettings[groupAndKey.key] === undefined) {
+    return defaultValue;
+  }
+
+  return parseEncodedValue(groupSettings[groupAndKey.key]);
+};
+
+/**
+ * Save a setting.
+ *
+ * @param {string}  key        The setting key.
+ * @param {boolean} value      The setting value.
+ * @param {string}  identifier The identifier for the settings.
+ */
+const saveSettingDirect = (key, value, identifier = 'mousehunt-improved-settings') => {
+  if (isSafeMode()) {
+    return;
+  }
+
+  // Grab all the settings, set the new one, and save them.
+  const settings = getSettingDirect(null, {}, identifier);
+
+  const groupAndKey = getGroupAndKey(key);
+
+  if (groupAndKey.group) {
+    if (! settings[groupAndKey.group]) {
+      settings[groupAndKey.group] = {};
+    }
+
+    settings[groupAndKey.group][groupAndKey.key] = value;
+  } else {
+    settings[key] = value;
+  }
+
+  localStorage.setItem(identifier, JSON.stringify(settings));
+};
+
+/**
+ * Get the group and key from a composite key.
+ *
+ * @param {string} key The composite key.
+ *
+ * @return {Object} The group and key.
+ */
+const getGroupAndKey = (key) => {
+  const split = key.split('.');
+
+  // If there's only one part, then return it as the key.
+  if (split.length === 1) {
+    return {
+      group: null,
+      key: split[0],
+    };
+  }
+
+  if (split[0] === 'location-huds-enabled') {
+    return {
+      group: 'location-huds-enabled',
+      key: split[1],
+    };
+  }
+
+  return {
+    group: `${split[0]}-settings`,
+    key: split[1],
+  };
+};
+
+/**
+ * Wrapper for getting a setting.
+ *
+ * @param {string}  key          Key of the setting.
+ * @param {boolean} defaultValue Default value of the setting.
+ *
+ * @return {boolean} Value of the setting.
+ */
+const getSetting = (key, defaultValue = false) => {
+  return getSettingDirect(key, defaultValue, 'mousehunt-improved-settings');
+};
+
+/**
+ * Delete a setting.
+ *
+ * @param {string} key The setting key.
+ */
+const deleteSetting = (key) => {
+  const settings = getSettings();
+
+  const groupAndKey = getGroupAndKey(key);
+  if (groupAndKey.group) {
+    if (settings[groupAndKey.group]) {
+      delete settings[groupAndKey.group][groupAndKey.key];
+    } else {
+      delete settings[groupAndKey.key];
+    }
+  } else {
+    delete settings[key];
+  }
+
+  localStorage.setItem('mousehunt-improved-settings', JSON.stringify(settings));
+};
+
+const migrateSetting = (oldKey, newKey) => {
+  const oldValue = getSetting(oldKey, null);
+  if (null !== oldValue) {
+    saveSetting(newKey, oldValue);
+    deleteSetting(oldKey);
+  }
+};
+
+/**
+ * Get the saved settings.
+ *
+ * @return {Object} The saved settings.
+ */
+const getSettings = () => {
+  if (isSafeMode()) {
+    return {};
+  }
+
+  const settings = localStorage.getItem('mousehunt-improved-settings');
+  if (! settings) {
+    return {};
+  }
+
+  const parsedSettings = safeJsonParse(settings, {}, (error) => {
+    console.error('Error parsing settings:', error); // eslint-disable-line no-console
+  });
+
+  return parsedSettings && 'object' === typeof parsedSettings ? parsedSettings : {};
+};
+
+/**
+ * Wrapper for saving a setting.
+ *
+ * @param {string}  key   Key of the setting.
+ * @param {boolean} value Value of the setting.
+ *
+ * @return {boolean} Value of the setting.
+ */
+const saveSetting = (key, value) => {
+  saveSettingDirect(key, value, 'mousehunt-improved-settings');
+
+  return value;
+};
+
+export {
+  parseEncodedValue,
+  getSettingDirect,
+  saveSettingDirect,
+  getSetting,
+  saveSetting,
+  migrateSetting,
+  getSettings,
+  deleteSetting
+};

package/src/utils/shared/fiery-warpath.js

@@ -0,0 +1,88 @@
+/**
+ * Get the current wave of the Fiery Warpath.
+ *
+ * @return {number} The current wave.
+ */
+const getFieryWarpathWave = () => {
+  let wave = 0;
+
+  const waveEl = document.querySelector('.warpathHUD.showPortal');
+  if (waveEl) {
+    // get the classlist and find the one that starts with 'wave'
+    const waveClass = [...waveEl.classList].find((className) => className.startsWith('wave'));
+    wave = waveClass.replace('wave', '').replace('_', '');
+  }
+
+  return wave;
+};
+
+/**
+ * Get the current streak of the Fiery Warpath.
+ *
+ * @return {number} The current streak.
+ */
+const getFieryWarpathStreak = () => {
+  let streak = 0;
+
+  const streakEl = document.querySelector('.warpathHUD-streakBoundingBox');
+  if (streakEl) {
+    streak = Number.parseInt(streakEl.innerText.replaceAll('\n', ' ').replace(' 0', '').trim()) || 0;
+  }
+
+  return streak;
+};
+
+/**
+ * Get the remaining mouse population in the specified wave.
+ *
+ * @param {number} [wave] The wave number. Defaults to the current wave.
+ *
+ * @return {number} The number of mice remaining.
+ */
+const getFieryWarpathRemainingInWave = (wave) => {
+  if (! wave) {
+    wave = getFieryWarpathWave();
+  }
+
+  let remaining = 0;
+
+  const remainingEl = document.querySelectorAll(`.warpathHUD-wave.wave_${wave} .warpathHUD-wave-mouse-population`);
+  if (remainingEl.length) {
+    // sum all the values that have an innerText
+    remaining = [...remainingEl].reduce((sum, el) => {
+      if (el.innerText) {
+        sum += Number.parseInt(el.innerText);
+      }
+      return sum;
+    }, 0);
+  }
+
+  return remaining;
+};
+
+/**
+ * Get the current percentage of the Fiery Warpath.
+ *
+ * @return {number} The current percentage.
+ */
+const getFieryWarpathPercent = () => {
+  let percent = 0;
+
+  const percentEl = document.querySelector('.warpathHUD-moraleBar span');
+  if (percentEl) {
+    // get the style attribute and parse the width value.
+    const style = percentEl.getAttribute('style');
+    if (style) {
+      percent = Number.parseInt(style.replace('width:', '').replace('%;', ''));
+    }
+  }
+
+  return percent;
+};
+
+export {
+  getFieryWarpathWave,
+  getFieryWarpathStreak,
+  getFieryWarpathRemainingInWave,
+  getFieryWarpathPercent
+};

package/src/utils/shared/memory-game.js

@@ -0,0 +1,231 @@
+import { addStyles, makeElement, makeElementDraggable } from '@utils';
+import styles from '../styles/memory-game.css';
+
+let hasInitialized = false;
+
+/**
+ * Launch an in-page memory matching game.
+ *
+ * @param {Object} options         Configuration options.
+ * @param {Array}  options.items   Array of item objects to use for cards.
+ * @param {string} [options.title] Title displayed on the game overlay.
+ * @param {string} [options.mode]  Difficulty mode (`easy`, `hard`, `extreme`, `nope`).
+ */
+const startMemoryGame = ({ items = [], title = 'Memory Matching Game', mode = 'easy' }) => {
+  if (! hasInitialized) {
+    addStyles(styles, 'mh-improved-memory-game');
+    hasInitialized = true;
+  }
+
+  if (! items.length) {
+    return;
+  }
+
+  let cardCount = 8; // Default to easy mode
+  switch (mode) {
+  case 'hard':
+    cardCount = 4 * 4; break;
+  case 'extreme':
+    cardCount = 4 * 6; break;
+  case 'nope':
+    cardCount = 70; break;
+  }
+
+  const createGameOverlay = () => {
+    return makeElement('div', ['mh-improved-memory-game', `mh-improved-memory-game-${mode}`],
+      `<div class="mh-improved-memory-game-header">
+        <h1>${title}</h1>
+        <svg class="mh-improved-memory-close" viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.5">
+          <path d="M18 6L6 18M6 6l12 12"></path>
+        </svg>
+      </div>
+      <div class="mh-improved-memory-grid"></div>
+      <div class="mh-improved-memory-message">
+        Find all matching pairs!
+      </div>`
+    );
+  };
+
+  let flippedCards = [];
+  let matchedPairs = 0;
+  let moves = 0;
+  let hintClickCount = 0;
+
+  const resetGame = () => {
+    let itemsToUse = items;
+    if (itemsToUse.length > cardCount) {
+      itemsToUse = itemsToUse.sort(() => Math.random() - 0.5).slice(0, cardCount);
+    }
+
+    // Shuffle cards and reset game state
+    const cards = [...itemsToUse, ...itemsToUse].sort(() => Math.random() - 0.5);
+    flippedCards = [];
+    matchedPairs = 0;
+    moves = 0;
+    hintClickCount = 0; // Reset hint counter
+
+    // Clear and repopulate the grid
+    grid.innerHTML = '';
+    cards.forEach((item, index) => {
+      const card = makeElement('div', 'mh-improved-memory-card',
+        `<div class="mh-improved-card-front">?</div>
+        <div class="mh-improved-card-back">
+          <img src="${item.image || item.images.upscaled || item.images.best}" alt="${item.name}" title="${item.name}" />
+          <span class="mh-improved-card-name">${item.name}</span>
+        </div>`
+      );
+
+      card.setAttribute('data-index', index);
+      card.setAttribute('data-symbol', item.id);
+
+      card.addEventListener('click', () => flipCard(card));
+      grid.append(card);
+    });
+
+    // Reset message
+    const message = gameOverlay.querySelector('.mh-improved-memory-message');
+    message.innerHTML = 'Find all matching pairs!';
+    gameOverlay.classList.remove('victory');
+  };
+
+  // Create or reuse the game overlay
+  let gameOverlay = document.querySelector('.mh-improved-memory-game');
+  if (! gameOverlay) {
+    gameOverlay = createGameOverlay();
+    document.body.append(gameOverlay);
+    makeElementDraggable(
+      `.mh-improved-memory-game-${mode}`,
+      '.mh-improved-memory-game-header',
+      mode === 'nope' ? 95 : 200,
+      mode === 'nope' ? 20 : 100
+    );
+  }
+
+  const grid = gameOverlay.querySelector('.mh-improved-memory-grid');
+  const message = gameOverlay.querySelector('.mh-improved-memory-message');
+
+  // Add hint click listener to message
+  message.addEventListener('click', () => {
+    if (gameOverlay.classList.contains('victory')) {
+      return; // Don't give hints when game is won
+    }
+
+    hintClickCount++;
+    if (hintClickCount >= 3) {
+      giveHint();
+      hintClickCount = 0; // Reset counter after giving hint
+    }
+  });
+
+  resetGame();
+
+  const giveHint = () => {
+    if (flippedCards.length >= 2 || matchedPairs === cardCount) {
+      return;
+    }
+
+    // Find all unmatched cards
+    const unmatchedCards = [...grid.querySelectorAll('.mh-improved-memory-card:not(.matched)')];
+
+    if (unmatchedCards.length === 0) {
+      return;
+    }
+
+    // If one card is flipped, find its match
+    if (flippedCards.length === 1) {
+      const symbol = flippedCards[0].dataset.symbol;
+      const matchingCard = grid.querySelector(`.mh-improved-memory-card[data-symbol="${symbol}"]:not(.flipped):not(.matched)`);
+      if (matchingCard) {
+        matchingCard.classList.add('hint');
+        setTimeout(() => matchingCard.classList.remove('hint'), 1000);
+        return;
+      }
+    }
+
+    // Otherwise, highlight a random pair
+    const symbols = new Set();
+    const availableCards = [];
+
+    unmatchedCards.forEach((card) => {
+      const symbol = card.dataset.symbol;
+      if (! symbols.has(symbol)) {
+        symbols.add(symbol);
+        const pair = unmatchedCards.filter((c) => c.dataset.symbol === symbol);
+        if (pair.length === 2) {
+          availableCards.push(pair);
+        }
+      }
+    });
+
+    if (availableCards.length > 0) {
+      const randomPair = availableCards[Math.floor(Math.random() * availableCards.length)];
+      randomPair.forEach((card) => {
+        card.classList.add('hint');
+      });
+
+      setTimeout(() => {
+        randomPair.forEach((card) => {
+          card.classList.remove('hint');
+        });
+      }, 1000);
+    }
+  };
+
+  const flipCard = (card) => {
+    if (card.classList.contains('flipped') || card.classList.contains('matched')) {
+      return;
+    }
+    if (flippedCards.length >= 2) {
+      return;
+    }
+
+    card.classList.add('flipped');
+    flippedCards.push(card);
+
+    if (flippedCards.length === 2) {
+      moves++;
+      setTimeout(checkMatch, 800);
+    }
+  };
+
+  const checkMatch = () => {
+    const [card1, card2] = flippedCards;
+
+    if (card1.dataset.symbol === card2.dataset.symbol) {
+      card1.classList.add('matched');
+      card2.classList.add('matched');
+      matchedPairs++;
+
+      if (matchedPairs === cardCount) {
+        setTimeout(() => {
+          const messageEl = gameOverlay.querySelector('.mh-improved-memory-message');
+          gameOverlay.classList.add('victory');
+          message.innerHTML = `
+            <span class="mh-improved-message-text">
+              🎉 Completed in ${moves} moves.
+            </span>
+            <a class="mh-improved-memory-play-again" href="#">Play Again</a>`;
+
+          const playAgain = messageEl.querySelector('.mh-improved-memory-play-again');
+          if (playAgain) {
+            playAgain.addEventListener('click', (e) => {
+              e.preventDefault();
+              resetGame();
+            });
+          }
+        }, 500);
+      }
+    } else {
+      card1.classList.remove('flipped');
+      card2.classList.remove('flipped');
+    }
+
+    flippedCards = [];
+  };
+
+  gameOverlay.querySelector('.mh-improved-memory-close').addEventListener('click', () => {
+    gameOverlay.remove();
+  });
+};
+
+export { startMemoryGame };