mousehunt-improved 0.97.1

package/src/modules/location-dashboard/index.js

@@ -0,0 +1,536 @@
+import {
+  addStyles,
+  createPopup,
+  dataGet,
+  dataSet,
+  debug,
+  debuglog,
+  doEvent,
+  getData,
+  isUserTitleAtLeast,
+  makeElement,
+  makeMhButton,
+  onEvent,
+  onRequest,
+  sessionSet,
+  sleep,
+  travelTo
+} from '@utils';
+
+import styles from './styles.css';
+
+import { getFieryWarpathText, setFieryWarpathData } from './locations/desert-warpath';
+import { getSeasonalGardenText, setSeasonalGardenData } from './locations/seasonal-garden';
+import { getZugzwangTowerText, setZugzwangTowerData } from './locations/zugzwang-tower';
+import getAfterwordAcresText from './locations/afterword-acres';
+import getBountifulBeanstalkText from './locations/bountiful-beanstalk';
+import getBristleWoodsRiftText from './locations/rift-bristle-woods';
+import getBurroughsRiftText from './locations/rift-burroughs';
+import getDraconicDepthsText from './locations/draconic-depths';
+import getEpilogueFallsText from './locations/epilogue-falls';
+import getFloatingIslandsText from './locations/floating-islands';
+import getForewordFarmText from './locations/foreword-farm';
+import getFortRoxText from './locations/fort-rox';
+import getFuromaRiftText from './locations/rift-furoma';
+import getIcebergText from './locations/iceberg';
+import getLabyrinthText from './locations/labyrinth';
+import getLivingGardenText from './locations/desert-oasis';
+import getLostCityText from './locations/lost-city';
+import getMousoleumText from './locations/mousoleum';
+import getMoussuPicchuText from './locations/moussu-picchu';
+import getQuesoGeyserText from './locations/queso-geyser';
+import getSandDunesText from './locations/sand-dunes';
+import getSchoolOfSorceryText from './locations/school-of-sorcery';
+import getSunkenCityText from './locations/sunken-city';
+import getTableOfContentsText from './locations/table-of-contents';
+import getToxicSpillText from './locations/pollution-outbreak';
+import getValourRiftText from './locations/rift-valour';
+import getWhiskerWoodsRiftText from './locations/whisker-woods-rift';
+import getZokorText from './locations/ancient-city';
+
+/**
+ * Cache the location data for the current location.
+ */
+const cacheLocationData = async () => {
+  await sleep(300);
+  if (! user.environment_type || ! user.quests) {
+    return;
+  }
+
+  // For some environments, we need to build the data from the quests.
+  if (user.environment_type === 'desert_warpath') {
+    const fwQuestData = setFieryWarpathData();
+    if (fwQuestData) {
+      user.quests.QuestFieryWarpath = fwQuestData;
+    }
+  } else if (user.environment_type === 'zugzwang_tower') {
+    const ztQuestData = setZugzwangTowerData();
+    if (ztQuestData) {
+      user.quests.QuestZugzwangTower = ztQuestData;
+    }
+  } else if (user.environment_type === 'seasonal_garden') {
+    const sgQuestData = setSeasonalGardenData();
+    if (sgQuestData) {
+      user.quests.QuestSeasonalGarden = sgQuestData;
+    }
+  }
+
+  // Get the current cached quests.
+  const questsCached = await dataGet('quests', {});
+
+  // Combine the cached quests with the current quests.
+  const questsCombined = Object.assign({}, questsCached, user.quests);
+
+  if (user.environment_type === 'labyrinth') {
+    questsCombined.QuestAncientCity = {};
+  } else if (user.environment_type === 'ancient_city') {
+    questsCombined.QuestLabyrinth = {};
+  } else if (user.environment_type === 'zugzwang_tower') {
+    questsCombined.QuestSeasonalGarden = {};
+  } else if (user.environment_type === 'seasonal_garden') {
+    questsCombined.QuestZugzwangTower = {};
+  }
+
+  // Save the combined data to localStorage.
+  try {
+    dataSet('quests', questsCombined);
+  } catch (error) {
+    debug('Error saving dashboard data.', error);
+  }
+};
+
+/**
+ * Travel to a location and wait for the travel to complete.
+ *
+ * @param {string} environment The environment to travel to.
+ *
+ * @return {Promise} A promise that resolves when the travel is complete.
+ */
+const waitForTravel = async (environment) => {
+  return new Promise((resolve) => {
+    hg.utils.User.travel(
+      environment,
+      (success) => {
+        debug(`Travel success: ${success}`);
+        resolve();
+      },
+      (error) => {
+        debug(`Travel error: ${error}`);
+        resolve();
+      }
+    );
+
+    debug(`Traveled to ${environment}.`);
+  });
+};
+
+/**
+ * Refresh the location data.
+ */
+const doLocationRefresh = async () => {
+  const locationProgress = [];
+
+  const environmentsToUse = new Set([
+    'ancient_city',
+    'bountiful_beanstalk',
+    'desert_warpath',
+    'draconic_depths',
+    'floating_islands',
+    'foreword_farm',
+    'fort_rox',
+    'iceberg',
+    'labyrinth',
+    'desert_oasis',
+    'lost_city',
+    'mousoleum',
+    'moussu_picchu',
+    'pollution_outbreak',
+    'queso_geyser',
+    'rift_bristle_woods',
+    'rift_burroughs',
+    'rift_furoma',
+    'rift_valour',
+    'rift_whisker_woods',
+    'sand_dunes',
+    'school_of_sorcery',
+    'seasonal_garden',
+    'sunken_city',
+    'table_of_contents',
+    'zugzwang_tower',
+  ]);
+
+  const environmentsToTravel = environments.filter((env) => {
+    return (environmentsToUse.has(env.id) && isUserTitleAtLeast(env.title));
+  });
+
+  debug(`Environments to travel: ${environmentsToTravel.map((env) => env.name).join(', ')}`);
+
+  // Sort environments by order
+  environmentsToTravel.sort((a, b) => {
+    return a.order - b.order;
+  });
+
+  debug(`Sorted environments to travel: ${environmentsToTravel.map((env) => env.name).join(', ')}`);
+
+  let locationProgressMarkup = '';
+  environmentsToTravel.forEach((env) => {
+    locationProgressMarkup += `<div class="location-refresh-item" data-environment-type="${env.id}">
+    <div class="locationImageWrapper">
+      <img class="locationImage" src="${env.image}" alt="${env.name}" title="${env.name}" />
+    </div>
+    <div class="locationName" title="Travel to ${env.name}">
+      <div class="name">${env.name}</div>
+      <div class="progress"></div>
+    </div>
+    </div>`;
+
+    locationProgress.push(env.id);
+    debug(`Adding ${env.name} to the to-travel list.`);
+  });
+
+  createPopup({
+    title: 'Update Location Data',
+    content: `<div class="mh-improved-location-refresh-popup">
+    <div class="mh-improved-location-refresh-popup-progress">${locationProgressMarkup}</div>
+    </div>`,
+    hasCloseButton: false,
+    show: true,
+  });
+
+  const originalLocation = user.environment_type;
+  debug(`Original location: ${user.environment_type}.`);
+
+  const originalLocationEl = document.querySelector(`.location-refresh-item[data-environment-type="${originalLocation}"]`);
+  if (originalLocationEl) {
+    originalLocationEl.classList.add('starting');
+  }
+
+  for (const location of locationProgress) {
+    const locationData = environments.find((env) => env.id === location);
+    if (! locationData) {
+      continue;
+    }
+
+    const progressItem = document.querySelector(`.location-refresh-item[data-environment-type="${location}"]`);
+    if (! progressItem) {
+      continue;
+    }
+
+    const item = progressItem.querySelector('.locationName');
+    if (! item) {
+      return;
+    }
+
+    makeMhButton({
+      text: 'Travel',
+      size: 'small',
+      element: 'button',
+      className: ['travel-button', 'lightBlue'],
+      callback: async (event) => {
+        const button = event.currentTarget;
+
+        sessionSet('doing-location-refresh', true);
+
+        progressItem.classList.add('traveling');
+        button.classList.add('busy');
+
+        await waitForTravel(location);
+        await sleep(1000);
+        await cacheLocationData();
+
+        button.classList.remove('busy');
+        progressItem.classList.remove('traveling');
+        progressItem.classList.add('done');
+
+        sessionSet('doing-location-refresh', false);
+      },
+      appendTo: item,
+    });
+  }
+
+  doEvent('travel_complete');
+};
+
+/**
+ * Build the dashboard tab.
+ */
+const makeDashboardTab = () => {
+  const tabsContainer = document.querySelector('.mousehuntHeaderView-dropdownContainer');
+  if (! tabsContainer) {
+    return;
+  }
+
+  // Create menu tab.
+  const menuTab = makeElement('div', ['menuItem', 'dropdown', 'dashboard']);
+
+  // Register click event listener.
+  menuTab.addEventListener('click', async () => {
+    menuTab.classList.toggle('expanded');
+
+    // When opening dashboard
+    if (menuTab.classList.contains('expanded')) {
+      const dashboardWrapper = document.querySelector('.dashboardWrapper');
+      if (! dashboardWrapper) {
+        return;
+      }
+
+      const existing = document.querySelector('.dashboardContents');
+      if (existing) {
+        const refreshedContents = await getDashboardContents();
+        existing.replaceWith(refreshedContents);
+
+        // Use existing cached data immediately
+        // Then update in background
+        setTimeout(async () => {
+          await cacheLocationData();
+          const newRefreshedContents = await getDashboardContents();
+          existing.replaceWith(newRefreshedContents);
+        }, 0);
+      } else {
+        // First time opening - show cached data immediately
+        const dashboardContents = await getDashboardContents();
+        const refreshWrapper = dashboardWrapper.querySelector('.refreshWrapper');
+        if (refreshWrapper) {
+          refreshWrapper.before(dashboardContents);
+          refreshWrapper.classList.remove('hidden');
+        } else {
+          dashboardWrapper.append(dashboardContents);
+        }
+
+        // Then update with current location data in background
+        setTimeout(async () => {
+          await cacheLocationData();
+          const refreshedContents = await getDashboardContents();
+          const currentContents = document.querySelector('.dashboardContents');
+          if (currentContents) {
+            currentContents.replaceWith(refreshedContents);
+          }
+        }, 100);
+      }
+    }
+
+    sessionSet('doing-location-refresh', false);
+  });
+
+  makeElement('span', '', 'Dashboard', menuTab);
+  makeElement('div', 'arrow', '', menuTab);
+
+  const dropdownContent = makeElement('div', 'dropdownContent');
+  const dashboardWrapper = makeElement('div', 'dashboardWrapper');
+
+  // Refresh button.
+  const refreshWrapper = makeElement('div', ['refreshWrapper', 'hidden']);
+
+  makeMhButton({
+    text: 'Refresh',
+    element: 'button',
+    className: ['dashboardRefresh'],
+    callback: doLocationRefresh,
+    appendTo: refreshWrapper,
+  });
+
+  dashboardWrapper.append(refreshWrapper);
+  dropdownContent.append(dashboardWrapper);
+  menuTab.append(dropdownContent);
+
+  // Append as the second to last tab.
+  tabsContainer.insertBefore(menuTab, tabsContainer.lastChild);
+};
+
+/**
+ * Create the markup for a region for the dashboard.
+ *
+ * @param {string}  name         The name of the region.
+ * @param {Element} childContent The child content.
+ * @param {Element} appendTo     The element to append to.
+ */
+const makeRegionMarkup = (name, childContent, appendTo) => {
+  // find the child of the first div
+  const firstChild = childContent.firstChild;
+  if (! firstChild) {
+    return;
+  }
+
+  // Make wrapper.
+  const regionWrapper = makeElement('div', 'regionWrapper');
+
+  // Name.
+  makeElement('div', 'regionName', name, regionWrapper);
+
+  // Child content.
+  regionWrapper.append(childContent);
+
+  appendTo.append(regionWrapper);
+};
+
+/**
+ * Build the markup for a location.
+ *
+ * @param {string}   id       The location ID.
+ * @param {string}   name     The location name.
+ * @param {Function} progress The progress function.
+ * @param {Element}  appendTo The element to append to.
+ * @param {Object}   quests   The quests object.
+ */
+const makeLocationMarkup = (id, name, progress, appendTo, quests) => {
+  const markup = progress(quests);
+
+  if (! markup) {
+    return;
+  }
+
+  const locationWrapper = makeElement('div', 'locationWrapper');
+  locationWrapper.setAttribute('data-location', id);
+  locationWrapper.classList.add(`locationWrapper-${id}`);
+
+  // Name & travel links
+  const locationImageWrapper = makeElement('div', 'locationImageWrapper');
+  // get the image for the location
+  const environment = environments.find((env) => env.id === id);
+  if (environment?.image) {
+    const locationImage = makeElement('img', 'locationImage');
+    locationImage.setAttribute('src', environment.image);
+
+    locationImageWrapper.append(locationImage);
+  }
+
+  if (environment?.id) {
+    locationImageWrapper.addEventListener('click', async () => {
+      travelTo(environment.id);
+    });
+  }
+
+  locationWrapper.append(locationImageWrapper);
+
+  const nameEl = makeElement('div', 'locationName', name);
+
+  if (environment?.id) {
+    nameEl.addEventListener('click', async () => {
+      travelTo(environment.id);
+    });
+  }
+
+  locationWrapper.append(nameEl);
+
+  makeElement('div', 'locationProgress', markup, locationWrapper);
+
+  appendTo.append(locationWrapper);
+};
+
+/**
+ * Get the dashboard contents.
+ *
+ * @return {Element} The dashboard contents.
+ */
+const getDashboardContents = async () => {
+  const quests = await dataGet('quests', {});
+
+  debuglog('location-dashboard', 'quests', quests);
+
+  const contentsWrapper = document.createElement('div');
+  contentsWrapper.classList.add('dashboardContents');
+
+  const burroughs = document.createElement('div');
+  makeLocationMarkup('mousoleum', 'Mousoleum', getMousoleumText, burroughs, quests);
+  makeLocationMarkup('pollution_outbreak', 'Toxic Spill', getToxicSpillText, burroughs, quests);
+  makeRegionMarkup('Burroughs', burroughs, contentsWrapper);
+
+  const varmintValley = document.createElement('div');
+  makeLocationMarkup('fort_rox', 'Fort Rox', getFortRoxText, varmintValley, quests);
+  makeRegionMarkup('Varmint Valley', varmintValley, contentsWrapper);
+
+  const sandtailDesert = document.createElement('div');
+  makeLocationMarkup('desert_warpath', 'Fiery Warpath', getFieryWarpathText, sandtailDesert, quests);
+  makeLocationMarkup('desert_oasis', 'Living Garden', getLivingGardenText, sandtailDesert, quests);
+  makeLocationMarkup('lost_city', 'Lost City', getLostCityText, sandtailDesert, quests);
+  makeLocationMarkup('sand_dunes', 'Sand Dunes', getSandDunesText, sandtailDesert, quests);
+  makeRegionMarkup('Sandtail Desert', sandtailDesert, contentsWrapper);
+
+  const rodentia = document.createElement('div');
+  if (quests?.QuestZugzwangTower?.amp && quests?.QuestZugzwangTower?.amp >= 1) {
+    makeLocationMarkup('zugzwang_tower', 'Zugzwang\'s Tower', getZugzwangTowerText, rodentia, quests);
+  } else {
+    makeLocationMarkup('seasonal_garden', 'Seasonal Garden', getSeasonalGardenText, rodentia, quests);
+  }
+  makeLocationMarkup('iceberg', 'Iceberg', getIcebergText, rodentia, quests);
+  makeLocationMarkup('sunken_city', 'Sunken City', getSunkenCityText, rodentia, quests);
+  makeRegionMarkup('Rodentia', rodentia, contentsWrapper);
+
+  const quesoCanyon = document.createElement('div');
+  makeLocationMarkup('queso_geyser', 'Queso Geyser', getQuesoGeyserText, quesoCanyon, quests);
+  makeRegionMarkup('Queso Canyon', quesoCanyon, contentsWrapper);
+
+  const hollowHeights = document.createElement('div');
+  makeLocationMarkup('labyrinth', 'Labyrinth', getLabyrinthText, hollowHeights, quests);
+  makeLocationMarkup('ancient_city', 'Zokor', getZokorText, hollowHeights, quests);
+  makeLocationMarkup('moussu_picchu', 'Moussu Picchu', getMoussuPicchuText, hollowHeights, quests);
+  makeLocationMarkup('floating_islands', 'Floating Islands', getFloatingIslandsText, hollowHeights, quests);
+  makeRegionMarkup('Hollow Heights', hollowHeights, contentsWrapper);
+
+  const folkloreForest = document.createElement('div');
+  makeLocationMarkup('bountiful_beanstalk', 'Bountiful Beanstalk', getBountifulBeanstalkText, folkloreForest, quests);
+  makeLocationMarkup('foreword_farm', 'Foreword Farm', getForewordFarmText, folkloreForest, quests);
+  makeLocationMarkup('table_of_contents', 'Table of Contents', getTableOfContentsText, folkloreForest, quests);
+  makeLocationMarkup('school_of_sorcery', 'School of Sorcery', getSchoolOfSorceryText, folkloreForest, quests);
+  makeLocationMarkup('draconic_depths', 'Draconic Depths', getDraconicDepthsText, folkloreForest, quests);
+  makeLocationMarkup('afterword_acres', 'Afterward Acres', getAfterwordAcresText, folkloreForest, quests);
+  makeLocationMarkup('epilogue_falls', 'Epilogue Falls', getEpilogueFallsText, folkloreForest, quests);
+  makeRegionMarkup('Folklore Forest', folkloreForest, contentsWrapper);
+
+  const rift = document.createElement('div');
+  makeLocationMarkup('rift_burroughs', 'Burroughs Rift', getBurroughsRiftText, rift, quests);
+  makeLocationMarkup('rift_whisker_woods', 'Whisker Woods Rift', getWhiskerWoodsRiftText, rift, quests);
+  makeLocationMarkup('rift_furoma', 'Furoma Rift', getFuromaRiftText, rift, quests);
+  makeLocationMarkup('rift_bristle_woods', 'Bristle Woods Rift', getBristleWoodsRiftText, rift, quests);
+  makeLocationMarkup('rift_valour', 'Valour Rift', getValourRiftText, rift, quests);
+  makeRegionMarkup('Rift', rift, contentsWrapper);
+
+  if (
+    burroughs.children.length === 0 &&
+    varmintValley.children.length === 0 &&
+    sandtailDesert.children.length === 0 &&
+    rodentia.children.length === 0 &&
+    quesoCanyon.children.length === 0 &&
+    hollowHeights.children.length === 0 &&
+    folkloreForest.children.length === 0 &&
+    rift.children.length === 0
+  ) {
+    const noLocation = makeElement('div', 'noLocationDataWrapper');
+    makeElement('div', 'noLocationData', 'No location data found. Refresh data to populate the dashboard.', noLocation);
+    contentsWrapper.append(noLocation);
+  }
+
+  return contentsWrapper;
+};
+
+let environments = [];
+
+/**
+ * Initialize the module.
+ */
+const init = async () => {
+  addStyles(styles, 'location-dashboard');
+
+  environments = await getData('environments');
+
+  // Cache the quest data for our current location.
+  sessionSet('doing-location-refresh', false);
+
+  cacheLocationData();
+  onEvent('travel_complete', cacheLocationData);
+  onRequest('*', cacheLocationData);
+
+  makeDashboardTab();
+};
+
+/**
+ * Initialize the module.
+ */
+export default {
+  id: 'location-dashboard',
+  name: 'Location Dashboard',
+  type: 'feature',
+  default: true,
+  description: 'View location HUD information in a dashboard available in the top dropdown menu.',
+  load: init,
+};

package/src/modules/location-dashboard/locations/afterword-acres.js

@@ -0,0 +1,18 @@
+/**
+ * Dashboard output for Afterword Acres.
+ *
+ * @param {Object} quests The quests data.
+ *
+ * @return {string} The dashboard output.
+ */
+export default (quests) => {
+  if (! quests.QuestAfterwordAcres) {
+    return '';
+  }
+
+  const quest = quests.QuestAfterwordAcres;
+
+  const multipler = quest.blight_thresholds?.find((threshold) => threshold.tier === quest.blight_tier)?.multiplier;
+
+  return `Blight: ${quest?.blight_level_nice_number || '0'} / ${quest?.max_blight_level || '0'} (x${multipler})`;
+};

package/src/modules/location-dashboard/locations/ancient-city.js

@@ -0,0 +1,23 @@
+/**
+ * Dashboard output.
+ *
+ * @param {Object} quests The quests data.
+ *
+ * @return {string} The dashboard output.
+ */
+export default (quests) => {
+  if (! quests.QuestAncientCity) {
+    return '';
+  }
+
+  const quest = {
+    district_name: quests?.QuestAncientCity?.district_name || null,
+    remaining: quests?.QuestAncientCity?.remaining || null,
+  };
+
+  if (! quest.district_name || ! quest.remaining) {
+    return '';
+  }
+
+  return `${quest.district_name.replace('The ', '')}, ${quest.remaining} stealth`;
+};

package/src/modules/location-dashboard/locations/bountiful-beanstalk.js

@@ -0,0 +1,51 @@
+/**
+ * Dashboard output.
+ *
+ * @param {Object} quests The quests data.
+ *
+ * @return {string} The dashboard output.
+ */
+export default (quests) => {
+  if (! quests.QuestBountifulBeanstalk) {
+    return '';
+  }
+
+  if (! quests?.QuestBountifulBeanstalk?.in_castle) {
+    const room = quests?.QuestBountifulBeanstalk?.beanstalk?.current_zone?.name || '';
+    const huntsRemaining = quests?.QuestBountifulBeanstalk?.beanstalk?.hunts_remaining_text || '';
+    const isBoss = quests?.QuestBountifulBeanstalk?.beanstalk?.is_boss_encounter || false;
+
+    return `${room} (Beanstalk) <div class="stats">${isBoss ? 'At Boss · ' : ''}${huntsRemaining}</div>`;
+  }
+
+  const huntsRemaining = quests?.QuestBountifulBeanstalk?.castle?.hunts_remaining_text || '';
+  const isBoss = quests?.QuestBountifulBeanstalk?.castle?.is_boss_encounter || false;
+  const isChase = quests?.QuestBountifulBeanstalk?.castle?.is_boss_chase || false;
+  const noise = quests?.QuestBountifulBeanstalk?.castle?.noise_level || 0;
+  const maxNoise = quests?.QuestBountifulBeanstalk?.castle?.max_noise_level || 0;
+
+  const roomQuality = quests?.QuestBountifulBeanstalk?.castle?.current_room?.type
+    .replace('_room', '')
+    .split('_')
+    .pop()
+    .trim();
+
+  const roomName = quests?.QuestBountifulBeanstalk?.castle?.current_room?.name
+    .replace(' Room', '')
+    .replace(`${roomQuality.charAt(0).toUpperCase() + roomQuality.slice(1).toLowerCase()} `, '')
+    .trim();
+
+  const noiseString = isBoss ? 'Boss' : (isChase ? 'Chase' : `♪ ${noise.toLocaleString()}/${maxNoise.toLocaleString()}`);
+
+  const embellishmentsText = quests?.QuestBountifulBeanstalk?.embellishments
+    .filter((item) => item.is_active)
+    .map((item) => `<span class="tile ${item.type}"></span>`);
+
+  let returnText = '<div class="dashboard-bb">';
+  returnText += `<div class="dashboard-bb-wrap room-name"><span class="tile ${roomQuality}"></span><div class="name">${roomName}</div>`;
+  returnText += `<div class="dashboard-bb-wrap embellishments">${embellishmentsText.join('')}</div>`;
+  returnText += '</div>';
+  returnText += `<div class="stats">${noiseString} · ${huntsRemaining}</div>`;
+
+  return returnText;
+};

package/src/modules/location-dashboard/locations/desert-oasis.js

@@ -0,0 +1,22 @@
+/**
+ * Dashboard output.
+ *
+ * @param {Object} quests The quests data.
+ *
+ * @return {string} The dashboard output.
+ */
+export default (quests) => {
+  if (! quests.QuestLivingGarden) {
+    return '';
+  }
+
+  const quest = quests.QuestLivingGarden;
+
+  const twistedText = quest.is_normal ? 'Not twisted' : 'Twisted';
+
+  if ('dumped' === quest?.minigame?.vials_state && quest?.minigame?.timer) {
+    return `${twistedText} · Pouring${quest?.minigame.timer ? ` for ${quest?.minigame.timer} hunts` : ''}`;
+  }
+
+  return `${twistedText}`;
+};