Release v1.3.0

This partially reverts commit 42529d3df6.

CHANGELOG.md

@@ -1,3 +1,79 @@
+## 1.3.0
+### New features
+- The keybinding for the Toggle Secret Door feature can now be reconfigured via Foundries keybinding configuration (the default key has changed to AltLeft)
+
+### Compatibility
+- Smart Doors is now compatible with Foundry 9
+
+### Translation
+- Added french translation (thanks to Elfenduli)
+
+
+## 1.2.9
+### Feature revival
+- The "Tint secret doors" feature is back, but will remain disabled by default.
+
+## 1.2.8
+### Compatibility
+- Smart Doors is now compatible with Foundry 0.8.8
+- Due to API changes inside Foundry, Smart Doors is no longer compatible with Foundry versions older than 0.8.7
+
+## 1.2.7
+### Compatibility
+- Smart Doors is now compatible with Foundry 0.8.5
+
+### Feature removals
+- The door icons now have outlines by defualt in Foundry. As a result the "Door Icon Outline" feature was removed.
+- Secret doors now have a different icon from regular doors in Foundry, making the "Tint Secret Doors" feature redundant. As a result it was removed.
+
+## 1.2.6
+### Compatibility
+- Smart Doors now uses the libwrapper module and as a result is now compatible with the module "FoundryVTT Arms Reach"
+
+## 1.2.5
+### New features
+- Synchronized doors can now be configured to synchronize their secret door status as well
+
+## v1.2.4
+### Bugfix
+- Fixed a race condition that may cause doors to not be properly synchronized across scenes
+
+## v1.2.3
+### Other
+- Smart Doors is now compatible with Arms Reach
+
+## v1.2.2
+### Bugfix
+- Disabled features are now less likely to interfere with other modules, increasing compatibility.
+  - This module can now be used together with the `Arms Reach` module if the `Toggle Secret Doors` feature is disabled in the settings.
+
+### Other
+- Warn the user about incompatibility if they use this module together with `Arms Reach` and have incompatible features enabled.
+
+## v1.2.1
+### Other
+- Verified compatibility with 0.7.9
+
+## v1.2.0
+### New features
+- Draw outlines around Door Control icons to increase their visibility
+
+### Other
+- Secret doors are now tinted black instead of dark grey.
+
+
+## v1.1.0
+### New features
+- Tint secret doors grey for the GM to differentiate them from regular doors
+- Toggle doors between secret and normal with ctrl+click
+- Makes the size of door controls independent of the scene's grid size
+
+### Bugfixes
+- In cloned scenes Locked Door Alerts will now only highlight the door in the correct scene
+- When adding a door to a synchronization group it will now assume the correct state if it's being synchronized with it's twin door on a cloned map
+- Fixed a bug that allowed synchonized doors to be opened dispite them being locked
+- Fixed a bug where secret doors that were synchronized with doors on other scenes wouldn't be tinted corretly after interacting with them
+
 ## v1.0.1
 - When adding a door to a synchronization group adjust it's state to bring it in sync with the other doors
 - Use the players character as speaker for the Locked Door Alert

README.md

@@ -1,17 +1,34 @@
+[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/staebchenfisch)
+
 # Smart Doors
 Makes doors smarter. Allows doors to synchronize across multiple scenes and sends chat messages when players try to open locked doors (and also tells you which of the doors).
 
 ## Feature overview
 
-### Locked door alerts
+### Consistent Door Control Size
-![Locked door alerts demonstration](https://raw.githubusercontent.com/manuelVo/foundryvtt-smart-doors/360d724240634dbc6cc493a3b62243a8b28b7056/media/locked_door_alert.webp)
+![Consistent Door Control Size demonstration](https://raw.githubusercontent.com/manuelVo/foundryvtt-smart-doors/e5b5c336d64f2b379914648f57aa07b6a69aadf1/media/door_control_size.webp)
+
+Door Control icons will be rendered the same size in every scene, regardless of the configured grid size. The size of the icons is configurable.
+
+### Toggle Secret Doors
+![Toggle Secret Doors demonstration](https://raw.githubusercontent.com/manuelVo/foundryvtt-smart-doors/da5872042ea81e2f41875a193d161331a81a2b6d/media/secret_door_toggle.webp)
+
+Easily reveal secret doors to players. Alt+left click secrets doors to turn them into regular doors. Alt+left click can also be done on normal doors to turn them into secret doors. The keybinding for this feature can be reconfigured.
+
+
+### Locked Door Alerts
+![Locked Door Alerts demonstration](https://raw.githubusercontent.com/manuelVo/foundryvtt-smart-doors/360d724240634dbc6cc493a3b62243a8b28b7056/media/locked_door_alert.webp)
 
 Keep everyone informed who tried to open which door. Whenever a player tries to open a door that is locked, a chat message stating that fact will be sent to all players. Additionally the door locked sound will be played for everyone. When the chat message is hovered with the mouse, the door that the player tried to open will be highlighted.
 
 If the GM tries to open a locked door the sound will only played for him and no chat message will be sent.
 
-### Synchronized doors
+### Tint Secret Doors
-![Synchronized doors demonstration](https://raw.githubusercontent.com/manuelVo/foundryvtt-smart-doors/360d724240634dbc6cc493a3b62243a8b28b7056/media/synchronized_doors.webp)
+This tints secret doors in a gay shade to make them easier to discern from regular doors when being zoomed further out.
+
+
+### Synchronized Doors
+![Synchronized Doors demonstration](https://raw.githubusercontent.com/manuelVo/foundryvtt-smart-doors/360d724240634dbc6cc493a3b62243a8b28b7056/media/synchronized_doors.webp)
 
 Keep multiple doors in sync - even across different scenes. Example use cases:
 - A tavern has an outdoor and an indoor scene. If a player opens the entrance door on the outdoor map, the entrance door in the indoor map will be opened as well
@@ -22,7 +39,7 @@ To set up door synchronization, assign all doors that should be synchronized to
 
 Once a Synchronization Group is set up for multiple doors, simply open/close/lock/unlock one of the doors to achieve the same effect on other doors as well.
 
-## Planned features
+## Features ideas
 - Attach macros to doors that are being executed when the door is being opened/closed
 - Give out keys to players, that allow them to lock/unlock associated doors
 - Doors that can only be seen from one side when closed

lang/en.json

@@ -1,6 +1,20 @@
 {
     "smart-doors": {
+		"keybindings": {
+			"toggleSecretDoor": {
+				"name": "Toggle Secret Door",
+				"hint": "While this key is being pressed, clicking on doors will cause the to toggle between normal and secret door"
+			}
+		},
 		"settings": {
+			"doorControlSizeFactor": {
+				"name": "Door Control Size Factor",
+				"hint": "Defines by which factor the size of the door control icons should be scaled up"
+			},
+			"highlightSecretDoors": {
+				"name": "Tint Secret Doors",
+				"hint": "Shade secret doors in a different color on the gm screen to differentiate them from normal doors"
+			},
 			"lockedDoorAlert": {
 				"name": "Locked Door Alert",
 				"hint": "Send a message in chat when a player tried to open a locked door"
@@ -12,11 +26,14 @@
 		},
 		"ui": {
 			"messages": {
-				"unknownVersion": "Smart Doors migration failed with the error: Unkown Version. Please report this to the Smart Doors issue tracker. To prevent possible data loss don't use this plugin until this error is fixed."
+				"migrating": "Migrating Smart Doors to version {version}. Please don't close the application.",
+				"migrationDone": "Smart Doors successfully migrated to version {version}.",
+				"unknownVersion": "Smart Doors migration failed with the error: Unkown Version {version}. Please report this to the Smart Doors issue tracker. To prevent possible data loss don't use this plugin until this error is fixed."
 			},
 			"synchronizedDoors": {
 				"description": "State changes of doors in the same synchronization group will be synchronized across scenes. Leave blank to disable synchronization for this door.",
-				"groupName": "Synchronization Group"
+				"groupName": "Synchronization Group",
+				"synchronizeSecretStatus": "Synchronize Secret Status"
 			}
 		}
 	}

lang/fr.json

@@ -0,0 +1,35 @@
+{
+	"smart-doors": {
+		"settings": {
+			"doorControlSizeFactor": {
+				"name": "Facteur de taille de commande de porte",
+				"hint": "Définit par quel facteur la taille des icônes de contrôle de porte doit être agrandie"
+			},
+			"highlightSecretDoors": {
+				"name": "Teinte des portes secrètes",
+				"indice": "Ombragez les portes secrètes d'une couleur différente sur l'écran gm pour les différencier des portes normales"
+			},
+			"lockedDoorAlert": {
+				"name": "Alerte de porte verrouillée",
+				"hint": "Envoyer un message dans le chat lorsqu'un joueur essaie d'ouvrir une porte verrouillée"
+			},
+			"synchronizedDoors": {
+				"name": "Portes synchronisées",
+				"hint": "Synchroniser l'état des portes configurées"
+			}
+		}
+	},
+	"ui": {
+		"messages": {
+			"migrating": "Migration de Smart Doors vers la version {version}. Veuillez ne pas fermer l'application.",
+			"migrationDone": "Smart Doors a migré avec succès vers la version {version}.",
+			"unknownVersion": "La migration de Smart Doors a échoué avec l'erreur : Version inconnue {version}. Veuillez le signaler à l'outil de suivi des problèmes Smart Doors. Pour éviter une éventuelle perte de données, n'utilisez pas ce plug-in tant que cette erreur n'est pas corrigée."
+		},
+		"synchronizedDoors": {
+			"description": "Les changements d'état des portes dans le même groupe de synchronisation seront synchronisés entre les scènes. Laissez vide pour désactiver la synchronisation pour cette porte.",
+			"groupName": "Groupe de synchronisation",
+			"synchronizeSecretStatus": "Synchroniser le statut Secret"
+		}
+	}
+}
+}

lib/libwrapper_shim.js

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+// Copyright © 2021 fvtt-lib-wrapper Rui Pinheiro
+
+'use strict';
+
+// A shim for the libWrapper library
+export let libWrapper = undefined;
+
+Hooks.once('init', () => {
+	// Check if the real module is already loaded - if so, use it
+	if(globalThis.libWrapper && !(globalThis.libWrapper.is_fallback ?? true)) {
+		libWrapper = globalThis.libWrapper;
+		return;
+	}
+
+	// Fallback implementation
+	libWrapper = class {
+		static get is_fallback() { return true };
+
+		static register(module, target, fn, type="MIXED", {chain=undefined}={}) {
+			const is_setter = target.endsWith('#set');
+			target = !is_setter ? target : target.slice(0, -4);
+			const split = target.split('.');
+			const fn_name = split.pop();
+			const root_nm = split.splice(0,1)[0];
+			const _eval = eval; // The browser doesn't expose all global variables (e.g. 'Game') inside globalThis, but it does to an eval. We copy it to a variable to have it run in global scope.
+			const obj = split.reduce((x,y)=>x[y], globalThis[root_nm] ?? _eval(root_nm));
+
+			let iObj = obj;
+			let descriptor = null;
+			while(iObj) {
+				descriptor = Object.getOwnPropertyDescriptor(iObj, fn_name);
+				if(descriptor) break;
+				iObj = Object.getPrototypeOf(iObj);
+			}
+			if(!descriptor || descriptor?.configurable === false) throw `libWrapper Shim: '${target}' does not exist, could not be found, or has a non-configurable descriptor.`;
+
+			let original = null;
+			const wrapper = (chain ?? type != 'OVERRIDE') ? function() { return fn.call(this, original.bind(this), ...arguments); } : function() { return fn.apply(this, arguments); };
+
+			if(!is_setter) {
+				if(descriptor.value) {
+					original = descriptor.value;
+					descriptor.value = wrapper;
+				}
+				else {
+					original = descriptor.get;
+					descriptor.get = wrapper;
+				}
+			}
+			else {
+				if(!descriptor.set) throw `libWrapper Shim: '${target}' does not have a setter`;
+				original = descriptor.set;
+				descriptor.set = wrapper;
+			}
+
+			descriptor.configurable = true;
+			Object.defineProperty(obj, fn_name, descriptor);
+		}
+	}
+});

main.js

@@ -1,298 +0,0 @@
-"use strict";
-
-const settingsKey = "smart-doors";
-const currentDataVersion = "1.0.0"
-
-Hooks.once("init", () => {
-	registerSettings()
-	hookDoorEvents()
-	hookWallConfigUpdate()
-})
-
-Hooks.once("ready", () => {
-	performMigrations()
-})
-
-// Tint the source door red when a locked alert is hovered
-Hooks.on("renderChatMessage", (message, html, data) => {
-	// Tint the door that generated this message
-	const sourceId = message.data.flags.smartdoors?.sourceId
-	if (!sourceId)
-		return
-
-	// Tint on mouse enter
-	const mouseEnter = function () {
-		const sourceDoor = canvas.controls.doors.children.find(door => door.wall.data._id == sourceId);
-		if (sourceDoor)
-			sourceDoor.icon.tint = 0xff0000;
-	}
-	html.on("mouseenter", mouseEnter);
-
-	// Remove tint on mouse leave
-	const mouseLeave = function () {
-		const sourceDoor = canvas.controls.doors.children.find(door => door.wall.data._id == sourceId);
-		if (sourceDoor)
-			sourceDoor.icon.tint = 0xffffff;
-	}
-	html.on("mouseleave", mouseLeave);
-})
-
-// Inject our custom settings into the WallConfig dialog
-Hooks.on("renderWallConfig", (wallConfig, html, data) => {
-	// Settings for synchronized doors
-	if (data.isDoor && game.settings.get(settingsKey, "synchronizedDoors")) {
-		// Inject settings
-		const synchronizedSettings = `
-			<p class="notes">${game.i18n.localize("smart-doors.ui.synchronizedDoors.description")}</p>
-			<div class="form-group">
-				<label for="synchronizationGroup">${game.i18n.localize("smart-doors.ui.synchronizedDoors.groupName")}</label>
-				<input type="text" name="synchronizationGroup"/>
-			</div>
-		`
-		html.find(".form-group").last().after(synchronizedSettings)
-
-		const smartdoorsData = data.object.flags.smartdoors
-		// Fill the injected input fields with values
-		const input = (name) => html.find(`input[name="${name}"]`)
-		input("synchronizationGroup").prop("value", smartdoorsData?.synchronizationGroup)
-
-		// Recalculate config window height
-		wallConfig.setPosition({height: "auto"})
-	}
-})
-
-// Hook the update function of the WallConfig dialog so we can store our custom data
-function hookWallConfigUpdate() {
-	// Replace the original function with our custom one
-	const originalHandler = WallConfig.prototype._updateObject;
-	WallConfig.prototype._updateObject = async function (event, formData) {
-		await originalHandler.call(this, event, formData)
-		return onWallConfigUpdate.call(this, event, formData)
-	}
-}
-
-// Store our custom data from the WallConfig dialog
-async function onWallConfigUpdate(event, formData) {
-	const updateData = {flags: {smartdoors: {synchronizationGroup: formData.synchronizationGroup}}}
-	let ids = this.options.editTargets;
-	if (ids.length == 0) {
-		ids = [this.object.data._id];
-	}
-
-	// If a synchronization group is set, get the state of existing doors and assume their state
-	if (formData.synchronizationGroup) {
-		const doorInGroup = findInAllWalls(wall => wall.door && wall.flags.smartdoors?.synchronizationGroup == formData.synchronizationGroup && !ids.includes(wall._id));
-		if (doorInGroup)
-			updateData.ds = doorInGroup.ds;
-	}
-
-	// Update all the edited walls
-	const updateDataset = ids.reduce((dataset, id) => {
-		dataset.push({_id: id, ...updateData})
-		return dataset
-	}, [])
-	return canvas.scene.updateEmbeddedEntity("Wall", updateDataset)
-}
-
-// Hook mouse events on DoorControls to perform our logic.
-// If we successfully handled the event block the original handler. Forward the event otherwise.
-function hookDoorEvents() {
-	// Replace the original mousedown handler with our custom one
-	const originalMouseDownHandler = DoorControl.prototype._onMouseDown
-	DoorControl.prototype._onMouseDown = function (event) {
-		// Call our handler first. Only allow the original handler to run if our handler returns true
-		const eventHandled = onDoorMouseDown.call(this, event)
-		if (eventHandled)
-			return
-		return originalMouseDownHandler.call(this, event)
-	}
-
-	// Replace the original rightdown handler with our custom one
-	const originalRightDownHandler = DoorControl.prototype._onRightDown
-	DoorControl.prototype._onRightDown = function (event) {
-		// Call our handler first. Only allow the original handler to run if our handler returns true
-		const eventHandled = onDoorRightDown.call(this, event)
-		if (eventHandled)
-			return
-		return originalRightDownHandler.call(this, event)
-	}
-}
-
-// Searches through all scenes for walls and returns those that match the given filter criteria.
-function filterAllWalls(filterFn) {
-	// Find all walls that match the filter criteria
-	const scenes = game.scenes.map((scene) => {return {scene: scene, walls: scene.data.walls.filter(filterFn)}})
-	// Drop all scenes that don't contain any results
-	return scenes.filter(scene => scene.walls.length > 0)
-}
-
-// Searches through all scenes for a wall that matches the given filter criteria
-function findInAllWalls(filterFn) {
-	// TODO The performance of this could be increased by stopping the search on the first hit
-	const scenes = filterAllWalls(filterFn)
-	// If results were found take the first wall from the first scene.
-	return scenes[0]?.walls[0]
-}
-
-// Our custom handler for mousedown events on doors
-function onDoorMouseDown(event) {
-	// If the user doesn't have the "door" permission we don't do anything.
-	if (!game.user.can("WALL_DOORS"))
-		return false
-	// If the game is paused don't do anything if the current player isn't the gm
-	if ( game.paused && !game.user.isGM )
-		return false
-
-	if (lockedDoorAlertLeftClick.call(this))
-		return true
-
-	if (synchronizedDoorsLeftClick.call(this))
-		return true
-
-	return false
-}
-
-// Our custom handler for rightdown events on doors
-function onDoorRightDown(event) {
-	if (synchronizedDoorsRightClick.call(this))
-		return true
-
-	return false
-}
-
-// Creates a chat message stating that a player tried to open a locked door
-function lockedDoorAlertLeftClick() {
-	const state = this.wall.data.ds
-	const states = CONST.WALL_DOOR_STATES
-
-	// Check if this feature is enabled
-	if (!game.settings.get(settingsKey, "lockedDoorAlert"))
-		return false
-
-	// Only create messages when the door is locked.
-	if (state != states.LOCKED)
-		return false
-
-	// Generate no message if the gm attempts to open the door
-	if (game.user.isGM)
-		return false
-
-	// Create and send the chat message
-	const message = {}
-	message.user = game.user
-	if (game.user.character)
-		message.speaker = {actor: game.user.character}
-	message.content = "Just tried to open a locked door"
-	message.sound = CONFIG.sounds.lock
-	message.flags = {smartdoors: {sourceId: this.wall.data._id}}
-	ChatMessage.create(message)
-	return true
-}
-
-// Updates all doors in the specified synchronization group with the provided data
-function updateSynchronizedDoors(updateData, synchronizationGroup) {
-	// Search for doors belonging to the synchronization group in all scenes
-	let scenes = filterAllWalls(wall => wall.door && wall.flags.smartdoors?.synchronizationGroup == synchronizationGroup);
-
-	// Update all doors in the synchronization group
-	scenes.forEach((scene) => {
-		scene.scene.updateEmbeddedEntity("Wall", scene.walls.map((wall) => {return {_id: wall._id, ...updateData}}))
-	})
-}
-
-// Update the state of all synchronized doors
-function synchronizedDoorsLeftClick() {
-	const state = this.wall.data.ds
-	const states = CONST.WALL_DOOR_STATES
-
-	// Check if this feature is enabled
-	if (!game.settings.get(settingsKey, "synchronizedDoors"))
-		return false
-
-	const synchronizationGroup = this.wall.data.flags.smartdoors?.synchronizationGroup
-
-	// Does this door have a synchronization group? If not there is nothing to do
-	if (!synchronizationGroup)
-		return false
-
-	// If the door is locked there is nothing to synchronize
-	if (this.state === states.LOCKED)
-		return false
-
-	// Calculate new door state
-	const newstate = state === states.CLOSED ? states.OPEN : states.CLOSED
-
-	// Update all doors belonging to the synchronization group
-	const updateData = {ds: newstate}
-	updateSynchronizedDoors(updateData, synchronizationGroup)
-
-	return true
-}
-
-function synchronizedDoorsRightClick() {
-	const state = this.wall.data.ds
-	const states = CONST.WALL_DOOR_STATES
-
-	// Check if this feature is enabled
-	if (!game.settings.get(settingsKey, "synchronizedDoors"))
-		return false
-
-	const synchronizationGroup = this.wall.data.flags.smartdoors?.synchronizationGroup
-
-	// Does this door have a synchronization group? If not there is nothing to do
-	if (!synchronizationGroup)
-		return false
-
-	// Only the gm is allowed to lock/unlock doors
-	if ( !game.user.isGM )
-		return false;
-
-	// If the door is currently opened we cannot lock the door
-	if ( state === states.OPEN )
-		return false;
-
-	// Calculate new door state
-	const newstate = state === states.LOCKED ? states.CLOSED : states.LOCKED;
-
-	// Update all doors belonging to the synchronization group
-	const updateData = {ds: newstate}
-	updateSynchronizedDoors(updateData, synchronizationGroup)
-
-	return true
-}
-
-function performMigrations() {
-	const dataVersion = game.settings.get(settingsKey, "dataVersion")
-	if (dataVersion === "fresh install")
-	{
-		game.settings.set(settingsKey, "dataVersion", currentDataVersion);
-		return;
-	}
-	if (dataVersion != currentDataVersion)
-		ui.notifications.error(game.i18n.localize("smart-doors.ui.messages.unknownVersion"), {permanent: true})
-}
-
-function registerSettings() {
-	game.settings.register(settingsKey, "dataVersion", {
-		scope: "world",
-		config: false,
-		type: String,
-		default: "fresh install"
-	})
-	game.settings.register(settingsKey, "lockedDoorAlert", {
-		name: "smart-doors.settings.lockedDoorAlert.name",
-		hint: "smart-doors.settings.lockedDoorAlert.hint",
-		scope: "world",
-		config: true,
-		type: Boolean,
-		default: true,
-	})
-	game.settings.register(settingsKey, "synchronizedDoors", {
-		name: "smart-doors.settings.synchronizedDoors.name",
-		hint: "smart-doors.settings.synchronizedDoors.hint",
-		scope: "world",
-		config: true,
-		type: Boolean,
-		default: true,
-	})
-}

module.json

@@ -2,24 +2,37 @@
 	"name": "smart-doors",
 	"title": "Smart Doors",
 	"description": "Makes doors smarter. Allows doors to synchronize across multiple scenes and sends chat messages when players try to open locked doors.",
-	"version": "1.0.1",
+	"version": "1.3.0",
-	"minimumCoreVersion" : "0.7.7",
+	"minimumCoreVersion" : "9.238",
-	"compatibleCoreVersion" : "0.7.8",
+	"compatibleCoreVersion" : "9",
-	"author": "Manuel Vögele",
+	"authors": [
+		{
+			"name": "Manuel Vögele",
+			"email": "develop@manuel-voegele.de",
+			"discord": "Stäbchenfisch#5107"
+		}
+	],
 	"esmodules": [
-		"./main.js"
+		"lib/libwrapper_shim.js",
+		"src/main.js"
 	],
 	"languages": [
 		{
 			"lang": "en",
 			"name": "English",
 			"path": "lang/en.json"
+		},
+		{
+			"lang": "fr",
+			"name": "Français",
+			"path": "lang/fr.json"
 		}
 	],
 	"url": "https://github.com/manuelVo/foundryvtt-smart-doors",
 	"manifest": "https://raw.githubusercontent.com/manuelVo/foundryvtt-smart-doors/master/module.json",
-	"download": "https://github.com/manuelVo/foundryvtt-smart-doors/archive/v1.0.1.zip",
+	"download": "https://github.com/manuelVo/foundryvtt-smart-doors/archive/v1.3.0.zip",
 	"readme": "https://github.com/manuelVo/foundryvtt-smart-doors/blob/master/README.md",
 	"changelog": "https://github.com/manuelVo/foundryvtt-smart-doors/blob/master/CHANGELOG.md",
-	"bugs": "https://github.com/manuelVo/foundryvtt-smart-doors/issues"
+	"bugs": "https://github.com/manuelVo/foundryvtt-smart-doors/issues",
+	"allowBugReporter": true
 }

src/features/door_control_icon_scale.js

@@ -0,0 +1,37 @@
+import { libWrapper } from "../../lib/libwrapper_shim.js"
+import {settingsKey} from "../settings.js"
+
+// Adjust the repositioning formula for the door controls
+export function hookDoorControlReposition() {
+	libWrapper.register("smart-doors", "DoorControl.prototype.reposition", function () {
+		let gridSize = this.wall.scene.data.grid
+		gridSize *= game.settings.get(settingsKey, "doorControlSizeFactor")
+		const pos = this.wall.midpoint.map(p => p - gridSize * 0.2)
+		this.position.set(...pos)
+	}, "OVERRIDE");
+}
+
+// Set the size of all door controls in relation to the grid size so it'll have a constant percieved size
+export function onCanvasReady(currentCanvas) {
+	const doors = currentCanvas.controls.doors.children
+	doors.forEach(control => fixDoorControlSize(control))
+}
+
+// Set the size of the door control in relation to the grid size so it'll have a constant percieved size
+export function onDoorControlPostDraw() {
+	// If the canvas isn't ready we'll do this after the "canvasReady" event is fired instead
+	if (!canvas.ready)
+		return
+
+	fixDoorControlSize(this)
+}
+
+// Resizes the door control according to the grid size
+function fixDoorControlSize(control) {
+	let gridSize = control.wall.scene.data.grid
+	gridSize *= game.settings.get(settingsKey, "doorControlSizeFactor")
+	control.icon.width = control.icon.height = gridSize * 0.4
+	control.hitArea = new PIXI.Rectangle(gridSize * -0.02, gridSize * -0.02, gridSize * 0.44, gridSize * 0.44);
+    control.border.clear().lineStyle(1, 0xFF5500, 0.8).drawRoundedRect(gridSize * -0.02, gridSize * -0.02, gridSize * 0.44, gridSize * 0.44, gridSize * 0.05).endFill();
+	control.bg.clear().beginFill(0x000000, 1.0).drawRoundedRect(gridSize * -0.02, gridSize * -0.02, gridSize * 0.44, gridSize * 0.44, gridSize * 0.05).endFill();
+}

src/features/highlight_secret_doors.js

@@ -0,0 +1,34 @@
+import {settingsKey} from "../settings.js"
+
+const SECRET_DOOR_TINT = 0x888888
+
+// Tint all secret doors dark grey
+export function onCanvasReady(currentCanvas) {
+	if (game.settings.get(settingsKey, "highlightSecretDoors")) {
+		const types = CONST.WALL_DOOR_TYPES
+		const secretDoors = canvas.controls.doors.children.filter(control => control.wall.data.door == types.SECRET)
+		secretDoors.forEach(control => control.icon.tint = SECRET_DOOR_TINT)
+	}
+}
+
+// If door type has been changed, tint the door accordingly
+export function onUpdateWall(scene, wall, update) {
+	if (!game.settings.get(settingsKey, "highlightSecretDoors"))
+		return
+	const types = CONST.WALL_DOOR_TYPES
+	if (wall.door === types.NONE)
+		return
+	// Find the door control corresponding to the changed door
+	const changedDoor = canvas.controls.doors.children.find(control => control.wall.data._id === wall._id);
+	// If the changed door doesn't have a control it's not on this scene - ignore it
+	if (!changedDoor)
+		return
+	// The wall object we got passed might be from another scene so we replace it with the door from the current scene
+	wall = changedDoor.wall.data
+	if (wall.door === types.DOOR)
+		changedDoor.icon.tint = 0xFFFFFF
+	else if (wall.door === types.SECRET)
+		changedDoor.icon.tint = SECRET_DOOR_TINT
+	else
+		console.warn("Smart Doors | Encountered unknown door type " + wall.door + " while highlighting secret doors.")
+}

src/features/locked_door_alert.js

@@ -0,0 +1,54 @@
+import {settingsKey} from "../settings.js"
+
+// Tint the source door red when a locked alert is hovered
+export function onRenderChatMessage(message, html, data) {
+	// Tint the door that generated this message
+	const source = message.data.flags.smartdoors?.source
+	if (!source)
+		return
+
+	// Tint on mouse enter
+	const mouseEnter = function () {
+		const sourceDoor = canvas.controls.doors.children.find(door => door.wall.id === source.wall && door.wall.scene.id === source.scene);
+		if (sourceDoor)
+			sourceDoor.icon.tint = 0xff0000;
+	}
+	html.on("mouseenter", mouseEnter);
+
+	// Remove tint on mouse leave
+	const mouseLeave = function () {
+		const sourceDoor = canvas.controls.doors.children.find(door => door.wall.id === source.wall && door.wall.scene.id === source.scene);
+		if (sourceDoor)
+			sourceDoor.icon.tint = 0xffffff;
+	}
+	html.on("mouseleave", mouseLeave);
+}
+
+// Creates a chat message stating that a player tried to open a locked door
+export function onDoorLeftClick() {
+	// Check if this feature is enabled
+	if (!game.settings.get(settingsKey, "lockedDoorAlert"))
+		return false
+
+	const state = this.wall.data.ds
+	const states = CONST.WALL_DOOR_STATES
+
+	// Only create messages when the door is locked.
+	if (state !== states.LOCKED)
+		return false
+
+	// Generate no message if the gm attempts to open the door
+	if (game.user.isGM)
+		return false
+
+	// Create and send the chat message
+	const message = {}
+	message.user = game.user.id;
+	if (game.user.character)
+		message.speaker = {actor: game.user.character}
+	message.content = "Just tried to open a locked door"
+	message.sound = CONFIG.sounds.lock
+	message.flags = {smartdoors: {source: {wall: this.wall.data._id, scene: this.wall.scene.id}}}
+	ChatMessage.create(message)
+	return true
+}

src/features/synchronized_doors.js

@@ -0,0 +1,149 @@
+import {settingsKey} from "../settings.js"
+import * as Util from "../util.js"
+
+// Inject settings for synchronized doors
+export function onRederWallConfig(wallConfig, html, data) {
+	if (game.settings.get(settingsKey, "synchronizedDoors") && data.isDoor) {
+		// Inject settings
+		const synchronizedSettings = `
+			<p class="notes">${game.i18n.localize("smart-doors.ui.synchronizedDoors.description")}</p>
+			<div class="form-group">
+				<label for="synchronizationGroup">${game.i18n.localize("smart-doors.ui.synchronizedDoors.groupName")}</label>
+				<input type="text" name="synchronizationGroup"/>
+			</div>
+			<div class="form-group">
+				<label for="synchronizeSecretStatus">${game.i18n.localize("smart-doors.ui.synchronizedDoors.synchronizeSecretStatus")}</label>
+				<input type="checkbox" name="synchronizeSecretStatus" value="true"/>
+			</div>
+		`
+		html.find(".form-group").last().after(synchronizedSettings)
+
+		const smartdoorsData = data.object.flags.smartdoors
+		// Fill the injected input fields with values
+		const input = (name) => html.find(`input[name="${name}"]`); // input is a helper function to search for a input field by it's name
+		input("synchronizationGroup").prop("value", smartdoorsData?.synchronizationGroup)
+		input("synchronizeSecretStatus").prop("checked", smartdoorsData?.synchronizeSecretStatus);
+
+		// Recalculate config window height
+		wallConfig.setPosition({height: "auto"})
+	}
+}
+
+// Store our custom data from the WallConfig dialog
+export async function onWallConfigUpdate(event, formData) {
+	const synchronizeSecretStatus = formData.synchronizeSecretStatus;
+	const updateData = {flags: {smartdoors: {synchronizationGroup: formData.synchronizationGroup}}};
+	let ids = this.editTargets;
+	if (ids.length == 0) {
+		ids = [this.object.id];
+	}
+
+	// If a synchronization group is set, get the state of existing doors and assume their state
+	if (formData.synchronizationGroup) {
+		// Update the synchronizeSecretStatus flag
+		updateData.flags.smartdoors.synchronizeSecretStatus = synchronizeSecretStatus;
+
+		// Search for other doors in the synchronization group that aren't in the list of edited doors
+		const doorInGroup = Util.findInAllWalls(wall => {
+			// We only search for doors
+			if (!wall.data.door)
+				return false
+			// We only want doors in the same synchronization group
+			if (wall.data.flags.smartdoors?.synchronizationGroup !== formData.synchronizationGroup)
+				return false
+			// Doors on this scene that have their id included in `ids` are currently being changed. Ignore them.
+			if (wall.parent.id === canvas.scene.id && ids.includes(wall.id))
+				return false
+			return true
+		})
+		if (doorInGroup) {
+			// ds is the door sate in foundry
+			updateData.ds = doorInGroup.data.ds;
+
+			if (synchronizeSecretStatus) {
+				// door is the door type in foundry
+				updateData.door = doorInGroup.data.door;
+			}
+		}
+	}
+
+	// Update all the edited walls
+	const updateDataset = ids.map(id => {return {_id: id, ...updateData}});
+	const updateResult = await canvas.scene.updateEmbeddedDocuments("Wall", updateDataset);
+
+	// If door is synchronized, synchronize secret status among synchronized doors
+	if (formData.synchronizationGroup)
+		await updateSynchronizedDoors(updateData, formData.synchronizationGroup);
+
+	return updateResult;
+}
+
+// Update the state of all synchronized doors
+export function onDoorLeftClick() {
+	const state = this.wall.data.ds
+	const states = CONST.WALL_DOOR_STATES
+
+	// Check if this feature is enabled
+	if (!game.settings.get(settingsKey, "synchronizedDoors"))
+		return false
+
+	const synchronizationGroup = this.wall.data.flags.smartdoors?.synchronizationGroup
+
+	// Does this door have a synchronization group? If not there is nothing to do
+	if (!synchronizationGroup)
+		return false
+
+	// If the door is locked there is nothing to synchronize
+	if (state === states.LOCKED)
+		return false
+
+	// Calculate new door state
+	const newstate = state === states.CLOSED ? states.OPEN : states.CLOSED
+
+	// Update all doors belonging to the synchronization group
+	const updateData = {ds: newstate}
+	updateSynchronizedDoors(updateData, synchronizationGroup)
+
+	return true
+}
+
+export function onDoorRightClick() {
+	const state = this.wall.data.ds
+	const states = CONST.WALL_DOOR_STATES
+
+	// Check if this feature is enabled
+	if (!game.settings.get(settingsKey, "synchronizedDoors"))
+		return false
+
+	const synchronizationGroup = this.wall.data.flags.smartdoors?.synchronizationGroup
+
+	// Does this door have a synchronization group? If not there is nothing to do
+	if (!synchronizationGroup)
+		return false
+
+	// Only the gm is allowed to lock/unlock doors
+	if ( !game.user.isGM )
+		return false;
+
+	// If the door is currently opened we cannot lock the door
+	if ( state === states.OPEN )
+		return false;
+
+	// Calculate new door state
+	const newstate = state === states.LOCKED ? states.CLOSED : states.LOCKED;
+
+	// Update all doors belonging to the synchronization group
+	const updateData = {ds: newstate}
+	updateSynchronizedDoors(updateData, synchronizationGroup)
+
+	return true
+}
+
+// Updates all doors in the specified synchronization group with the provided data
+export function updateSynchronizedDoors(updateData, synchronizationGroup) {
+	// Search for doors belonging to the synchronization group in all scenes
+	let scenes = Util.filterAllWalls(wall => wall.data.door && wall.data.flags.smartdoors?.synchronizationGroup === synchronizationGroup);
+
+	// Update all doors in the synchronization group
+	return Promise.all(scenes.map(scene => scene.scene.updateEmbeddedDocuments("Wall", scene.walls.map((wall) => {return {_id: wall.id, ...updateData}}))));
+}

src/features/toggle_secret_door.js

@@ -0,0 +1,21 @@
+import {toggleSecretDoor} from "../keybindings.js";
+import {settingsKey} from "../settings.js"
+import {updateSynchronizedDoors} from "./synchronized_doors.js";
+
+// Toggles between normal and secret doors
+export function onDoorLeftClick() {
+	// We don't trust the event to be filled with the expected data for compatibilty with arms reach (which passes a broken event)
+	if (toggleSecretDoor && game.user.isGM) {
+		const types = CONST.WALL_DOOR_TYPES
+		const newtype = this.wall.data.door === types.DOOR ? types.SECRET : types.DOOR
+		const updateData = {door: newtype}
+		const synchronizationGroup = this.wall.data.flags.smartdoors?.synchronizationGroup
+		if (game.settings.get(settingsKey, "synchronizedDoors") && synchronizationGroup && this.wall.data.flags.smartdoors?.synchronizeSecretStatus)
+			updateSynchronizedDoors(updateData, synchronizationGroup)
+		else
+			this.wall.document.update(updateData)
+
+		return true
+	}
+	return false
+}

src/keybindings.js

@@ -0,0 +1,15 @@
+import {settingsKey} from "./settings.js";
+
+export let toggleSecretDoor = false;
+
+export function registerKeybindings() {
+	game.keybindings.register(settingsKey, "toggleSecretDoor", {
+		name: "smart-doors.keybindings.toggleSecretDoor.name",
+		hint: "smart-doors.keybindings.toggleSecretDoor.hint",
+		onDown: () => toggleSecretDoor = true,
+		onUp: () => toggleSecretDoor = false,
+		restricted: true,
+		editable: [{key: "AltLeft"}],
+		precedence: -1,
+	});
+}

src/main.js

@@ -0,0 +1,105 @@
+"use strict";
+
+import {libWrapper} from "../lib/libwrapper_shim.js";
+import * as DoorControlIconScale from "./features/door_control_icon_scale.js"
+import * as HighlightSecretDoors from "./features/highlight_secret_doors.js"
+import * as LockedDoorAlert from "./features/locked_door_alert.js"
+import * as SynchronizedDoors from "./features/synchronized_doors.js"
+import * as ToggleSecretDoor from "./features/toggle_secret_door.js"
+
+import {performMigrations} from "./migration.js"
+import {registerKeybindings} from "./keybindings.js"
+import {registerSettings, settingsKey} from "./settings.js"
+
+Hooks.once("init", () => {
+	registerSettings()
+	registerKeybindings()
+
+	hookDoorEvents()
+	hookWallConfigUpdate()
+	hookDoorControlDraw()
+	DoorControlIconScale.hookDoorControlReposition()
+})
+
+Hooks.once("ready", () => {
+	performMigrations()
+})
+
+Hooks.on("renderChatMessage", LockedDoorAlert.onRenderChatMessage)
+
+Hooks.on("canvasReady", DoorControlIconScale.onCanvasReady)
+Hooks.on("canvasReady", HighlightSecretDoors.onCanvasReady)
+
+Hooks.on("updateWall", HighlightSecretDoors.onUpdateWall)
+
+// Inject our custom settings into the WallConfig dialog
+Hooks.on("renderWallConfig", SynchronizedDoors.onRederWallConfig)
+
+// Hook the update function of the WallConfig dialog so we can store our custom data
+function hookWallConfigUpdate() {
+	// Replace the original function with our custom one
+	libWrapper.register("smart-doors", "WallConfig.prototype._updateObject", async function (wrapped, event, formData) {
+		await wrapped(event, formData);
+		return SynchronizedDoors.onWallConfigUpdate.call(this, event, formData)
+	}, "WRAPPER");
+}
+
+function hookDoorControlDraw() {
+	libWrapper.register("smart-doors", "DoorControl.prototype.draw", async function (wrapped) {
+		const result = await wrapped();
+		DoorControlIconScale.onDoorControlPostDraw.call(this)
+		return result;
+	}, "WRAPPER");
+}
+
+// Hook mouse events on DoorControls to perform our logic.
+// If we successfully handled the event block the original handler. Forward the event otherwise.
+function hookDoorEvents() {
+	// Replace the original mousedown handler with our custom one
+	libWrapper.register("smart-doors", "DoorControl.prototype._onMouseDown", function (wrapped, event) {
+		// Call our handler first. Only allow the original handler to run if our handler returns true
+		const eventHandled = onDoorMouseDown.call(this, event)
+		if (eventHandled)
+			return
+		return wrapped(event);
+	}, "MIXED");
+
+	// Replace the original rightdown handler with our custom one
+	libWrapper.register("smart-doors", "DoorControl.prototype._onRightDown", function (wrapped, event) {
+		// Call our handler first. Only allow the original handler to run if our handler returns true
+		const eventHandled = onDoorRightDown.call(this, event)
+		if (eventHandled)
+			return
+		return wrapped(event);
+	}, "MIXED");
+}
+
+// Our custom handler for mousedown events on doors
+function onDoorMouseDown(event) {
+	// If the user doesn't have the "door" permission we don't do anything.
+	if (!game.user.can("WALL_DOORS"))
+		return false
+	// If the game is paused don't do anything if the current player isn't the gm
+	if ( game.paused && !game.user.isGM )
+		return false
+
+	if (ToggleSecretDoor.onDoorLeftClick.call(this, event))
+		return true
+
+	if (LockedDoorAlert.onDoorLeftClick.call(this))
+		return true
+
+	if (SynchronizedDoors.onDoorLeftClick.call(this))
+		return true
+
+	return false
+}
+
+// Our custom handler for rightdown events on doors
+function onDoorRightDown(event) {
+
+	if (SynchronizedDoors.onDoorRightClick.call(this))
+		return true
+
+	return false
+}

src/migration.js

@@ -0,0 +1,57 @@
+import {settingsKey} from "./settings.js"
+
+const currentDataVersion = "1.1.0"
+
+export function performMigrations() {
+	if (!game.user.isGM)
+		return
+
+	let dataVersion = game.settings.get(settingsKey, "dataVersion")
+	if (dataVersion === "fresh install")
+	{
+		game.settings.set(settingsKey, "dataVersion", currentDataVersion);
+		return;
+	}
+
+	if (dataVersion === "1.0.0") {
+		dataVersion = "1.1.0"
+		ui.notifications.info(game.i18n.format("smart-doors.ui.messages.migrating", {version: dataVersion}))
+
+		// Make a dictionary that maps all door ids to their scenes
+		const walls = game.scenes.reduce((dict, scene) => {
+			scene.data.walls.forEach(wall => {
+				if (!wall.data.door)
+					return
+				dict[wall.id] = scene.id;
+			})
+			return dict
+		}, {})
+
+		// Migrate all messages that have a (wall) source id
+		game.messages.forEach(async message => {
+			const wallId = message.data.flags.smartdoors?.sourceId
+			if (!wallId)
+				return
+			const flags = message.data.flags
+			delete flags.smartdoors.sourceId
+			const scene = walls[wallId]
+			// If there is no wall with this id anymore we can drop the value. It has no purpose anymore
+			if (!scene) {
+				if (!message.data.flags.smartdoors)
+					delete flags.smartdoors
+			}
+			else {
+				// Assign the id and the scene id to the new data structure
+				flags.smartdoors.source = {wall: wallId, scene: scene}
+			}
+
+			// We have to disable recursive here so deleting keys will actually work
+			message.update({flags: flags}, {diff: false, recursive: false})
+		})
+
+		game.settings.set(settingsKey, "dataVersion", dataVersion)
+		ui.notifications.info(game.i18n.format("smart-doors.ui.messages.migrationDone", {version: dataVersion}))
+	}
+	if (dataVersion != currentDataVersion)
+		ui.notifications.error(game.i18n.format("smart-doors.ui.messages.unknownVersion", {version: dataVersion}), {permanent: true})
+}

src/settings.js

@@ -0,0 +1,49 @@
+export const settingsKey = "smart-doors";
+
+function reloadGM() {
+	if (game.user.isGM)
+		location.reload()
+}
+
+export function registerSettings() {
+	game.settings.register(settingsKey, "dataVersion", {
+		scope: "world",
+		config: false,
+		type: String,
+		default: "fresh install"
+	})
+	game.settings.register(settingsKey, "doorControlSizeFactor", {
+		name: "smart-doors.settings.doorControlSizeFactor.name",
+		hint: "smart-doors.settings.doorControlSizeFactor.hint",
+		scope: "client",
+		config: true,
+		type: Number,
+		default: 1.5,
+		onChange: () => location.reload()
+	})
+	game.settings.register(settingsKey, "highlightSecretDoors", {
+		name: "smart-doors.settings.highlightSecretDoors.name",
+		hint: "smart-doors.settings.highlightSecretDoors.hint",
+		scope: "world",
+		config: true,
+		type: Boolean,
+		default: false,
+		onChange: reloadGM,
+	})
+	game.settings.register(settingsKey, "lockedDoorAlert", {
+		name: "smart-doors.settings.lockedDoorAlert.name",
+		hint: "smart-doors.settings.lockedDoorAlert.hint",
+		scope: "world",
+		config: true,
+		type: Boolean,
+		default: true,
+	})
+	game.settings.register(settingsKey, "synchronizedDoors", {
+		name: "smart-doors.settings.synchronizedDoors.name",
+		hint: "smart-doors.settings.synchronizedDoors.hint",
+		scope: "world",
+		config: true,
+		type: Boolean,
+		default: true,
+	})
+}

src/util.js

@@ -0,0 +1,15 @@
+// Searches through all scenes for walls and returns those that match the given filter criteria.
+export function filterAllWalls(filterFn) {
+	// Find all walls that match the filter criteria
+	const scenes = game.scenes.map((scene) => {return {scene: scene, walls: scene.data.walls.filter(filterFn)}})
+	// Drop all scenes that don't contain any results
+	return scenes.filter(scene => scene.walls.length > 0)
+}
+
+// Searches through all scenes for a wall that matches the given filter criteria
+export function findInAllWalls(filterFn) {
+	// TODO The performance of this could be increased by stopping the search on the first hit
+	const scenes = filterAllWalls(filterFn)
+	// If results were found take the first wall from the first scene.
+	return scenes[0]?.walls[0]
+}