feat(#20): can now start multiple timers [WIP]

Author: Giesenberg, Jan

src/js/MindFlayer.js

@@ -41,15 +41,15 @@ export default class MindFlayer {
   }
 
   init() {
-    if (this.#settings.enabled && dependencies.warnIfAnyMissing()) {
+    if (dependencies.warnIfAnyMissing()) {
       console.debug(LOG_PREFIX + "Initializing modules");
       this._vttBugFixes();
       loader.init(this);
     }
   }
 
   ready() {
-    if (this.#settings.enabled && dependencies.warnIfAnyMissing(false)) {
+    if (dependencies.warnIfAnyMissing(false)) {
       console.debug(LOG_PREFIX + "Calling ready methods on modules");
       loader.ready(this);
     }

src/js/modules/AbstractSubModule.js

@@ -29,6 +29,16 @@ export default class AbstractSubModule {
     return [];
   }
 
+  /**
+   * Ask to start the module when the module Setting is enabled
+   * 
+   * @param {Mindflayer} instance the instance to start
+   * @returns {boolean} if true the module should be loaded
+   */
+  static shouldStart(instance) {
+    return instance.settings.enabled;
+  }
+
   constructor(instance) {
     this.#instance = instance;
     this.#loaded = true;

src/js/modules/ControllerManager/index.js

@@ -143,6 +143,9 @@ export default class ControllerManager extends AbstractSubModule {
       const keypad = this.#keypads[name];
       const leds = keypad.getLEDsIfChanged();
       if (leds) {
+        console.debug(
+          `${SUB_LOG_PREFIX}Sending updated LEDs to keypad '${keypad.controllerId}'`
+        );
         const data = JSON.stringify({
           type: "configuration",
           "controller-id": keypad.controllerId,

src/js/modules/ambilight/index.js

@@ -13,57 +13,60 @@
  * see <https://www.gnu.org/licenses/>.
  */
 "use strict";
+import { TABLE_LED_PRIORITY } from "../../settings/constants";
 import { Rectangle, Vector } from "../../utils/2d-geometry";
 import { hexToRgb } from "../../utils/color";
 import AbstractSubModule from "../AbstractSubModule";
-import { default as Socket } from "../socket";
+import TableLEDRing from "../tableLedRing";
+import { TableLEDRingHandlerMixin } from "../tableLedRing/TableLEDRingHandlerMixin";
 
-export default class Ambilight extends AbstractSubModule {
+export default class Ambilight extends TableLEDRingHandlerMixin(
+  AbstractSubModule
+) {
   #enabled = true;
   #updateLEDsTimer = null;
-  #ambilightLastSent = "null";
 
   ready() {
     this.#enabled = game.canvas.initialized;
-    // setup the animation loop for reading the canvas for ambilight leds
-    this.#updateLEDsTimer = window.setInterval(
-      this._ambilightLoop.bind(this),
-      Math.round(1000 / this.instance.settings.ambilight.fps)
-    );
+    this.tableLEDRing.registerHandler(this);
   }
 
   unhook() {
     this.#enabled = false;
+    this.tableLEDRing.unregisterHandler(this);
     window.clearInterval(this.#updateLEDsTimer);
     super.unhook();
   }
 
   static get moduleDependencies() {
-    return [...super.moduleDependencies, Socket.name];
+    return [...super.moduleDependencies, TableLEDRing.name];
   }
 
-  /**
-   * @returns {Socket}
-   */
-  get socket() {
-    return this.instance.modules[Socket.name];
+  /** @returns {TableLEDRing} */
+  get tableLEDRing() {
+    return this.instance.modules[TableLEDRing.name];
   }
 
   set enabled(value) {
     this.#enabled = game.canvas.initialized && value;
   }
 
-  /**
-   * @protected
-   */
-  async _ambilightLoop() {
+  get priority() {
+    if (this.#enabled) {
+      return TABLE_LED_PRIORITY.AMBILIGHT;
+    } else {
+      return TABLE_LED_PRIORITY.OFF;
+    }
+  }
+
+  async updateLEDs(count) {
     this.ensureLoaded();
     if (!this.#enabled || !this.instance.settings.ambilight.enabled) {
       return;
     }
     const pixelsRaw = await this.loadPixels();
     if (pixelsRaw !== null) {
-      this.sendAmbilightData(this._compileLEDData(pixelsRaw));
+      return this._compileLEDData(pixelsRaw, count);
     }
   }
 
@@ -74,7 +77,7 @@ export default class Ambilight extends AbstractSubModule {
   }
 
   /**
-   * Will only function correctly if call from within requestAnimationFrame()
+   * Will only function correctly if called from within requestAnimationFrame()
    * @protected
    */
   _loadPixels(resolve, reject) {
@@ -107,8 +110,7 @@ export default class Ambilight extends AbstractSubModule {
   /**
    * @protected
    */
-  _compileLEDData(pixelsRaw) {
-    const ledCount = this.instance.settings.ambilight.led.count;
+  _compileLEDData(pixelsRaw, ledCount) {
     const brightMin = this.instance.settings.ambilight.brightness.min;
     const brightRange =
       (this.instance.settings.ambilight.brightness.max - brightMin) / 255;
@@ -178,20 +180,4 @@ export default class Ambilight extends AbstractSubModule {
     }
     return Math.floor(bounds.center.x + bounds.center.y * bounds.p1.x) * 4;
   }
-
-  sendAmbilightData(ledState) {
-    if (ledState === null) {
-      return;
-    }
-    const data = JSON.stringify({
-      type: "ambilight",
-      target: this.instance.settings.ambilight.target,
-      universe: this.instance.settings.ambilight.universe,
-      colors: Array.from(ledState),
-    });
-    if (this.#ambilightLastSent !== data) {
-      this.socket.send(data);
-      this.#ambilightLastSent = data;
-    }
-  }
 }

src/js/modules/combatIndicator/index.js

@@ -3,6 +3,8 @@ import AbstractSubModule from "../AbstractSubModule";
 import Ambilight from "../ambilight";
 import ControllerManager from "../ControllerManager";
 import Keypad from "../ControllerManager/Keypad";
+import Timer from "../timer";
+import TimerRunner from "../timer/TimerRunner";
 
 const COMBAT_DURATION_TACTICAL_DISCUSSION = 60000; //ms
 const COMBAT_DURATION_FORCED_DODGE = 7000; //ms
@@ -28,11 +30,7 @@ export default class CombatIndicator extends AbstractSubModule {
   }
 
   static get moduleDependencies() {
-    return [
-      ...super.moduleDependencies,
-      ControllerManager.name,
-      AmbientLight.name,
-    ];
+    return [...super.moduleDependencies, ControllerManager.name, Timer.name];
   }
 
   /**
@@ -43,10 +41,10 @@ export default class CombatIndicator extends AbstractSubModule {
   }
 
   /**
-   * @returns {Ambilight}
+   * @returns {Timer}
    */
-  get ambilight() {
-    return this.instance.modules[Ambilight.name];
+  get timer() {
+    return this.instance.modules[Timer.name];
   }
 
   /**
@@ -119,61 +117,15 @@ export default class CombatIndicator extends AbstractSubModule {
       }
     }
   }
-  async #startTacticalTimer(updateCombatCallback, timeInMS) {
-    const totalLEDs = this.instance.settings.ambilight.led.count;
-    if (this.#updateLEDsTimer !== null) {
-      window.clearInterval(this.#updateLEDsTimer);
-    }
-    if (totalLEDs <= 0) {
-      window.setTimeout(updateCombatCallback, timeInMS);
-    } else {
-      this.ambilight.enabled = false;
-      this.#updateLEDsTimer = window.setInterval(
-        this.#updateLEDs.bind(this, updateCombatCallback),
-        Math.floor(timeInMS / totalLEDs)
-      );
-      this.#currentLED = 0;
-      this.#updateLEDs(updateCombatCallback);
-    }
-  }
 
-  async #finishTacticalTimer(callback) {
-    this.ambilight.enabled = true;
-    window.clearInterval(this.#updateLEDsTimer);
-    this.#updateLEDsTimer = null;
-    callback();
-  }
-
-  #updateLEDs(callback) {
-    const total = this.instance.settings.ambilight.led.count;
-    const totalValues = total * 3;
-    const offset = this.instance.settings.ambilight.led.offset;
-    const minBright = this.instance.settings.ambilight.brightness.min;
-    const remaining = total - this.#currentLED;
-    const completion = remaining / total;
-    const leds = [];
-    let color;
-    this.#currentLED++;
-    if (completion > 2 / 3) {
-      color = hexToRgb("#00FF00");
-    } else if (completion > 1 / 3) {
-      color = hexToRgb("#FFFF00");
-    } else if (remaining <= 0) {
-      return this.#finishTacticalTimer(callback);
-    } else {
-      color = hexToRgb("#FF0000");
-    }
-    for (let i = 0; i < total; i++) {
-      if (i < remaining) {
-        leds[(offset + i * 3 + 0) % totalValues] = color.r;
-        leds[(offset + i * 3 + 1) % totalValues] = color.g;
-        leds[(offset + i * 3 + 2) % totalValues] = color.b;
-      } else {
-        leds[(offset + i * 3 + 0) % totalValues] = minBright;
-        leds[(offset + i * 3 + 1) % totalValues] = minBright;
-        leds[(offset + i * 3 + 2) % totalValues] = minBright;
-      }
-    }
-    this.ambilight.sendAmbilightData(leds);
+  async #startTacticalTimer(updateCombatCallback, timeInMS) {
+    const start = new Date().valueOf();
+    this.timer.addTimer({
+      start: start,
+      end: start + timeInMS,
+      options: {
+        onDone: updateCombatCallback,
+      },
+    });
   }
 }

src/js/modules/doorHandler/index.js

@@ -33,7 +33,7 @@ export default class DoorHandler extends AbstractSubModule {
   }
 
   ready() {
-    if (!game.canvas.initialized) {
+    if (this.instance.settings.core.noCanvas) {
       console.info(SUB_LOG_PREFIX + "canvas is disabled, cannot control doors");
       return;
     }
@@ -42,7 +42,9 @@ export default class DoorHandler extends AbstractSubModule {
   }
 
   unhook() {
-    this.controllerManager.unregisterTickListener(this.#tickHandlerFun);
+    if (!this.instance.settings.core.noCanvas) {
+      this.controllerManager.unregisterTickListener(this.#tickHandlerFun);
+    }
     super.unhook();
   }
 

src/js/modules/loader.js

@@ -36,20 +36,42 @@ let dependencyGraph = null;
  */
 export function init(instance) {
   console.debug(LOG_PREFIX + "Sorting submodules");
+
   subModules.sort((a, b) => {
+    /*
+     * This functions sorts modules by their dependencies.
+     * starting with the modules with the most dependencies,
+     * ending with the ones who don't have any
+     */
     const bDeps = b.default.moduleDependencies;
     if (bDeps.includes(a.default.name)) {
-      return -1;
+      return 1;
     }
     const aDeps = a.default.moduleDependencies;
     if (aDeps.includes(b.default.name)) {
-      return 1;
+      return -1;
     }
     return aDeps.length - bDeps.length;
   });
+
+  console.debug(LOG_PREFIX + "Filtering unnecessary modules")
+
+  let filteredModules = [];
+  let requiredModuleNames = new Set();
+  for(var key in subModules) {
+    const module = subModules[key];
+    const moduleName = module.default.name;
+    if(module.default.shouldStart(instance) || requiredModuleNames.has(moduleName)) {
+      filteredModules.push(module);
+      requiredModuleNames.delete(moduleName);
+      module.default.moduleDependencies.forEach(name => requiredModuleNames.add(name));
+    }
+  }
+  subModules = filteredModules.reverse();
+  
   console.info(LOG_PREFIX + "Starting submodules");
 
-  __loadModules(instance, subModules);
+  __loadModules(instance, filteredModules);
 
   console.info(LOG_PREFIX + "Submodules initialized");
 }
@@ -74,11 +96,19 @@ export function ready(instance, modules = null) {
         }
         return aDeps.length - bDeps.length;
       })
-      .map((mod) => instance.modules[mod.default.name]);
+      .map((mod) => instance.modules[mod.default.name])
+      .filter((mod) => mod !== undefined && mod !== null);
   }
   modules.forEach((mod) => {
-    console.debug(`${LOG_PREFIX}Readying Module: ${mod.constructor.name}`);
-    mod.ready();
+    try {
+      console.debug(`${LOG_PREFIX}Readying Module: ${mod.constructor.name}`);
+      mod.ready();
+    } catch (e) {
+      console.warn(
+        `${LOG_PREFIX}Failed to ready module '${mod.constructor.name}', continuing...`,
+        e
+      );
+    }
   });
 }
 
@@ -134,6 +164,7 @@ function _reload(instance, module) {
     subModules.find((mod) => mod.default.name === name)
   );
   __loadModules(instance, modules);
+  ready(instance, modules);
 }
 
 export const reload = foundry.utils.debounce(_reload, 500);

src/js/modules/socket/index.js

@@ -39,6 +39,9 @@ export default class Socket extends AbstractSubModule {
   }
 
   ready() {
+    // The module may be asked to load as dependency
+    // WebSocket to connect to elder brain will only start if enabled
+    if(!Socket.shouldStart(this.instance)) return;
     this._initializeWebsocket();
   }