Split the module up into multiple files

src/features/door_control_icon_scale.js

@@ -0,0 +1,45 @@
+import {settingsKey} from "../settings.js"
+
+// Adjust the repositioning formula for the door controls
+export function hookDoorControlReposition() {
+	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)
+	}
+}
+
+export function hookDoorControlDraw() {
+	const originalHandler = DoorControl.prototype.draw
+	DoorControl.prototype.draw = async function () {
+		const result = await originalHandler.call(this)
+		onDoorControlPostDraw.call(this)
+		return result
+	}
+}
+
+// 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
+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 = 0x222222
+
+// 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.data._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.data._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() {
+	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: {source: {wall: this.wall.data._id, scene: this.wall.scene.id}}}
+	ChatMessage.create(message)
+	return true
+}

src/features/synchronized_doors.js

@@ -0,0 +1,132 @@
+import {settingsKey} from "../settings.js"
+import * as Util from "../util.js"
+
+// Inject settings for synchronized doors
+export function onRederWallConfig(wallConfig, html, data) {
+	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"})
+	}
+}
+
+// Store our custom data from the WallConfig dialog
+export 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) {
+		// 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.door)
+				return false
+			// We only want doors in the same synchronization group
+			if (wall.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.scene === canvas.scene && ids.includes(wall._id))
+				return false
+			return true
+		})
+		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)
+}
+
+// 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
+function updateSynchronizedDoors(updateData, synchronizationGroup) {
+	// Search for doors belonging to the synchronization group in all scenes
+	let scenes = Util.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}}))
+	})
+}

src/features/toggle_secret_door.js

@@ -0,0 +1,12 @@
+import {settingsKey} from "../settings.js"
+
+// Toggles between normal and secret doors
+export function onDoorLeftClick(event) {
+	if (event.data.originalEvent.ctrlKey && game.user.isGM && game.settings.get(settingsKey, "toggleSecretDoors")) {
+		const types = CONST.WALL_DOOR_TYPES
+		const newtype = this.wall.data.door === types.DOOR ? types.SECRET : types.DOOR
+		this.wall.update({door: newtype})
+		return true
+	}
+	return false
+}