",
+ "private": true,
+ "scripts": {
+ "build": "webpack --config webpack.config.js",
+ "prod": "NODE_ENV=production webpack --config webpack.config.js",
+ "style": "prettier --write src/ templates/ lang/ *.json *.md webpack.config.js",
+ "test": "echo \"Error: no test specified\" && exit 1",
+ "semantic-release": "semantic-release"
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/mindflayer-vtt/foundryvtt-mindflayer.git"
+ },
+ "license": "GPL-3",
+ "bugs": {
+ "url": "https://github.com/mindflayer-vtt/foundryvtt-mindflayer/issues"
+ },
+ "homepage": "https://github.com/mindflayer-vtt/foundryvtt-mindflayer#readme",
+ "devDependencies": {
+ "@semantic-release/commit-analyzer": "^9.0.2",
+ "@semantic-release/exec": "^6.0.3",
+ "@semantic-release/git": "^10.0.1",
+ "@semantic-release/github": "^8.0.2",
+ "@semantic-release/npm": "^9.0.0",
+ "@semantic-release/release-notes-generator": "^10.0.3",
+ "copy-webpack-plugin": "^10.2.4",
+ "prettier": "2.5.1",
+ "semantic-release": "^19.0.2",
+ "webpack": "^5.67.0",
+ "webpack-cli": "^4.9.2"
+ },
+ "dependencies": {
+ "dependency-graph": "^0.11.0",
+ "require": "^2.4.20"
+ }
+}
diff --git a/src/js/MindFlayer.js b/src/js/MindFlayer.js
new file mode 100644
index 0000000..b33c2a2
--- /dev/null
+++ b/src/js/MindFlayer.js
@@ -0,0 +1,65 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { settings } from "./settings";
+import * as dependencies from "./dependencies";
+import loader from "./modules/loader";
+import AbstractSubModule from "./modules/AbstractSubModule";
+import ControllerManager from "./modules/ControllerManager";
+
+export default class MindFlayer {
+ #settings = null;
+ #modules = [];
+
+ constructor() {
+ this.#settings = settings.init();
+ }
+
+ /**
+ * @type {settings}
+ */
+ get settings() {
+ return this.#settings;
+ }
+
+ /**
+ * @type {AbstractSubModule[]}
+ */
+ get modules() {
+ return this.#modules;
+ }
+
+ ready() {
+ if (dependencies.warnIfAnyMissing() && this.#settings.enabled) {
+ loader(this);
+ }
+ }
+
+ handleCombatUpdate(combat, update) {
+ if (combat.combatant) {
+ const activePlayerIds = combat.combatant.players.map(
+ (player) => player.id
+ );
+ this.#modules[ControllerManager.name].keypads.forEach((keypad) => {
+ const player = keypad.player;
+ if (activePlayerIds.includes(player.id)) {
+ keypad.setLED(1, "#FF0000");
+ } else {
+ keypad.setLED(1, player.data.color);
+ }
+ });
+ }
+ }
+}
diff --git a/src/js/dependencies/index.js b/src/js/dependencies/index.js
new file mode 100644
index 0000000..8b943a4
--- /dev/null
+++ b/src/js/dependencies/index.js
@@ -0,0 +1,41 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { VTT_MODULE_NAME } from "../settings/constants";
+const moduleJson = require("../module.tmpl.json");
+
+/**
+ * Warn the GM user about any missing dependencies
+ *
+ * @returns true if all dependencies are available
+ */
+export function warnIfAnyMissing() {
+ let result = true;
+ for (let i in moduleJson.dependencies) {
+ if (!moduleJson.dependencies.hasOwnProperty(i)) {
+ continue;
+ }
+ const dependency = moduleJson.dependencies[i].name;
+ if (!game.modules.get(dependency)?.active) {
+ if (game.user.isGM) {
+ ui.notifications.error(
+ `Module '${VTT_MODULE_NAME}' requires the '${dependency}' module. Please install and activate it.`
+ );
+ }
+ result = false;
+ }
+ }
+ return result;
+}
diff --git a/src/js/index.js b/src/js/index.js
new file mode 100644
index 0000000..41784ef
--- /dev/null
+++ b/src/js/index.js
@@ -0,0 +1,55 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+(function () {
+ "use strict";
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Imports
+ //
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ const { default: MindFlayer } = require("./MindFlayer");
+ const { setModuleInstance } = require("./utils/module");
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Globals
+ //
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ /**
+ * @type {MindFlayer}
+ */
+ let instance = null;
+
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // Hooks
+ //
+ //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * Init hook
+ */
+ Hooks.once("init", () => {
+ instance = new MindFlayer();
+ setModuleInstance(instance);
+ });
+
+ /**
+ * Ready hook
+ */
+ Hooks.once("ready", () => {
+ instance.ready();
+ });
+})();
diff --git a/src/js/module.tmpl.json b/src/js/module.tmpl.json
new file mode 100644
index 0000000..91de228
--- /dev/null
+++ b/src/js/module.tmpl.json
@@ -0,0 +1,43 @@
+{
+ "name": "mindflayer-token-controller",
+ "title": "Mind Flayer - Token Controller",
+ "description": "Adds functionality to control tokens through external applications or devices. Mind Flayer server (https://github.com/mindflayer-vtt/mindflayer-server) is required for the module to communicate with external services.",
+ "minimumCoreVersion": "0.8.0",
+ "compatibleCoreVersion": "0.8.8",
+ "author": "749, shawly",
+ "authors": [
+ {
+ "name": "shawly",
+ "email": "shawlyde@gmail.com",
+ "url": "https://github.com/shawly"
+ },
+ {
+ "name": "749",
+ "url": "https://github.com/749"
+ }
+ ],
+ "esmodules": ["./MindFlayer.js"],
+ "scripts": [],
+ "socket": true,
+ "styles": ["./style.css"],
+ "languages": [
+ {
+ "lang": "en",
+ "name": "English",
+ "path": "./lang/en.json"
+ }
+ ],
+ "dependencies": [
+ {
+ "name": "lib-wrapper",
+ "manifest": "https://github.com/ruipin/fvtt-lib-wrapper/releases/latest/download/module.json"
+ }
+ ],
+ "media": [],
+ "url": "https://github.com/mindflayer-vtt/foundryvtt-mindflayer",
+ "manifest": "https://github.com/mindflayer-vtt/foundryvtt-mindflayer/releases/latest/download/module.json",
+ "download": "https://github.com/mindflayer-vtt/foundryvtt-mindflayer/releases/latest/download/module.zip",
+ "bugs": "https://github.com/mindflayer-vtt/foundryvtt-mindflayer/issues",
+ "license": "https://github.com/mindflayer-vtt/foundryvtt-mindflayer/blob/main/LICENSE",
+ "readme": "https://github.com/mindflayer-vtt/foundryvtt-mindflayer/blob/main/README.md"
+}
diff --git a/src/js/modules/AbstractSubModule.js b/src/js/modules/AbstractSubModule.js
new file mode 100644
index 0000000..9b8c8b1
--- /dev/null
+++ b/src/js/modules/AbstractSubModule.js
@@ -0,0 +1,60 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import MindFlayer from "../MindFlayer";
+
+export default class AbstractSubModule {
+ #loaded = false;
+ /**
+ * @type {MindFlayer | null}
+ */
+ #instance = null;
+
+ static get moduleDependencies() {
+ return [];
+ }
+
+ constructor(instance) {
+ this.#instance = instance;
+ this.#loaded = true;
+ }
+ /**
+ * @returns {MindFlayer}
+ */
+ get instance() {
+ return this.#instance;
+ }
+ /**
+ * @returns {boolean}
+ */
+ get loaded() {
+ return this.#loaded;
+ }
+ unhook() {
+ this.#loaded = false;
+ this.#instance = null;
+ }
+
+ /**
+ * @throws {ReferenceError} if the function is called while the module is unloaded
+ */
+ ensureLoaded() {
+ if (!this.#loaded) {
+ throw new ReferenceError(
+ `the module ${this.name} needs to be loaded to use this functionality`
+ );
+ }
+ }
+}
diff --git a/src/js/modules/ControllerManager/Key.js b/src/js/modules/ControllerManager/Key.js
new file mode 100644
index 0000000..8bb0519
--- /dev/null
+++ b/src/js/modules/ControllerManager/Key.js
@@ -0,0 +1,58 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+
+export class Key {
+ #state = false;
+ #lastUp = null;
+ lastTrigger = null;
+ get down() {
+ return this.#state;
+ }
+ set down(isDown) {
+ if (!isDown) {
+ this.#lastUp = null;
+ this.lastTrigger = null;
+ }
+ this.#state = isDown;
+ }
+
+ isJustDown(time) {
+ if (!this.#state) {
+ return false;
+ }
+ if (this.#lastUp === null || this.#lastUp === time) {
+ this.#lastUp = time;
+ return true;
+ }
+ return false;
+ }
+
+ isRepeatedDown(time) {
+ if (!this.#state) {
+ return false;
+ }
+ if (this.lastTrigger === null || this.lastTrigger === time) {
+ this.lastTrigger = time;
+ return true;
+ }
+ if (time > this.lastTrigger + 250) {
+ // Last trigger is more than 250ms ago
+ this.lastTrigger = time;
+ return true;
+ }
+ return false;
+ }
+}
diff --git a/src/js/modules/ControllerManager/Keypad.js b/src/js/modules/ControllerManager/Keypad.js
new file mode 100644
index 0000000..616277c
--- /dev/null
+++ b/src/js/modules/ControllerManager/Keypad.js
@@ -0,0 +1,220 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { LOG_PREFIX, VTT_MODULE_NAME } from "../../settings/constants";
+import { Key } from "./Key";
+import * as TokenUtil from "../../utils/tokenUtil";
+
+/**
+ * Keypad class representing a keypad
+ */
+export default class Keypad {
+ #instance;
+ #controllerId;
+ #rawState = {
+ Q: new Key(),
+ W: new Key(),
+ E: new Key(),
+ A: new Key(),
+ S: new Key(),
+ D: new Key(),
+ Z: new Key(),
+ X: new Key(),
+ C: new Key(),
+ SHI: new Key(),
+ SPC: new Key(),
+ };
+ #ledChanged = false;
+ #ledState = ["#000000", "#000000"];
+
+ constructor(instance, controllerId) {
+ this.#instance = instance;
+ this.#controllerId = controllerId;
+ this.setDefaultLEDColor();
+ console.debug(
+ LOG_PREFIX + "Initialized keypad for controller " + this.#controllerId
+ );
+ }
+
+ get controllerId() {
+ return this.#controllerId;
+ }
+
+ get rotation() {
+ let r = game.user.getFlag(
+ VTT_MODULE_NAME,
+ "controllerRotation_" + this.#controllerId
+ );
+ if (r === undefined) {
+ r = 0;
+ this.rotation = r;
+ }
+ return r;
+ }
+
+ set rotation(amount) {
+ if (typeof amount !== "number") {
+ throw new TypeError("Rotation has to be numerical");
+ }
+ amount = amount % 360;
+ if (amount < 0) {
+ amount += 360;
+ }
+ game.user.setFlag(
+ VTT_MODULE_NAME,
+ "controllerRotation_" + this.#controllerId,
+ amount
+ );
+ }
+
+ /**
+ * Returns an assigned player for this keypad.
+ *
+ * @returns {Player | null} the assigned player
+ */
+ get player() {
+ const settings = this.#instance.settings.settings;
+ const playerId = Object.keys(settings.mappings).find(
+ (key) => settings.mappings[key] == this.#controllerId
+ );
+ const selectedPlayer = game.users.contents.find(
+ (player) => player.id == playerId
+ );
+ if (!selectedPlayer) {
+ return null;
+ }
+ return selectedPlayer;
+ }
+
+ /**
+ * Returns the currently selected Token for this keypad
+ *
+ * @returns {Token | null} the assinged token
+ */
+ get token() {
+ const player = this.player;
+ if (!player) return null;
+ return TokenUtil.getTokenFor(player, true);
+ }
+
+ get keys() {
+ return Object.getOwnPropertyNames(this.#rawState);
+ }
+
+ registerKeyEvent(data) {
+ if (!this.#rawState.hasOwnProperty(data.key)) {
+ console.warn(
+ LOG_PREFIX +
+ `Keypad[${
+ this.#controllerId
+ }].registerKeyEvent() called with unknown key:`,
+ data
+ );
+ return;
+ }
+ this.#rawState[data.key].down = `${data.state}`.toLowerCase() === "down";
+ }
+
+ isDown(wantedKey) {
+ if (!this.#rawState.hasOwnProperty(wantedKey)) {
+ console.warn(
+ LOG_PREFIX +
+ `Keypad[${
+ this.#controllerId
+ }].isDown() called with unknown key: ${wantedKey}`
+ );
+ return false;
+ }
+ return this.#rawState[wantedKey].down;
+ }
+
+ isJustDown(wantedKey, currentTime) {
+ if (!this.#rawState.hasOwnProperty(wantedKey)) {
+ console.warn(
+ LOG_PREFIX +
+ `Keypad[${
+ this.#controllerId
+ }].isDown() called with unknown key: ${wantedKey}`
+ );
+ return false;
+ }
+ return this.#rawState[wantedKey].isJustDown(currentTime);
+ }
+
+ isRepeatedDown(wantedKey, currentTime) {
+ if (!this.#rawState.hasOwnProperty(wantedKey)) {
+ console.warn(
+ LOG_PREFIX +
+ `Keypad[${
+ this.#controllerId
+ }].isDown() called with unknown key: ${wantedKey}`
+ );
+ return false;
+ }
+ return this.#rawState[wantedKey].isRepeatedDown(currentTime);
+ }
+
+ syncRepetitions(keys = [], currentTime) {
+ if (!Array.isArray(keys) || keys.length < 2) {
+ return;
+ }
+ keys = keys.map((name) => this.#rawState[name]).filter((key) => key.down);
+ if (keys.length < 2) {
+ return;
+ }
+ const latestTrigger = keys
+ .map((key) => key.lastTrigger || currentTime)
+ .reduce((lastMax, currentValue) => Math.max(lastMax, currentValue), 0);
+ keys.forEach((key) => (key.lastTrigger = latestTrigger));
+ }
+
+ setDefaultLEDColor() {
+ try {
+ const playerColor = this.player.data.color;
+ this.setLED(0, playerColor);
+ this.setLED(1, playerColor);
+ } catch (err) {
+ console.warn(
+ LOG_PREFIX +
+ `Keypad[${
+ this.#controllerId
+ }].setDefaultLEDColor() could not determine associated player`,
+ err
+ );
+ }
+ }
+ setLED(index, color) {
+ if (!this.#ledState[index]) {
+ console.error(
+ LOG_PREFIX +
+ `Keypad[${
+ this.#controllerId
+ }].setLED() tried to set unknown led at '${index}'`
+ );
+ return;
+ }
+ if (this.#ledState[index] !== color) {
+ this.#ledChanged = true;
+ this.#ledState[index] = color;
+ }
+ }
+ getLEDsIfChanged() {
+ if (this.#ledChanged) {
+ this.#ledChanged = false;
+ return this.#ledState;
+ }
+ return null;
+ }
+}
diff --git a/src/js/modules/ControllerManager/index.js b/src/js/modules/ControllerManager/index.js
new file mode 100644
index 0000000..c3e5b1a
--- /dev/null
+++ b/src/js/modules/ControllerManager/index.js
@@ -0,0 +1,154 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { LOG_PREFIX } from "../../settings/constants";
+import { hexToRgb } from "../../utils/color";
+import AbstractSubModule from "../AbstractSubModule";
+import Socket from "../socket";
+import Keypad from "./Keypad";
+const SUB_LOG_PREFIX = LOG_PREFIX + "ControllerManager: ";
+
+export default class ControllerManager extends AbstractSubModule {
+ /**
+ * @property {Keypad} #keypads.*
+ */
+ #keypads = {};
+
+ #tickThread = null;
+ #tickListeners = [];
+
+ #onRegisterFun = null;
+ #onKeyEventFun = null;
+
+ constructor(instance) {
+ super(instance);
+ this.#onRegisterFun = this.#onRegisterHandler.bind(this);
+ this.#onKeyEventFun = this.#onKeyEventHandler.bind(this);
+ this.socket.registerListener("registration", this.#onRegisterFun);
+ this.socket.registerListener("key-event", this.#onKeyEventFun);
+ this.#tickThread = window.setInterval(this.#tick.bind(this), 1000 / 30);
+ }
+
+ unhook() {
+ window.clearInterval(this.#tickThread);
+ this.#tickThread = null;
+ this.socket.unregisterListener("registration", this.#onRegisterFun);
+ this.socket.unregisterListener("key-event", this.#onKeyEventFun);
+ this.#tickListeners = [];
+ super.unhook();
+ }
+
+ static get moduleDependencies() {
+ return [...super.moduleDependencies, Socket.name];
+ }
+
+ /**
+ * @returns {Socket}
+ */
+ get socket() {
+ return this.instance.modules[Socket.name];
+ }
+
+ /**
+ * @type {Keypad[]}
+ */
+ get keypads() {
+ return Object.values(this.#keypads);
+ }
+
+ #onRegisterHandler(msg) {
+ if (msg.receiver) {
+ console.debug(
+ SUB_LOG_PREFIX +
+ "Got registration message from other receiver, ignoring!"
+ );
+ return;
+ }
+ const controllerId = msg["controller-id"];
+ if (msg.status === "connected") {
+ this.#keypads[controllerId] = new Keypad(this.instance, controllerId);
+ ui.notifications.info(
+ "Mind Flayer: " +
+ game.i18n.format("MindFlayer.Notifications.NewClient", {
+ controller: controllerId,
+ player: this.#keypads[controllerId].player?.name || "unassigned",
+ })
+ );
+ } else if (msg.status === "disconnected") {
+ ui.notifications.warn(
+ "Mind Flayer: " +
+ game.i18n.format("MindFlayer.Notifications.ClientDisconnected", {
+ controller: controllerId,
+ player: this.#keypads[controllerId].player?.name || "unassigned",
+ })
+ );
+ delete this.#keypads[controllerId];
+ }
+ }
+
+ #onKeyEventHandler(msg) {
+ const controllerId = msg["controller-id"];
+ if (!this.#keypads.hasOwnProperty(controllerId)) {
+ console.warn(
+ SUB_LOG_PREFIX +
+ `Keypad '${controllerId}' sent key-event before registration, ignoring!`
+ );
+ return;
+ }
+ this.#keypads[controllerId].registerKeyEvent(msg);
+ }
+
+ #tick() {
+ const frameTime = new Date().getTime();
+ this.#tickListeners.forEach((callback, i) => {
+ try {
+ callback(frameTime, this.#keypads);
+ } catch (err) {
+ console.error(
+ SUB_LOG_PREFIX + `Keypad Tick Listener [${i}] threw an error: `,
+ err
+ );
+ }
+ });
+ this.#sendChangedLEDs();
+ }
+
+ #sendChangedLEDs() {
+ for (let name in this.#keypads) {
+ if (!this.#keypads.hasOwnProperty(name)) {
+ continue;
+ }
+ const keypad = this.#keypads[name];
+ const leds = keypad.getLEDsIfChanged();
+ if (leds) {
+ const data = JSON.stringify({
+ type: "configuration",
+ "controller-id": keypad.controllerId,
+ led1: hexToRgb(leds[0]),
+ led2: hexToRgb(leds[1]),
+ });
+ this.socket.send(data);
+ }
+ }
+ }
+
+ registerTickListener(callback) {
+ this.#tickListeners.push(callback);
+ }
+
+ unregisterTickListener(callback) {
+ this.#tickListeners = this.#tickListeners.filter((c) => c !== callback);
+ }
+}
diff --git a/src/js/modules/ambilight/index.js b/src/js/modules/ambilight/index.js
new file mode 100644
index 0000000..3f07d3f
--- /dev/null
+++ b/src/js/modules/ambilight/index.js
@@ -0,0 +1,194 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { Rectangle, Vector } from "../../utils/2d-geometry";
+import { hexToRgb } from "../../utils/color";
+import AbstractSubModule from "../AbstractSubModule";
+import Socket from "../socket";
+
+export default class Ambilight extends AbstractSubModule {
+ #updateLEDsTimer = null;
+ #ambilightLastSent = "null";
+
+ constructor(instance) {
+ super(instance);
+ // setup the animation loop for reading the canvas for ambilight leds
+ this.#updateLEDsTimer = window.setInterval(
+ this._ambilightLoop.bind(this),
+ 1000 / this.instance.settings.ambilight.fps
+ );
+ }
+
+ unhook() {
+ window.clearInterval(this.#updateLEDsTimer);
+ super.unhook();
+ }
+
+ static get moduleDependencies() {
+ return [...super.moduleDependencies, Socket.name];
+ }
+
+ /**
+ * @returns {Socket}
+ */
+ get socket() {
+ return this.instance.modules[Socket.name];
+ }
+
+ /**
+ * @protected
+ */
+ async _ambilightLoop() {
+ this.ensureLoaded();
+ if (!this.instance.settings.ambilight.enabled) {
+ return;
+ }
+ const pixelsRaw = await this.loadPixels();
+ if (pixelsRaw !== null) {
+ this._sendAmbilightData(this._compileLEDData(pixelsRaw));
+ }
+ }
+
+ loadPixels() {
+ return new Promise((resolve, reject) => {
+ requestAnimationFrame(this._loadPixels.bind(this, resolve, reject));
+ });
+ }
+
+ /**
+ * Will only function correctly if call from within requestAnimationFrame()
+ * @protected
+ */
+ _loadPixels(resolve, reject) {
+ try {
+ const gl = game.canvas.app.renderer.gl;
+ const pixelsRaw = {
+ image: new Uint8Array(
+ gl.drawingBufferWidth * gl.drawingBufferHeight * 4 +
+ gl.drawingBufferHeight
+ ),
+ drawingBufferWidth: gl.drawingBufferWidth,
+ drawingBufferHeight: gl.drawingBufferHeight,
+ };
+ // bottom left of the screen is the origin
+ gl.readPixels(
+ 0,
+ 0,
+ gl.drawingBufferWidth,
+ gl.drawingBufferHeight,
+ gl.RGBA,
+ gl.UNSIGNED_BYTE,
+ pixelsRaw.image
+ );
+ resolve(pixelsRaw);
+ } catch (e) {
+ reject(e);
+ }
+ }
+
+ /**
+ * @protected
+ */
+ _compileLEDData(pixelsRaw) {
+ const ledCount = this.instance.settings.ambilight.led.count;
+ const brightMin = this.instance.settings.ambilight.brightness.min;
+ const brightRange =
+ (this.instance.settings.ambilight.brightness.max - brightMin) / 255;
+ const ledState = new Uint32Array(ledCount * 3);
+ const bounds = new Rectangle(
+ new Vector(0, 0),
+ new Vector(pixelsRaw.drawingBufferWidth, pixelsRaw.drawingBufferHeight)
+ );
+ const direction = new Vector(0, 1);
+ let ledOffset = this.instance.settings.ambilight.led.offset % ledCount;
+ if (ledOffset < 0) {
+ ledOffset = ledOffset + ledCount;
+ }
+ const angle = -(2 * Math.PI) / ledCount;
+ direction.rotate(angle * ledOffset);
+ let totalColor = 0;
+ for (let i = 0; i < ledCount; i++) {
+ const ledIndex = i * 3;
+ const imageIndex = this._findColorAlongVector(
+ pixelsRaw.image,
+ bounds,
+ direction
+ );
+ totalColor +=
+ pixelsRaw.image[imageIndex] +
+ pixelsRaw.image[imageIndex + 1] +
+ pixelsRaw.image[imageIndex + 2];
+ ledState[ledIndex] =
+ pixelsRaw.image[imageIndex] * brightRange + brightMin;
+ ledState[ledIndex + 1] =
+ pixelsRaw.image[imageIndex + 1] * brightRange + brightMin;
+ ledState[ledIndex + 2] =
+ pixelsRaw.image[imageIndex + 2] * brightRange + brightMin;
+ direction.rotate(angle);
+ }
+ if (totalColor == 0) {
+ return null;
+ }
+ return ledState;
+ }
+
+ /**
+ * @protected
+ */
+ _findColorAlongVector(image, bounds, direction) {
+ // scale vector so longer direction is length 1
+ const backgroundColor = hexToRgb(game.scenes.active.data.backgroundColor);
+ direction.scale(1 / Math.max(Math.abs(direction.x), Math.abs(direction.y)));
+ const scale = Math.floor(bounds.intersectionFromCenter(direction));
+ for (let i = scale; i >= 0; i--) {
+ const x = Math.floor(bounds.center.x + direction.x * i);
+ const y = Math.floor(bounds.center.y + direction.y * i);
+ const baseIndex = (x + y * bounds.p1.x) * 4;
+ if (
+ image[baseIndex] == backgroundColor.r &&
+ image[baseIndex + 1] == backgroundColor.g &&
+ image[baseIndex + 2] == backgroundColor.b
+ ) {
+ continue;
+ } else if (
+ image[baseIndex] != 0 ||
+ image[baseIndex + 1] != 0 ||
+ image[baseIndex + 2] != 0
+ ) {
+ return baseIndex;
+ }
+ }
+ return Math.floor(bounds.center.x + bounds.center.y * bounds.p1.x) * 4;
+ }
+
+ /**
+ * @protected
+ */
+ _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;
+ }
+ }
+}
diff --git a/src/js/modules/cameraControl/index.js b/src/js/modules/cameraControl/index.js
new file mode 100644
index 0000000..b22a2e0
--- /dev/null
+++ b/src/js/modules/cameraControl/index.js
@@ -0,0 +1,179 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import AbstractSubModule from "../AbstractSubModule";
+import * as TokenUtil from "../../utils/tokenUtil";
+import ControllerManager from "../ControllerManager";
+import { LOG_PREFIX, VTT_MODULE_NAME } from "../../settings/constants";
+
+const WRAP_Token_setPosition = "Token.prototype.setPosition";
+export default class CameraControl extends AbstractSubModule {
+ constructor(instance) {
+ super(instance);
+ let $this = this;
+ console.debug(
+ LOG_PREFIX +
+ "overriding camera pan to focus on all player tokens instead of the current moved one."
+ );
+ libWrapper.register(
+ VTT_MODULE_NAME,
+ WRAP_Token_setPosition,
+ async function wrapperTokenSetPosition(wrapped, ...args) {
+ return await $this.#Token_setPosition(this, wrapped, ...args);
+ },
+ libWrapper.MIXED
+ );
+ }
+
+ unhook() {
+ libWrapper.unregister(VTT_MODULE_NAME, WRAP_Token_setPosition);
+ super.unhook();
+ }
+
+ static get moduleDependencies() {
+ return [...super.moduleDependencies, ControllerManager.name];
+ }
+
+ /**
+ * @returns {ControllerManager}
+ */
+ get controllerManager() {
+ return this.instance.modules[ControllerManager.name];
+ }
+
+ async #Token_setPosition(token, wrapped, x, y, { animate = true } = {}) {
+ let cameraControl = this.instance.settings.camera.control;
+ if (cameraControl == "off" || cameraControl == "focusPlayers") {
+ // Create a Ray for the requested movement
+ let origin = token._movement ? token.position : token._validPosition,
+ target = { x: x, y: y },
+ isVisible = token.isVisible;
+
+ // Create the movement ray
+ let ray = new Ray(origin, target);
+
+ // Update the new valid position
+ token._validPosition = target;
+
+ // Record the Token's new velocity
+ token._velocity = token._updateVelocity(ray);
+
+ // Update visibility for a non-controlled token which may have moved into the controlled tokens FOV
+ token.visible = isVisible;
+
+ // Conceal the HUD if it targets this Token
+ if (token.hasActiveHUD) token.layer.hud.clear();
+
+ // Either animate movement to the destination position, or set it directly if animation is disabled
+ if (animate) await token.animateMovement(new Ray(token.position, ray.B));
+ else token.position.set(x, y);
+
+ // Re-center the view on all players if the moved token is visible
+ if (cameraControl == "focusPlayers" && isVisible) {
+ this.panCamera();
+ }
+
+ return token;
+ }
+
+ // use default camera control behavior for token movement
+ return await wrapped(x, y, ({ animate = true } = {}));
+ }
+
+ panCamera() {
+ const sceneSize = canvas.scene.dimensions.sceneRect;
+ const gridSize = canvas.scene.dimensions.size;
+ let activeCharacterTokens = TokenUtil.getAllCombatTokens();
+ activeCharacterTokens.push(
+ ...this.controllerManager.keypads.map((keypad) => keypad.token)
+ );
+ activeCharacterTokens = activeCharacterTokens.filter(
+ (token) => token !== null
+ );
+ if (activeCharacterTokens.length <= 0) {
+ console.warn(
+ LOG_PREFIX +
+ "No active character tokens found. Automatic camera panning only works with active controllers that belong to a player with a character token in the same scene."
+ );
+ return;
+ }
+ activeCharacterTokens = activeCharacterTokens.filter((token) =>
+ token.combatant
+ ? !token.combatant.data.hidden && !token.combatant.data.defeated
+ : true
+ );
+
+ const pad = gridSize * (30 / 5);
+ const lowestXCoordinate = Math.max(
+ Math.min(...activeCharacterTokens.map((token) => token.x)) - pad,
+ sceneSize.x
+ );
+ const highestXCoordinate = Math.min(
+ Math.max(...activeCharacterTokens.map((token) => token.x + token.w)) +
+ pad,
+ sceneSize.x + sceneSize.width
+ );
+
+ const lowestYCoordinate = Math.max(
+ Math.min(...activeCharacterTokens.map((token) => token.y)) - pad,
+ sceneSize.y
+ );
+ const highestYCoordinate = Math.min(
+ Math.max(...activeCharacterTokens.map((token) => token.y + token.h)) +
+ pad,
+ sceneSize.y + sceneSize.height
+ );
+
+ const boundingbox = {
+ width: highestXCoordinate - lowestXCoordinate,
+ height: highestYCoordinate - lowestYCoordinate,
+ };
+ const boundingWidthScale = window.innerWidth / boundingbox.width;
+ const boundingHeightScale = window.innerHeight / boundingbox.height;
+ let scale = Math.min(boundingWidthScale, boundingHeightScale);
+ const sceneWidthScale = window.innerWidth / sceneSize.width;
+ const sceneHeightScale = window.innerHeight / sceneSize.height;
+ const sceneScaleMin = Math.min(sceneWidthScale, sceneHeightScale);
+ scale = Math.max(sceneScaleMin, scale);
+
+ let targetXCoordinate =
+ lowestXCoordinate + (highestXCoordinate - lowestXCoordinate) / 2;
+ let targetYCoordinate =
+ lowestYCoordinate + (highestYCoordinate - lowestYCoordinate) / 2;
+ const minPadX = (window.innerWidth * scale) / 2;
+ targetXCoordinate = Math.max(
+ sceneSize.x + minPadX,
+ Math.min(targetXCoordinate, sceneSize.x + sceneSize.width - minPadX)
+ );
+ const minPadY = (window.innerHeight * scale) / 2;
+ targetYCoordinate = Math.max(
+ sceneSize.y + minPadY,
+ Math.min(targetYCoordinate, sceneSize.y + sceneSize.height - minPadY)
+ );
+
+ const cameraSettings = {
+ x: targetXCoordinate,
+ y: targetYCoordinate,
+ scale: scale,
+ duration: 1000,
+ };
+ console.debug(
+ LOG_PREFIX +
+ "Readjusting view to fit all player tokens on screen... Centering on: ",
+ cameraSettings
+ );
+ canvas.animatePan(cameraSettings);
+ }
+}
diff --git a/src/js/modules/doorHandler/index.js b/src/js/modules/doorHandler/index.js
new file mode 100644
index 0000000..a282807
--- /dev/null
+++ b/src/js/modules/doorHandler/index.js
@@ -0,0 +1,105 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import AbstractSubModule from "../AbstractSubModule";
+import ControllerManager from "../ControllerManager";
+import * as TokenUtil from "../../utils/tokenUtil";
+import { Keypad } from "../ControllerManager/Keypad";
+import { Rectangle, Vector } from "../../utils/2d-geometry";
+import { LOG_PREFIX } from "../../settings/constants";
+
+export default class DoorHandler extends AbstractSubModule {
+ #nextDoorTimestamp;
+ #doorQueue = [];
+ #tickHandlerFun;
+
+ constructor(instance) {
+ super(instance);
+ this.#nextDoorTimestamp = new Date().getTime();
+ this.#tickHandlerFun = this.#tickHandler.bind(this);
+ this.controllerManager.registerTickListener(this.#tickHandlerFun);
+ }
+
+ unhook() {
+ this.controllerManager.unregisterTickListener(this.#tickHandlerFun);
+ super.unhook();
+ }
+
+ static get moduleDependencies() {
+ return [...super.moduleDependencies, ControllerManager.name];
+ }
+
+ /**
+ * @returns {ControllerManager}
+ */
+ get controllerManager() {
+ return this.instance.modules[ControllerManager.name];
+ }
+
+ #tickHandler(now, keypads) {
+ Object.values(keypads).forEach((keypad) => {
+ if (keypad.isJustDown("SPC", now)) {
+ this.#enqueueDoors(keypad);
+ }
+ });
+ this.#processDoorQueue(now);
+ }
+
+ #processDoorQueue(now) {
+ if (this.#nextDoorTimestamp <= now && this.#doorQueue.length > 0) {
+ const doorCR = this.#doorQueue.shift();
+ console.debug(
+ LOG_PREFIX +
+ `${doorCR.player.name}[${doorCR.token.name}]: toggling the door `,
+ doorCR.door
+ );
+ doorCR.door.doorControl._onMouseDown(new MouseEvent("mousedown"));
+ this.#nextDoorTimestamp = now + 150;
+ }
+ }
+
+ /**
+ * @param {Keypad} keypad
+ */
+ #enqueueDoors(keypad) {
+ const player = keypad.player;
+ const token = TokenUtil.getTokenFor(player);
+
+ const interactionBounds = new Rectangle(
+ new Vector(
+ token.x - canvas.grid.size,
+ token.y + token.height + canvas.grid.size
+ ),
+ new Vector(
+ token.x + token.width + canvas.grid.size,
+ token.y - canvas.grid.size
+ )
+ );
+
+ canvas.walls.doors.forEach((door) => {
+ if (
+ door.doorControl &&
+ interactionBounds.intersect(Rectangle.fromBounds(door.bounds)) &&
+ !this.#doorQueue.find((d) => d.door === door)
+ ) {
+ this.#doorQueue.push({
+ player,
+ token,
+ door,
+ });
+ }
+ });
+ }
+}
diff --git a/src/js/modules/fullscreen/index.js b/src/js/modules/fullscreen/index.js
new file mode 100644
index 0000000..5298170
--- /dev/null
+++ b/src/js/modules/fullscreen/index.js
@@ -0,0 +1,120 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { LOG_PREFIX, VTT_MODULE_NAME } from "../../settings/constants";
+import AbstractSubModule from "../AbstractSubModule";
+import WakeLock from "../wakeLock";
+const SUB_LOG_PREFIX = LOG_PREFIX + "Fullscreen: ";
+
+const WRAP_KeyboardManager_handleKeys = "KeyboardManager.prototype._handleKeys";
+const WRAP_PlaceableObject_can = "PlaceableObject.prototype.can";
+
+export default class Fullscreen extends AbstractSubModule {
+ #keyboardManagerHandleKeysWrapperFun = null;
+
+ constructor(instance) {
+ super(instance);
+ console.debug(
+ SUB_LOG_PREFIX + "overriding Key handling to add F10 to hide UI."
+ );
+ libWrapper.register(
+ VTT_MODULE_NAME,
+ WRAP_PlaceableObject_can,
+ this.#placeableObjectCanWrapper.bind(this),
+ libWrapper.WRAPPER
+ );
+ this.#keyboardManagerHandleKeysWrapperFun =
+ this.#keyboardManagerHandleKeysWrapper.bind(this);
+ if (isNewerVersion(game.version || game.data.version, "0.9.0")) {
+ game.keybindings.register(VTT_MODULE_NAME, "hideUI", {
+ name: "Hide UI",
+ hint: "When the key is released, the game UI is toggled invisible.",
+ uneditable: [
+ {
+ key: "hideUI",
+ modifiers: [],
+ },
+ ],
+ editable: [
+ {
+ key: "F10",
+ },
+ ],
+ onDown: () => {},
+ onUp: () => {
+ this.enabled = !this.enabled;
+ },
+ restricted: false, // Restrict this Keybinding to gamemaster only?
+ reservedModifiers: [], // If the ALT modifier is pressed, the notification is permanent instead of temporary
+ precedence: CONST.KEYBINDING_PRECEDENCE.NORMAL,
+ });
+ } else {
+ libWrapper.register(
+ VTT_MODULE_NAME,
+ WRAP_KeyboardManager_handleKeys,
+ this.#keyboardManagerHandleKeysWrapperFun,
+ libWrapper.MIXED
+ );
+ }
+ }
+
+ unhook() {
+ libWrapper.unregister(VTT_MODULE_NAME, WRAP_KeyboardManager_handleKeys);
+ libWrapper.unregister(VTT_MODULE_NAME, WRAP_PlaceableObject_can);
+ super.unhook();
+ }
+
+ static get moduleDependencies() {
+ return [...super.moduleDependencies, WakeLock.name];
+ }
+
+ /**
+ * @returns {WakeLock}
+ */
+ get wakeLock() {
+ return this.instance.modules[WakeLock.name];
+ }
+
+ get enabled() {
+ return jQuery(document.body).hasClass("hide-ui");
+ }
+
+ set enabled(value) {
+ const $body = jQuery(document.body);
+ if (value) {
+ $body.addClass("hide-ui");
+ } else {
+ $body.removeClass("hide-ui");
+ }
+ this.wakeLock.enabled = this.enabled;
+ this.wakeLock.ensureWakeLock();
+ }
+
+ #placeableObjectCanWrapper(wrapped, user, action) {
+ if (action == "control" && this.enabled) {
+ return false;
+ }
+ return wrapped(user, action);
+ }
+
+ #keyboardManagerHandleKeysWrapper(wrapped, event, key, state) {
+ const result = wrapped(event, key, state);
+ if (key == "F10" && state == false) {
+ event.preventDefault();
+ this.enabled = !this.enabled;
+ }
+ return result;
+ }
+}
diff --git a/src/js/modules/loader.js b/src/js/modules/loader.js
new file mode 100644
index 0000000..2a3db14
--- /dev/null
+++ b/src/js/modules/loader.js
@@ -0,0 +1,109 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { LOG_PREFIX } from "../settings/constants";
+import { DepGraph } from "dependency-graph";
+import MindFlayer from "../MindFlayer";
+
+function importAll(contextRequire) {
+ return contextRequire.keys().map((module) => contextRequire(module));
+}
+const subModules = importAll(require.context("./", true, /\/index\.js$/));
+
+/**
+ * @var {DepGraph} dependencyGraph
+ */
+let dependencyGraph = null;
+
+/**
+ * Load all submodules in the order in which they are dependent on one another
+ *
+ * @param {MindFlayer} instance
+ */
+export default function init(instance) {
+ console.debug(LOG_PREFIX + "Sorting submodules");
+ subModules.sort((a, b) => {
+ const bDeps = b.default.moduleDependencies;
+ if (bDeps.includes(a.default.name)) {
+ return -1;
+ }
+ const aDeps = a.default.moduleDependencies;
+ if (aDeps.includes(b.default.name)) {
+ return 1;
+ }
+ return aDeps.length - bDeps.length;
+ });
+ console.info(LOG_PREFIX + "Starting submodules");
+
+ __loadModules(instance, subModules);
+
+ console.info(LOG_PREFIX + "Submodules ready");
+}
+
+function buildDependencyGraph() {
+ if (dependencyGraph !== null) {
+ return;
+ }
+ dependencyGraph = new DepGraph();
+ subModules.forEach((mod) => {
+ dependencyGraph.addNode(mod.default.name);
+ });
+ subModules.forEach((mod) => {
+ mod.default.moduleDependencies.forEach((dependency) => {
+ dependencyGraph.addDependency(mod.default.name, dependency);
+ });
+ });
+}
+
+function __loadModules(instance, modules) {
+ modules.forEach((element) => {
+ console.debug(`${LOG_PREFIX}Starting Module: ${element.default.name}`);
+ instance.modules[element.default.name] = new element.default(instance);
+ });
+}
+
+function __unloadModules(instance, modules) {
+ for (let i = modules.length - 1; i >= 0; i--) {
+ const mod = modules[i];
+ instance.modules[mod].unhook();
+ delete instance.modules[mod];
+ }
+}
+
+/**
+ * Restarts the given Module and all its dependants
+ *
+ * @param {MindFlayer} instance
+ * @param {string} module
+ */
+function _reload(instance, module) {
+ buildDependencyGraph();
+ const moduleNamesToReload = [
+ module,
+ ...dependencyGraph.dependantsOf(module, false),
+ ];
+ const loadOrderNames = dependencyGraph
+ .overallOrder(false)
+ .filter(moduleNamesToReload.includes);
+
+ __unloadModules(instance, loadOrderNames);
+
+ const modules = loadOrderNames.map((name) =>
+ subModules.find((mod) => mod.default.name === name)
+ );
+ __loadModules(instance, modules);
+}
+
+export const reload = foundry.utils.debounce(_reload, 500);
diff --git a/src/js/modules/playerLogin/index.js b/src/js/modules/playerLogin/index.js
new file mode 100644
index 0000000..b3faa5c
--- /dev/null
+++ b/src/js/modules/playerLogin/index.js
@@ -0,0 +1,51 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import AbstractSubModule from "../AbstractSubModule";
+import Socket from "../socket";
+
+export default class PlayerLogin extends AbstractSubModule {
+ #messageHandlerFun;
+
+ constructor(instance) {
+ super(instance);
+ this.#messageHandlerFun = this.#messageHandler.bind(this);
+ this.socket.registerListener("keyboard-login", this.#messageHandlerFun);
+ }
+
+ unhook() {
+ this.socket.unregisterListener("keyboard-login", this.#messageHandlerFun);
+ super.unhook();
+ }
+
+ static get moduleDependencies() {
+ return [...super.moduleDependencies, Socket.name];
+ }
+
+ /**
+ * @returns {Socket}
+ */
+ get socket() {
+ return this.instance.modules[Socket.name];
+ }
+
+ #messageHandler(message) {
+ const settings = this.instance.settings.settings;
+
+ settings.mappings[message["player-id"]] = message["controller-id"];
+
+ this.instance.settings.settings = settings;
+ }
+}
diff --git a/src/js/modules/socket/index.js b/src/js/modules/socket/index.js
new file mode 100644
index 0000000..9cbe591
--- /dev/null
+++ b/src/js/modules/socket/index.js
@@ -0,0 +1,184 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { LOG_PREFIX } from "../../settings/constants";
+import AbstractSubModule from "../AbstractSubModule";
+
+const SUB_LOG_PREFIX = LOG_PREFIX + "Socket: ";
+
+export default class Socket extends AbstractSubModule {
+ #connection = null;
+ #onmessageFun = null;
+ #onopenFun = null;
+ #oncloseFun = null;
+ #onerrorFun = null;
+ #initializeWebsocketFun = null;
+ #handlers = {};
+
+ constructor(instance) {
+ super(instance);
+
+ this.#onmessageFun = this._onmessage.bind(this);
+ this.#onopenFun = this._onopen.bind(this);
+ this.#oncloseFun = this._onclose.bind(this);
+ this.#onerrorFun = this._onerror.bind(this);
+ this.#initializeWebsocketFun = this._initializeWebsocket.bind(this);
+
+ this._initializeWebsocket();
+ }
+
+ unhook() {
+ try {
+ this.send(
+ JSON.stringify({
+ type: "registration",
+ status: "disconnected",
+ receiver: true,
+ players: [],
+ })
+ );
+ } catch (err) {
+ console.debug(SUB_LOG_PREFIX + "Failed to send disconnect message", err);
+ }
+ this.#connection.close();
+ this.#connection = null;
+ super.unhook();
+ }
+
+ get isConnected() {
+ return (
+ this.#connection !== null &&
+ this.#connection.readyState === this.#connection.OPEN
+ );
+ }
+
+ registerListener(type, callback) {
+ if (!Array.isArray(this.#handlers[type])) {
+ this.#handlers[type] = [];
+ }
+ this.#handlers[type].push(callback);
+ }
+
+ unregisterListener(type, callback) {
+ if (!Array.isArray(this.#handlers[type])) {
+ return;
+ }
+ this.#handlers[type] = this.#handlers[type].filter((c) => c !== callback);
+ }
+
+ ensureConnected() {
+ this.ensureLoaded();
+ if (!this.isConnected) {
+ throw new ReferenceError(
+ `The module 'Socket' does not have a connection`
+ );
+ }
+ }
+
+ send(data) {
+ this.ensureConnected();
+ this.#connection.send(data);
+ }
+
+ _initializeWebsocket() {
+ this.#connection = new WebSocket(this.instance.settings.websocket.url);
+ this.#connection.addEventListener("open", this.#onopenFun);
+ this.#connection.addEventListener("error", this.#onerrorFun);
+ this.#connection.addEventListener("message", this.#onmessageFun);
+ this.#connection.addEventListener("close", this.#oncloseFun);
+ }
+
+ _onmessage(message) {
+ const data = JSON.parse(message.data);
+ console.debug(SUB_LOG_PREFIX + "Received message: ", data);
+ try {
+ this._dispatch(data);
+ } catch (error) {
+ console.error(SUB_LOG_PREFIX + "Error dispatching: ", error);
+ }
+ }
+
+ _onopen(data) {
+ ui.notifications.info(
+ "Mind Flayer: " +
+ game.i18n.format("MindFlayer.Notifications.Connected", {
+ host: this.instance.settings.websocket.host,
+ port: this.instance.settings.websocket.port,
+ path: this.instance.settings.websocket.path,
+ })
+ );
+ console.log(SUB_LOG_PREFIX + "Connected! ", data);
+ this.send(
+ JSON.stringify({
+ type: "registration",
+ status: "connected",
+ receiver: true,
+ players: game.users.players.map((player) => ({
+ id: player.id,
+ name: player.name,
+ })),
+ })
+ );
+ }
+
+ _onclose() {
+ this.#connection = null;
+ if (this.loaded) {
+ ui.notifications.error(
+ "Mind Flayer: " +
+ game.i18n.localize("MindFlayer.Notifications.ConnectionClosed")
+ );
+ console.warn(
+ SUB_LOG_PREFIX +
+ "Websocket connection closed, attempting to reconnect in 5 seconds..."
+ );
+ setTimeout(this.#initializeWebsocketFun, 5000);
+ }
+ }
+
+ _onerror(error) {
+ ui.notifications.error(
+ "Mind Flayer: " + game.i18n.localize("MindFlayer.Notifications.Error")
+ );
+ console.error(SUB_LOG_PREFIX + "Error! ", error);
+ this.#connection.close();
+ }
+
+ _dispatch(data) {
+ Object.freeze(data);
+ if (!data.hasOwnProperty("type")) {
+ console.error(SUB_LOG_PREFIX + "Received message without type: ", data);
+ return;
+ }
+ if (!Array.isArray(this.#handlers[data.type])) {
+ console.warn(
+ SUB_LOG_PREFIX + "Received message with unhandled type: ",
+ data
+ );
+ return;
+ }
+ this.#handlers[data.type].forEach((callback, i) => {
+ try {
+ callback(data);
+ } catch (err) {
+ // ignore and log any errors
+ console.warn(
+ SUB_LOG_PREFIX + `Handler [${data.type}][${i}] threw an error: `,
+ err
+ );
+ }
+ });
+ }
+}
diff --git a/src/js/modules/tokenBorder/index.js b/src/js/modules/tokenBorder/index.js
new file mode 100644
index 0000000..355017f
--- /dev/null
+++ b/src/js/modules/tokenBorder/index.js
@@ -0,0 +1,71 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { LOG_PREFIX, VTT_MODULE_NAME } from "../../settings/constants";
+import { hexToRgb } from "../../utils/color";
+import * as TokenUtil from "../../utils/tokenUtil";
+import AbstractSubModule from "../AbstractSubModule";
+import Socket from "../socket";
+const SUB_LOG_PREFIX = LOG_PREFIX + "TokenBorder: ";
+
+const REF_Token_getBorderColor = "Token.prototype._getBorderColor";
+export default class TokenBorder extends AbstractSubModule {
+ constructor(instance) {
+ super(instance);
+ const $this = this;
+ console.debug(
+ SUB_LOG_PREFIX +
+ "overriding Token Border Color to add display user select."
+ );
+ libWrapper.register(
+ VTT_MODULE_NAME,
+ REF_Token_getBorderColor,
+ function (wrapped, ...args) {
+ return $this.#getBorderColorWrapper(wrapped, this, ...args);
+ },
+ libWrapper.MIXED
+ );
+ TokenUtil.refreshTokenPlaceables();
+ }
+
+ unhook() {
+ libWrapper.unregister(VTT_MODULE_NAME, REF_Token_getBorderColor, false);
+ super.unhook();
+ }
+
+ static get moduleDependencies() {
+ return [...super.moduleDependencies, Socket.name];
+ }
+
+ /**
+ * @returns {Socket}
+ */
+ get socket() {
+ return this.instance.modules[Socket.name];
+ }
+
+ #getBorderColorWrapper(wrapped, token, ...args) {
+ if (this.socket.isConnected && token.actor && token.actor.hasPlayerOwner) {
+ const player = TokenUtil.getUserIfSelectedTokenIs(token);
+ if (player) {
+ const color = hexToRgb(player.data.color);
+ return (
+ ((color.r & 0xff) << 16) | ((color.g & 0xff) << 8) | (color.b & 0xff)
+ );
+ }
+ }
+ return wrapped(...args);
+ }
+}
diff --git a/src/js/modules/tokenMovement/index.js b/src/js/modules/tokenMovement/index.js
new file mode 100644
index 0000000..6d481bd
--- /dev/null
+++ b/src/js/modules/tokenMovement/index.js
@@ -0,0 +1,154 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import AbstractSubModule from "../AbstractSubModule";
+import ControllerManager from "../ControllerManager";
+import { deg2rad, Vector } from "../../utils/2d-geometry";
+import Keypad from "../ControllerManager/Keypad";
+import { LOG_PREFIX } from "../../settings/constants";
+
+const SUB_LOG_PREFIX = LOG_PREFIX + "TokenMovement: ";
+
+export default class TokenMovement extends AbstractSubModule {
+ #tickHandlerFun;
+
+ constructor(instance) {
+ super(instance);
+ this.#tickHandlerFun = this.#tickHandler.bind(this);
+ this.instance.modules[ControllerManager.name].registerTickListener(
+ this.#tickHandlerFun
+ );
+ }
+
+ unhook() {
+ this.controllerManager.unregisterTickListener(this.#tickHandlerFun);
+ super.unhook();
+ }
+
+ static get moduleDependencies() {
+ return [...super.moduleDependencies, ControllerManager.name];
+ }
+
+ /**
+ * @returns {ControllerManager}
+ */
+ get controllerManager() {
+ return this.instance.modules[ControllerManager.name];
+ }
+
+ /**
+ * Called once per Keypad tick/frame to handle interaction with the keypad
+ *
+ * @param {number} now the timestamp of the current Keypad "frame"
+ * @param {Keypad[]} keypads an array of all connected Keypads
+ */
+ #tickHandler(now, keypads) {
+ Object.values(keypads).forEach((keypad) => {
+ this.#handleMovement(now, keypad);
+ if (keypad.isDown("SHI") && keypad.isJustDown("C", now)) {
+ this.#rotateKeypad(keypad);
+ }
+ });
+ }
+
+ /**
+ * Rotates the keypad so that the movements are rotated clockwise by 90 deg
+ * @param {Keypad} keypad a keypad client that has been mapped from the websocket message data
+ */
+ #rotateKeypad(keypad) {
+ const newRotation = keypad.rotation + 90;
+ const token = keypad.token;
+ if (token) {
+ const north = new Vector(0, -1);
+ north.rotate(deg2rad(newRotation));
+ canvas.tokens.moveMany({
+ dx: Math.round(north.x),
+ dy: Math.round(north.y),
+ rotate: true,
+ ids: [token.id],
+ });
+ }
+ ui.notifications.info(
+ "Mind Flayer: " +
+ game.i18n.format("MindFlayer.Notifications.ChangeDirection", {
+ player: keypad.player?.name || "unassigned",
+ orientation: newRotation,
+ })
+ );
+ keypad.rotation = newRotation;
+ }
+
+ /**
+ * Handles token movement and rotation.
+ *
+ * @param {number} now the timestamp of the current Keypad "frame"
+ * @param {Keypad} keypad a keypad client that has been mapped from the websocket message data
+ * @private
+ */
+ async #handleMovement(now, keypad) {
+ const token = keypad.token;
+ if (!token) {
+ return;
+ }
+
+ keypad.syncRepetitions(["W", "A", "S", "D"], now);
+ const rotateOnly = keypad.isDown("SHI");
+ const direction = new Vector(0, 0);
+ // Track the movement set
+ if (keypad.isRepeatedDown("W", now)) {
+ direction.y -= 1;
+ }
+ if (keypad.isRepeatedDown("D", now)) {
+ direction.x += 1;
+ }
+ if (keypad.isRepeatedDown("S", now)) {
+ direction.y += 1;
+ }
+ if (keypad.isRepeatedDown("A", now)) {
+ direction.x -= 1;
+ }
+ if (direction.length() >= 1) {
+ direction.rotate(deg2rad(keypad.rotation));
+ direction.x = Math.round(direction.x);
+ direction.y = Math.round(direction.y);
+
+ // Logging movement action
+ console.debug(
+ SUB_LOG_PREFIX +
+ `${keypad.player.name}: ${rotateOnly ? "Rotating" : "Moving"} ${
+ token.name
+ } to direction`,
+ direction
+ );
+
+ // Perform the shift or rotation
+ await canvas.tokens.moveMany({
+ dx: direction.x,
+ dy: direction.y,
+ rotate: rotateOnly,
+ ids: [token.id],
+ });
+
+ if (!rotateOnly) {
+ await canvas.tokens.moveMany({
+ dx: direction.x,
+ dy: direction.y,
+ rotate: true,
+ ids: [token.id],
+ });
+ }
+ }
+ }
+}
diff --git a/src/js/modules/tokenSelect/index.js b/src/js/modules/tokenSelect/index.js
new file mode 100644
index 0000000..f1878b7
--- /dev/null
+++ b/src/js/modules/tokenSelect/index.js
@@ -0,0 +1,100 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import AbstractSubModule from "../AbstractSubModule";
+import ControllerManager from "../ControllerManager";
+import * as TokenUtil from "../../utils/tokenUtil";
+import Keypad from "../ControllerManager/Keypad";
+import { LOG_PREFIX, VTT_MODULE_NAME } from "../../settings/constants";
+
+export default class TokenSelect extends AbstractSubModule {
+ #tickHandlerFun;
+
+ constructor(instance) {
+ super(instance);
+ this.#tickHandlerFun = this.#tickHandler.bind(this);
+ this.instance.modules[ControllerManager.name].registerTickListener(
+ this.#tickHandlerFun
+ );
+ }
+
+ unhook() {
+ this.controllerManager.unregisterTickListener(this.#tickHandlerFun);
+ super.unhook();
+ }
+
+ static get moduleDependencies() {
+ return [...super.moduleDependencies, ControllerManager.name];
+ }
+
+ /**
+ * @returns {ControllerManager}
+ */
+ get controllerManager() {
+ return this.instance.modules[ControllerManager.name];
+ }
+
+ /**
+ * Called once per Keypad tick/frame to handle interaction with the keypad
+ *
+ * @param {number} now the timestamp of the current Keypad "frame"
+ * @param {Keypad[]} keypads an array of all connected Keypads
+ */
+ #tickHandler(now, keypads) {
+ Object.values(keypads).forEach((keypad) => {
+ if (keypad.isJustDown("Q", now)) {
+ this.#selectNextToken(keypad);
+ }
+ });
+ }
+
+ /**
+ * Select the next Token associated with the player of the given keypad
+ * @param {Keypad} keypad
+ */
+ #selectNextToken(keypad) {
+ const player = keypad.player;
+ if (player === null) {
+ return;
+ }
+ const currentTokenId = game.user.getFlag(
+ VTT_MODULE_NAME,
+ "selectedToken_" + player.id
+ );
+
+ if (!currentTokenId) {
+ TokenUtil.setDefaultToken(player);
+ } else {
+ const tokens = TokenUtil.findAllTokensFor(player);
+ let i = 0;
+ for (; i < tokens.length; i++) {
+ if (currentTokenId == tokens[i].id) {
+ break;
+ }
+ }
+ i = (i + 1) % tokens.length;
+ game.user.setFlag(
+ VTT_MODULE_NAME,
+ "selectedToken_" + player.id,
+ tokens[i].id
+ );
+ console.debug(
+ LOG_PREFIX +
+ `selected token '${tokens[i].name}' for player '${player.name}'`
+ );
+ }
+ TokenUtil.refreshTokenPlaceables();
+ }
+}
diff --git a/src/js/modules/tokenTorch/index.js b/src/js/modules/tokenTorch/index.js
new file mode 100644
index 0000000..9da0d79
--- /dev/null
+++ b/src/js/modules/tokenTorch/index.js
@@ -0,0 +1,97 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import AbstractSubModule from "../AbstractSubModule";
+import ControllerManager from "../ControllerManager";
+import Keypad from "../ControllerManager/Keypad";
+import { LOG_PREFIX } from "../../settings/constants";
+
+const SUB_LOG_PREFIX = LOG_PREFIX + "TokenMovement: ";
+
+export default class TokenTorch extends AbstractSubModule {
+ #tickHandlerFun = null;
+
+ constructor(instance) {
+ super(instance);
+ this.#tickHandlerFun = this.#tickHandler.bind(this);
+ this.instance.modules[ControllerManager.name].registerTickListener(
+ this.#tickHandlerFun
+ );
+ }
+
+ unhook() {
+ this.controllerManager.unregisterTickListener(this.#tickHandlerFun);
+ super.unhook();
+ }
+
+ static get moduleDependencies() {
+ return [...super.moduleDependencies, ControllerManager.name];
+ }
+
+ /**
+ * @returns {ControllerManager}
+ */
+ get controllerManager() {
+ return this.instance.modules[ControllerManager.name];
+ }
+
+ /**
+ * Called once per Keypad tick/frame to handle interaction with the keypad
+ *
+ * @param {number} now the timestamp of the current Keypad "frame"
+ * @param {Keypad[]} keypads an array of all connected Keypads
+ */
+ #tickHandler(now, keypads) {
+ Object.values(keypads).forEach((keypad) => {
+ if (keypad.isJustDown("E", now)) {
+ this.#toggleTorch(keypad);
+ }
+ });
+ }
+
+ /**
+ * Toggle the light arround the currently selected token of the given keypad
+ *
+ * @param {Keypad} keypad keypad which initiated the torch request
+ * @private
+ */
+ #toggleTorch(keypad) {
+ const token = keypad.token;
+ if (!token) {
+ return;
+ }
+
+ if (!token.emitsLight) {
+ console.debug(
+ SUB_LOG_PREFIX +
+ keypad.player.name +
+ ": Turn on torch for " +
+ token.name
+ );
+ token.update({
+ brightLight: 20,
+ dimLight: 40,
+ lightAlpha: 0.12,
+ lightColor: "#ffad58",
+ lightAnimation: { type: "torch", speed: 5, intensity: 5 },
+ });
+ } else {
+ console.debug(
+ LOG_PREFIX + keypad.player.name + ": Turn off torch for " + token.name
+ );
+ token.update({ brightLight: 0, dimLight: 0 });
+ }
+ }
+}
diff --git a/src/js/modules/wakeLock/index.js b/src/js/modules/wakeLock/index.js
new file mode 100644
index 0000000..971b366
--- /dev/null
+++ b/src/js/modules/wakeLock/index.js
@@ -0,0 +1,68 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { LOG_PREFIX } from "../../settings/constants";
+import AbstractSubModule from "../AbstractSubModule";
+
+const SUB_LOG_PREFIX = LOG_PREFIX + "WakeLock: ";
+
+/**
+ * Uses Navigator.wakeLock to keep the Screensaver from activating
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Navigator/wakeLock
+ */
+export default class WakeLock extends AbstractSubModule {
+ enabled = false;
+ #wakeLock = null;
+ #wakeLockFun = null;
+
+ constructor(instance) {
+ super(instance);
+ this.#wakeLockFun = this.ensureWakeLock.bind(this);
+ document.addEventListener("visibilitychange", this.#wakeLockFun);
+ }
+
+ unhook() {
+ this.enabled = false;
+ document.removeEventListener("visibilitychange", this.#wakeLockFun);
+ super.unhook();
+ }
+
+ async ensureWakeLock() {
+ if (this.enabled && document.visibilityState === "visible") {
+ if (this.#wakeLock !== null && !this.#wakeLock.released) {
+ return;
+ }
+ try {
+ this.#wakeLock = await navigator.wakeLock.request();
+ const $this = this;
+ this.#wakeLock.addEventListener("release", () => {
+ $this.#wakeLock = null;
+ console.debug(SUB_LOG_PREFIX + "screen lock released");
+ });
+ console.debug(SUB_LOG_PREFIX + "locked the screen awake");
+ } catch (err) {
+ console.error(
+ SUB_LOG_PREFIX + `Error locking ${err.name}, ${err.message}`
+ );
+ }
+ } else if (this.#wakeLock != null) {
+ if (this.#wakeLock.released) {
+ this.#wakeLock = null;
+ } else {
+ this.#wakeLock.release();
+ }
+ }
+ }
+}
diff --git a/src/js/settings/TokenControllerConfig.js b/src/js/settings/TokenControllerConfig.js
new file mode 100644
index 0000000..a440ae4
--- /dev/null
+++ b/src/js/settings/TokenControllerConfig.js
@@ -0,0 +1,106 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { settings } from ".";
+import * as TokenUtil from "../utils/tokenUtil";
+import { VTT_MODULE_NAME } from "./constants";
+
+/**
+ * Form application to assign controllers to players.
+ */
+export class TokenControllerConfig extends FormApplication {
+ static get defaultOptions() {
+ return mergeObject(super.defaultOptions, {
+ title: game.i18n.localize("MindFlayer.configTitle"),
+ id: "mindflayer-token-controller-config",
+ template:
+ "modules/mindflayer-token-controller/templates/keyboard-config.html",
+ width: 500,
+ height: "auto",
+ closeOnSubmit: true,
+ tabs: [
+ { navSelector: ".tabs", contentSelector: "form", initial: "general" },
+ ],
+ });
+ }
+
+ getData(options) {
+ const existingSettings = settings.settings;
+ let data = mergeObject(
+ {
+ playerList: game.users.contents.reduce((acc, user) => {
+ acc[user.id] = user.name;
+ return acc;
+ }, {}),
+ },
+ this.reset ? { mappings: {} } : existingSettings
+ );
+ return data;
+ }
+
+ async _updateObject(event, formData) {
+ formData = this._parseInputs(formData);
+
+ const existingSettings = settings.settings;
+ let newSettings = mergeObject(existingSettings, formData);
+
+ await game.settings.set(VTT_MODULE_NAME, "settings", newSettings);
+
+ game.socket.emit("module.mindflayer-token-controller", {
+ type: "update",
+ user: game.user.id,
+ });
+ ui.notifications.info(game.i18n.localize("MindFlayer.saveMessage"));
+
+ TokenUtil.setDefaultTokens();
+ }
+
+ activateListeners(html) {
+ super.activateListeners(html);
+ html.find('button[name="reset"]').click(this._onReset.bind(this));
+ this.reset = false;
+ }
+
+ _onReset() {
+ this.reset = true;
+ this.render();
+ }
+
+ _parseInputs(data) {
+ var ret = {};
+ retloop: for (var input in data) {
+ var val = data[input];
+
+ var parts = input.split("[");
+ var last = ret;
+
+ for (var i in parts) {
+ var part = parts[i];
+ if (part.substr(-1) == "]") {
+ part = part.substr(0, part.length - 1);
+ }
+
+ if (i == parts.length - 1) {
+ last[part] = val;
+ continue retloop;
+ } else if (!last.hasOwnProperty(part)) {
+ last[part] = {};
+ }
+ last = last[part];
+ }
+ }
+ return ret;
+ }
+}
diff --git a/src/js/settings/constants.js b/src/js/settings/constants.js
new file mode 100644
index 0000000..33816b7
--- /dev/null
+++ b/src/js/settings/constants.js
@@ -0,0 +1,18 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+
+export const VTT_MODULE_NAME = "mindflayer-token-controller";
+export const LOG_PREFIX = "Mind Flayer | ";
diff --git a/src/js/settings/index.js b/src/js/settings/index.js
new file mode 100644
index 0000000..5f9778f
--- /dev/null
+++ b/src/js/settings/index.js
@@ -0,0 +1,318 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import CameraControl from "../modules/cameraControl";
+import { reload } from "../modules/loader";
+import Socket from "../modules/socket";
+import { getModuleInstance } from "../utils/module";
+import { LOG_PREFIX, VTT_MODULE_NAME } from "./constants";
+import { TokenControllerConfig } from "./TokenControllerConfig";
+
+const SETT_MODULE_ENABLED = "enabled";
+
+const SETT_WEBSOCKET_HOST = "websocketHost";
+const SETT_WEBSOCKET_PORT = "websocketPort";
+const SETT_WEBSOCKET_PATH = "websocketPath";
+
+const SETT_CAMERA_CONTROL = "cameraControl";
+
+const SETT_AMBILIGHT_ENABLE = "ambilightEnabled";
+const SETT_AMBILIGHT_TARGET = "ambilightTarget";
+const SETT_AMBILIGHT_UNIVERSE = "ambilightUniverse";
+const SETT_AMBILIGHT_FPS = "ambilightFPS";
+const SETT_AMBILIGHT_LED_COUNT = "ambilightLEDCount";
+const SETT_AMBILIGHT_LED_OFFSET = "ambilightOffset";
+const SETT_AMBILIGHT_BRIGHTNESS_MIN = "ambilightBrightnessMin";
+const SETT_AMBILIGHT_BRIGHTNESS_MAX = "ambilightBrightnessMax";
+
+const SETT_SETTINGS = "settings";
+
+export const settings = {
+ /**
+ * @returns {Boolean}
+ */
+ get enabled() {
+ return game.settings.get(VTT_MODULE_NAME, SETT_MODULE_ENABLED);
+ },
+
+ get settings() {
+ return game.settings.get(VTT_MODULE_NAME, SETT_SETTINGS);
+ },
+
+ websocket: {
+ get host() {
+ return game.settings.get(VTT_MODULE_NAME, SETT_WEBSOCKET_HOST);
+ },
+ get port() {
+ return game.settings.get(VTT_MODULE_NAME, SETT_WEBSOCKET_PORT);
+ },
+ get path() {
+ return game.settings.get(VTT_MODULE_NAME, SETT_WEBSOCKET_PATH);
+ },
+ get url() {
+ return "wss://" + this.host + ":" + this.port + this.path;
+ },
+ },
+
+ camera: {
+ get control() {
+ return game.settings.get(VTT_MODULE_NAME, SETT_CAMERA_CONTROL);
+ },
+ },
+
+ ambilight: {
+ /**
+ * @returns {Boolean}
+ */
+ get enabled() {
+ return game.settings.get(VTT_MODULE_NAME, SETT_AMBILIGHT_ENABLE);
+ },
+ get target() {
+ return game.settings.get(VTT_MODULE_NAME, SETT_AMBILIGHT_TARGET);
+ },
+ get universe() {
+ return game.settings.get(VTT_MODULE_NAME, SETT_AMBILIGHT_UNIVERSE);
+ },
+ /**
+ * @var {float} fps Number of refreshes of the ambilight per second
+ */
+ get fps() {
+ return game.settings.get(VTT_MODULE_NAME, SETT_AMBILIGHT_FPS);
+ },
+ led: {
+ get count() {
+ return game.settings.get(VTT_MODULE_NAME, SETT_AMBILIGHT_LED_COUNT);
+ },
+ get offset() {
+ return game.settings.get(VTT_MODULE_NAME, SETT_AMBILIGHT_LED_OFFSET);
+ },
+ },
+ brightness: {
+ get min() {
+ return game.settings.get(
+ VTT_MODULE_NAME,
+ SETT_AMBILIGHT_BRIGHTNESS_MIN
+ );
+ },
+ get max() {
+ return game.settings.get(
+ VTT_MODULE_NAME,
+ SETT_AMBILIGHT_BRIGHTNESS_MAX
+ );
+ },
+ },
+ },
+
+ init() {
+ game.settings.register(VTT_MODULE_NAME, SETT_MODULE_ENABLED, {
+ name: "MindFlayer.moduleEnabled",
+ hint: "MindFlayer.moduleEnabledHint",
+ scope: "client",
+ type: Boolean,
+ default: false,
+ config: true,
+ restricted: false,
+ onChange: () => {
+ location.reload();
+ },
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_WEBSOCKET_HOST, {
+ name: "MindFlayer.websocketHost",
+ hint: "MindFlayer.websocketHostHint",
+ scope: "client",
+ type: String,
+ default: "localhost",
+ config: true,
+ onChange: () => {
+ reload(getModuleInstance(), Socket.name);
+ },
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_WEBSOCKET_PORT, {
+ name: "MindFlayer.websocketPort",
+ hint: "MindFlayer.websocketPortHint",
+ scope: "client",
+ type: String,
+ default: "443",
+ config: true,
+ onChange: () => {
+ reload(getModuleInstance(), Socket.name);
+ },
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_WEBSOCKET_PATH, {
+ name: "MindFlayer.websocketPath",
+ hint: "MindFlayer.websocketPathHint",
+ scope: "client",
+ type: String,
+ default: "/ws/vtt",
+ config: true,
+ onChange: () => {
+ reload(getModuleInstance(), Socket.name);
+ },
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_CAMERA_CONTROL, {
+ name: "MindFlayer.cameraControl",
+ hint: "MindFlayer.cameraControlHint",
+ default: "default",
+ type: String,
+ isSelect: true,
+ choices: {
+ default: game.i18n.localize("MindFlayer.cameraControlDefault"),
+ focusPlayers: game.i18n.localize(
+ "MindFlayer.cameraControlFocusPlayers"
+ ),
+ off: game.i18n.localize("MindFlayer.cameraControlOff"),
+ },
+ config: true,
+ onChange: () => {
+ reload(getModuleInstance(), CameraControl.name);
+ },
+ });
+
+ game.settings.registerMenu(VTT_MODULE_NAME, VTT_MODULE_NAME, {
+ name: "MindFlayer.config",
+ label: "MindFlayer.configTitle",
+ hint: "MindFlayer.configHint",
+ icon: "fas fa-keyboard",
+ type: TokenControllerConfig,
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_AMBILIGHT_ENABLE, {
+ name: "MindFlayer.ambilightEnabled",
+ hint: "MindFlayer.ambilightEnabledHint",
+ scope: "client",
+ type: Boolean,
+ default: false,
+ config: true,
+ restricted: false,
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_AMBILIGHT_TARGET, {
+ name: "MindFlayer.ambilightTarget",
+ hint: "MindFlayer.ambilightTargetHint",
+ scope: "client",
+ type: String,
+ default: "",
+ config: true,
+ restricted: false,
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_AMBILIGHT_UNIVERSE, {
+ name: "MindFlayer.ambilightUniverse",
+ hint: "MindFlayer.ambilightUniverseHint",
+ scope: "client",
+ type: Number,
+ default: 0x01,
+ range: {
+ min: 1,
+ max: 255,
+ step: 1,
+ },
+ config: true,
+ restricted: false,
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_AMBILIGHT_FPS, {
+ name: "MindFlayer.ambilightFPS",
+ hint: "MindFlayer.ambilightFPSHint",
+ scope: "client",
+ type: Number,
+ default: 0x01,
+ range: {
+ min: 0.1,
+ max: 15,
+ step: 0.1,
+ },
+ config: true,
+ restricted: false,
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_AMBILIGHT_LED_COUNT, {
+ name: "MindFlayer.ambilightLEDCount",
+ hint: "MindFlayer.ambilightLEDCountHint",
+ scope: "client",
+ type: Number,
+ default: 0x01,
+ range: {
+ min: 1,
+ max: 170,
+ step: 1,
+ },
+ config: true,
+ restricted: false,
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_AMBILIGHT_LED_OFFSET, {
+ name: "MindFlayer.ambilightOffset",
+ hint: "MindFlayer.ambilightOffsetHint",
+ scope: "client",
+ type: Number,
+ default: 0,
+ range: {
+ min: -170,
+ max: 170,
+ step: 1,
+ },
+ config: true,
+ restricted: false,
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_AMBILIGHT_BRIGHTNESS_MIN, {
+ name: "MindFlayer.ambilightBrightnessMin",
+ hint: "MindFlayer.ambilightBrightnessMinHint",
+ scope: "client",
+ type: Number,
+ default: 0,
+ range: {
+ min: 0,
+ max: 255,
+ step: 1,
+ },
+ config: true,
+ restricted: false,
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_AMBILIGHT_BRIGHTNESS_MAX, {
+ name: "MindFlayer.ambilightBrightnessMax",
+ hint: "MindFlayer.ambilightBrightnessMaxHint",
+ scope: "client",
+ type: Number,
+ default: 255,
+ range: {
+ min: 0,
+ max: 255,
+ step: 1,
+ },
+ config: true,
+ restricted: false,
+ });
+
+ game.settings.register(VTT_MODULE_NAME, SETT_SETTINGS, {
+ name: "MindFlayer.config",
+ scope: "world",
+ type: Object,
+ config: false,
+ default: {
+ mappings: {},
+ },
+ });
+
+ console.log(LOG_PREFIX + "Loaded settings");
+ return this;
+ },
+};
diff --git a/src/js/utils/2d-geometry.js b/src/js/utils/2d-geometry.js
new file mode 100644
index 0000000..bac1b3b
--- /dev/null
+++ b/src/js/utils/2d-geometry.js
@@ -0,0 +1,116 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+
+export class Vector {
+ x = 0;
+ y = 0;
+
+ constructor(x, y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ length() {
+ return Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2));
+ }
+
+ normalize() {
+ const length = this.length();
+ this.x /= length;
+ this.y /= length;
+ return this;
+ }
+
+ scale(fact) {
+ this.x *= fact;
+ this.y *= fact;
+ return this;
+ }
+
+ rotate(rad) {
+ const cos = Math.cos(rad);
+ const sin = Math.sin(rad);
+ const x = cos * this.x - sin * this.y;
+ this.y = sin * this.x + cos * this.y;
+ this.x = x;
+ return this;
+ }
+
+ subtract(vector) {
+ return new Vector(this.x - vector.x, this.y - vector.y);
+ }
+
+ add(vector) {
+ return new Vector(this.x + vector.x, this.y + vector.y);
+ }
+}
+
+export class Rectangle {
+ p0 = null;
+ p1 = null;
+ center = null;
+
+ constructor(p0, p1) {
+ this.p0 = new Vector(Math.min(p0.x, p1.x), Math.min(p0.y, p1.y));
+ this.p1 = new Vector(Math.max(p0.x, p1.x), Math.max(p0.y, p1.y));
+ this.center = this.p1.subtract(this.p0).scale(0.5).add(this.p0);
+ }
+
+ static fromBounds(bounds) {
+ return new Rectangle(
+ new Vector(bounds.left, bounds.bottom),
+ new Vector(bounds.right, bounds.top)
+ );
+ }
+
+ intersectionFromCenter(direction) {
+ if (direction.y != 0) {
+ const interFact = Math.abs((this.p1.y - this.center.y - 1) / direction.y);
+ const interX = direction.x * interFact + this.center.x;
+ if (interX >= this.p0.x && interX <= this.p1.x) {
+ return interFact;
+ }
+ }
+ if (direction.x != 0) {
+ const interFact = Math.abs((this.p1.x - this.center.x - 1) / direction.x);
+ const interY = direction.y * interFact + this.center.y;
+ if (interY >= this.p0.y && interY <= this.p1.y) {
+ return interFact;
+ }
+ }
+ console.error("(0,0) vector?", direction);
+ return 1;
+ }
+
+ /**
+ * Check if this Rectangle intersects another Rectangle
+ *
+ * @param {Rectangle} rect2 the second Rectangle
+ * @returns true if the given Rectangle intersect with this one
+ */
+ intersect(rect2) {
+ return !(
+ rect2.p0.x > this.p1.x ||
+ rect2.p1.x < this.p0.x ||
+ rect2.p1.y < this.p0.y ||
+ rect2.p0.y > this.p1.y
+ );
+ }
+}
+
+export function deg2rad(degrees) {
+ return (degrees * Math.PI) / 180;
+}
diff --git a/src/js/utils/color.js b/src/js/utils/color.js
new file mode 100644
index 0000000..ddb5c31
--- /dev/null
+++ b/src/js/utils/color.js
@@ -0,0 +1,31 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+
+/**
+ * Convert a hex color string to json color object
+ * @param {string} hex the color as hex string in the format '#ffffff'
+ * @returns a javascript object representing the color
+ */
+export function hexToRgb(hex) {
+ var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+ return result !== null
+ ? {
+ r: parseInt(result[1], 16),
+ g: parseInt(result[2], 16),
+ b: parseInt(result[3], 16),
+ }
+ : null;
+}
diff --git a/src/js/utils/module.js b/src/js/utils/module.js
new file mode 100644
index 0000000..1e43847
--- /dev/null
+++ b/src/js/utils/module.js
@@ -0,0 +1,23 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { VTT_MODULE_NAME } from "../settings/constants";
+
+export function getModuleInstance() {
+ return game.modules.get(VTT_MODULE_NAME).instance;
+}
+export function setModuleInstance(inst) {
+ game.modules.get(VTT_MODULE_NAME).instance = inst;
+}
diff --git a/src/js/utils/tokenUtil.js b/src/js/utils/tokenUtil.js
new file mode 100644
index 0000000..90fd994
--- /dev/null
+++ b/src/js/utils/tokenUtil.js
@@ -0,0 +1,138 @@
+/**
+ * This file is part of the Foundry VTT Module Mindflayer.
+ *
+ * The Foundry VTT Module Mindflayer is free software: you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * The Foundry VTT Module Mindflayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+ * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along with the Foundry VTT Module Mindflayer. If not,
+ * see .
+ */
+"use strict";
+import { LOG_PREFIX, VTT_MODULE_NAME } from "../settings/constants";
+
+const SUB_LOG_PREFIX = LOG_PREFIX + "TokenUtil: ";
+
+/**
+ * Returns all controllable tokens of a player.
+ *
+ * @param {Player} player the player to search through
+ * @param {Boolean} ignoreEmpty if no exception should be thrown (necessary for initialization)
+ * @returns {Token[]} all controllable tokens of a player
+ * @throws an Error object if no tokens could be found and ignoreEmpty is false
+ */
+export function findAllTokensFor(player, ignoreEmpty = false) {
+ const tokens = canvas.tokens.placeables
+ .filter(
+ (token) => token.actor && token.actor.data.permission[player.id] >= 3
+ )
+ .sort((a, b) => a.id.localeCompare(b.id));
+ if (!ignoreEmpty && tokens.length <= 0) {
+ console.warn(
+ SUB_LOG_PREFIX + `Player '${player.name}' does not have any Tokens: `
+ );
+ throw new Error("Could not find any tokens for player: " + player.name);
+ }
+ return tokens;
+}
+
+/**
+ * Returns the currently selected token of the given player.
+ *
+ * @param {Player} player the player to search through
+ * @param {boolean} ignoreNone if false an error will be thrown if no tokens are found
+ * @throws {Error} if no selected token could be found and ignoreNone is false
+ */
+export function getTokenFor(player, ignoreNone = false) {
+ const selectedToken = game.user.getFlag(
+ VTT_MODULE_NAME,
+ "selectedToken_" + player.id
+ );
+ let token = canvas.tokens.placeables.find(
+ (token) => token.id == selectedToken
+ );
+ if (!token) {
+ const tokens = findAllTokensFor(player, true);
+ if (tokens.length <= 0) {
+ if (!ignoreNone) {
+ throw new Error(
+ "Could not find token any tokens on current map for player " +
+ player.name
+ );
+ }
+ } else {
+ token = tokens[0];
+ }
+ }
+ return token;
+}
+
+/**
+ * Sets the users default characters as preselected tokens.
+ */
+export function setDefaultTokens() {
+ game.users.contents.forEach(setDefaultToken);
+}
+
+export function setDefaultToken(user) {
+ let selectedToken = null;
+ const allTokens = findAllTokensFor(user, true);
+ if (user.character) {
+ selectedToken = allTokens.find(
+ (token) => token.actor.id == user.character.id
+ );
+ if (selectedToken) {
+ selectedToken = selectedToken.id;
+ }
+ } else if (allTokens.length > 0) {
+ selectedToken = allTokens[0].id;
+ }
+ game.user.setFlag(VTT_MODULE_NAME, "selectedToken_" + user.id, selectedToken);
+ console.debug(
+ LOG_PREFIX +
+ `Selected default token '${selectedToken.name}' for player '${player.name}'`
+ );
+}
+
+/**
+ * Get the User belonging to the token, if the token is currently selected
+ *
+ * @param {Token} token the token to check
+ * @returns {Player|null} the player who is currently controlling the token or null if noone is controlling it
+ */
+export function getUserIfSelectedTokenIs(token) {
+ let result = null;
+ game.users.contents.forEach((player) => {
+ if (
+ game.user.getFlag(VTT_MODULE_NAME, "selectedToken_" + player.id) ==
+ token.id
+ ) {
+ result = player;
+ }
+ });
+ return result;
+}
+
+/**
+ * Returns all tokens that are in combat
+ *
+ * @returns {TokenDocument[]} the tokens in combat or empty array if no combat
+ */
+export function getAllCombatTokens() {
+ if (game.combat == null) {
+ return [];
+ }
+ return game.combat.turns.map((combatant) => combatant.token.object);
+}
+
+function _refreshTokens() {
+ console.debug(SUB_LOG_PREFIX + "refreshing tokens");
+ canvas.tokens.placeables.forEach((t) => t.refresh({}));
+ canvas.triggerPendingOperations();
+}
+
+export const refreshTokenPlaceables = debounce(_refreshTokens, 100);
diff --git a/src/lang/en.json b/src/lang/en.json
new file mode 100644
index 0000000..599022c
--- /dev/null
+++ b/src/lang/en.json
@@ -0,0 +1,48 @@
+{
+ "MindFlayer.config": "Controller Assignments",
+ "MindFlayer.configTitle": "Controller Assignments",
+ "MindFlayer.configHint": "Controller to user assignments",
+
+ "MindFlayer.ambilightEnabled": "Enable Ambilight",
+ "MindFlayer.ambilightEnabledHint": "Enables the ambilight to be controlled from this browser",
+ "MindFlayer.ambilightTarget": "E131 Target",
+ "MindFlayer.ambilightTargetHint": "Can be an IP address or a E131 Universe",
+ "MindFlayer.ambilightUniverse": "E131 Universe",
+ "MindFlayer.ambilightUniverseHint": "The Universe to which the LEDs belong",
+ "MindFlayer.ambilightLEDCount": "E131 RGB LED count",
+ "MindFlayer.ambilightLEDCountHint": "Must be a number between 1 and 170 inclusive",
+ "MindFlayer.ambilightOffset": "Starting LED offset",
+ "MindFlayer.ambilightOffsetHint": "How many times should the array be rotated by one led. Positive numbers shift upwards",
+ "MindFlayer.ambilightBrightnessMin": "Minimum LED Brightness",
+ "MindFlayer.ambilightBrightnessMinHint": "Each Color of each LED will be at least this value",
+ "MindFlayer.ambilightBrightnessMax": "Maximum LED Brightness",
+ "MindFlayer.ambilightBrightnessMaxHint": "Each Color of each LED will be capped to this value",
+
+ "MindFlayer.websocketHost": "Websocket Host",
+ "MindFlayer.websocketHostHint": "A websocket server that the module will connect to",
+ "MindFlayer.websocketPort": "Websocket Port",
+ "MindFlayer.websocketPortHint": "The port of the websocket that the module will connect to",
+ "MindFlayer.websocketPath": "Websocket Path",
+ "MindFlayer.websocketPathHint": "The path of the websocket that the module will connect to",
+
+ "MindFlayer.cameraControl": "Camera Behavior",
+ "MindFlayer.cameraControlHint": "This changes the camera behavior when tokens move",
+ "MindFlayer.cameraControlDefault": "VTT Default (focus controlled token)",
+ "MindFlayer.cameraControlFocusPlayers": "Automatic (focus all active player tokens on scene)",
+ "MindFlayer.cameraControlOff": "GM Mode (manual camera control)",
+
+ "MindFlayer.moduleEnabled": "Enabled",
+ "MindFlayer.moduleEnabledHint": "Enables the module for this browser",
+
+ "MindFlayer.Save": "Save",
+ "MindFlayer.Reset": "Reset",
+
+ "MindFlayer.saveMessage": "Updated Mind Flayer Controller Assignments",
+
+ "MindFlayer.Notifications.Connected": "Connected to websocket on \"{host}:{port}\"",
+ "MindFlayer.Notifications.Error": "An error ocurred, look at the log for more information",
+ "MindFlayer.Notifications.ConnectionClosed": "Connected to websocket closed, attempting to reconnect in 5 seconds...",
+ "MindFlayer.Notifications.NewClient": "Controller \"{controller}\" assigned to player \"{player}\" connected!",
+ "MindFlayer.Notifications.ClientDisconnected": "Controller \"{controller}\" assigned to player \"{player}\" disconnected!",
+ "MindFlayer.Notifications.ChangeDirection": "Player \"{player}\" changed orientation by {orientation}°"
+}
diff --git a/style.css b/src/style.css
similarity index 99%
rename from style.css
rename to src/style.css
index 7efbbe3..2112937 100644
--- a/style.css
+++ b/src/style.css
@@ -34,4 +34,4 @@
.hide-ui .illandril-npc-quick-actions--outer-container {
display: none;
-}
\ No newline at end of file
+}
diff --git a/src/templates/keyboard-config.html b/src/templates/keyboard-config.html
new file mode 100644
index 0000000..341815f
--- /dev/null
+++ b/src/templates/keyboard-config.html
@@ -0,0 +1,50 @@
+
+
diff --git a/templates/keyboard-config.html b/templates/keyboard-config.html
deleted file mode 100644
index 4e7cf4a..0000000
--- a/templates/keyboard-config.html
+++ /dev/null
@@ -1,29 +0,0 @@
-
diff --git a/webpack.config.js b/webpack.config.js
new file mode 100644
index 0000000..0baf22d
--- /dev/null
+++ b/webpack.config.js
@@ -0,0 +1,73 @@
+"use strict";
+const path = require("path");
+const packages = require("./package.json");
+const fs = require("fs");
+const CopyPlugin = require("copy-webpack-plugin");
+
+class ModuleJsonWebpackPlugin {
+ static defaultOptions = {
+ srcFile: "src/js/module.tmpl.json",
+ outputFile: "module.json",
+ };
+ constructor(options = {}) {
+ this.options = { ...ModuleJsonWebpackPlugin.defaultOptions, ...options };
+ }
+ apply(compiler) {
+ const pluginName = ModuleJsonWebpackPlugin.name;
+ const { webpack } = compiler;
+ const { Compilation } = webpack;
+ const { RawSource } = webpack.sources;
+ compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
+ compilation.hooks.processAssets.tap(
+ {
+ name: pluginName,
+ stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE,
+ },
+ (assets) => {
+ const content = JSON.parse(fs.readFileSync(this.options.srcFile));
+ content.version = packages.version;
+
+ // Adding new asset to the compilation, so it would be automatically
+ // generated by the webpack in the output directory.
+ compilation.emitAsset(
+ this.options.outputFile,
+ new RawSource(JSON.stringify(content))
+ );
+ }
+ );
+ });
+ }
+}
+
+let devDomain = "localhost";
+if (fs.existsSync(".devDomain")) {
+ devDomain = fs.readFileSync(".devDomain");
+}
+
+module.exports = {
+ mode: process.env.NODE_ENV == "production" ? "production" : "development",
+ entry: "./src/js/index.js",
+ output: {
+ filename: "MindFlayer.js",
+ path: path.resolve(
+ __dirname,
+ process.env.NODE_ENV == "production"
+ ? "dist"
+ : "chrome-overrides/" +
+ devDomain +
+ "/modules/mindflayer-token-controller"
+ ),
+ },
+ plugins: [
+ new CopyPlugin({
+ patterns: [
+ { from: "src/lang", to: "lang" },
+ { from: "src/templates", to: "templates" },
+ { from: "LICENSE", to: "LICENSE" },
+ { from: "src/style.css", to: "style.css" },
+ ],
+ }),
+ new ModuleJsonWebpackPlugin(),
+ ],
+ devtool: "source-map",
+};
![](\"https://raw.githubusercontent.com/mindflayer-vtt/foundryvtt-mindflayer/main/.github/foundryvtt-mindflayer-logo.png\"){kind=logo}