diff --git a/backend/src/models/Map.js b/backend/src/models/Map.js index c3545d21..92665939 100644 --- a/backend/src/models/Map.js +++ b/backend/src/models/Map.js @@ -27,6 +27,32 @@ const MapSchema = new Schema({ x: { type: Number, default: 0 }, y: { type: Number, default: 0 } }], + // Lights placed on the map. x/y are image pixels like a pin — a light is not tied to a cell — and + // `radius` is how far it reaches in image pixels, of which `bright` is the part that is bright + // light and the rest dim light. The walls below are what stops one, see the viewer's + // services/MapLighting.js. + lights: [{ + x: { type: Number, default: 0 }, + y: { type: Number, default: 0 }, + radius: { type: Number, min: 1, default: 150 }, + bright: { type: Number, min: 0, default: 75 }, + // Tint of the light, like '#ffc46b'; empty for a plain white light. + color: { type: String, default: '' }, + // The Foundry AmbientLight document this light mirrors, when the world sent it (see + // routes/foundry-link.js). Empty for a light the campaign placed itself. + foundryLightId: { type: String, default: '' } + }], + // The line segments that block the lights above. Endpoints are image pixels, and the app draws + // them from corner to corner of the grid so a wall follows its lines. + walls: [{ + x1: { type: Number, default: 0 }, + y1: { type: Number, default: 0 }, + x2: { type: Number, default: 0 }, + y2: { type: Number, default: 0 }, + // The Foundry Wall document this segment came from, when the world sent it. The world owns its + // walls, so a synced one is drawn back over by the next push of that scene. + foundryWallId: { type: String, default: '' } + }], campaign: { type: Schema.Types.ObjectId, ref: 'Campaign', @@ -39,6 +65,9 @@ const MapSchema = new Schema({ ref: 'Folder', default: null }, + // The Foundry scene whose lights and walls this map mirrors (see routes/foundry-link.js). Empty for + // a map the campaign made for itself, which is the one kind of light a world never hears about. + foundrySceneId: { type: String, default: '' }, date: { type: Date, default: Date.now } }); diff --git a/backend/src/routes/foundry-link.js b/backend/src/routes/foundry-link.js index 0cb1675b..17bcc5f1 100644 --- a/backend/src/routes/foundry-link.js +++ b/backend/src/routes/foundry-link.js @@ -7,6 +7,9 @@ const Campaign = require('../models/Campaign'); const Actor = require('../models/Actor'); const Item = require('../models/Item'); const Folder = require('../models/Folder'); +// Named for what it is: the plain `Map` of this module's own scope would hide the built-in `Map` the +// item folder sync below builds its trees out of. +const MapModel = require('../models/Map'); const { foundryActorToCharacter } = require('../services/actor-foundry'); const { foundryItemToItemData } = require('../services/item-foundry'); const { joinFoundryAssetUrl } = require('../services/foundry-icons'); @@ -268,6 +271,187 @@ function resolveFoundryItemFolder(source, folders) { return folders.get(foundryFolderId.trim())?._id || null; } +// --- Scene lighting ------------------------------------------------------------ +// A Foundry scene lights its own ground, and the campaign mirrors that onto the map standing for that +// scene: the world's ambient lights and the walls that stop them arrive there, so a torch lit in the +// world is a torch on the map the campaign reads, and the dark behind its walls is the same dark. +// +// The module sends its coordinates as pixels of the scene's background image at the size that image +// has on disk, and its reaches likewise. The campaign keeps everything as pixels of its own map image, +// so the grid cell is the unit the two agree on: one scene pixel is worth as many map pixels as that +// map's cell is wider or narrower than the scene's. + +function sceneNumber(value, fallback = 0) { + const number = Number(value); + return Number.isFinite(number) ? number : fallback; +} + +// The scene a push describes: enough of it to mirror a map after it, and to scale its lighting onto +// the grid of whichever map that turns out to be. +function readSceneSource(source) { + const id = String(source?.id || '').trim().slice(0, 120); + if (!id) return null; + return { + id, + title: String(source?.title || '').trim().slice(0, 200), + // How wide one of the scene's cells is in its image pixels, and how much distance it stands + // for: the map the scene is mirrored onto keeps both of these under the same names. + grid: Math.max(1, Math.round(sceneNumber(source?.grid, 50))), + gridDistance: Math.max(0.01, sceneNumber(source?.gridDistance, 5)), + image: typeof source?.image === 'string' ? source.image.trim() : '' + }; +} + +// The map a scene's lighting belongs to: the one already mirroring that scene, or the campaign's own +// map of the same name — the same courtesy the item sync extends a hand-written row, so whoever drew +// the map by hand is not made to start over — and, when the scene has lighting of its own and the +// campaign has no map for it yet, a new map mirroring the scene. A scene with nothing to send never +// invents a map nobody asked for. +async function sceneMap(campaign, scene, create) { + const mapped = await MapModel.findOne({ campaign: campaign._id, foundrySceneId: scene.id }); + if (mapped) return mapped; + + if (scene.title) { + const namesakes = await MapModel.find({ campaign: campaign._id, name: scene.title }).limit(4); + const claiming = namesakes.filter((map) => !map.foundrySceneId); + // Only a name the campaign uses once claims the scene; two maps of that name would make it a + // guess which of them the world is talking about. + if (claiming.length === 1) { + const map = claiming[0]; + map.foundrySceneId = scene.id; + return map; + } + } + if (!create) return null; + + return new MapModel({ + campaign: campaign._id, + name: scene.title || 'Foundry scene', + // The scene's own artwork, read against its world like every other Foundry image (see + // worldAssetUrl), so the campaign is looking at the same picture the players are. + image: worldAssetUrl(scene.image, campaign?.settings?.integrations?.foundryUrl), + gridSize: scene.grid, + scale: scene.gridDistance, + foundrySceneId: scene.id + }); +} + +// A scene pixel as a coordinate of the campaign's map: whole pixels, never negative, and scaled by the +// two grids' difference in cell width. +function scenePixelToMap(value, ratio) { + const number = sceneNumber(value, 0) * ratio; + return Math.max(0, Math.round(number)); +} + +// The tint of a light, or none: the viewer paints with it, so anything that is not a hex colour is +// dropped rather than trusted. +function sceneLightColor(value) { + const color = typeof value === 'string' ? value.trim().toLowerCase() : ''; + return /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/.test(color) ? color : ''; +} + +// A wall of the map is kept at its corners of the grid, the way a wall drawn in Dragonroll is, so the +// lines a scene sends and the lines a campaign draws follow the same grid. +function toMapGridVertex(value, offset, size) { + const steps = Math.round((Math.max(0, Math.round(value)) - offset) / size); + return Math.max(0, Math.round(offset + steps * size)); +} + +// The lights of a scene written onto its map. A light the world sent before is written over — the +// world owns its own lighting, so unlike an actor's fields a move lands on every push — one it never +// sent is added, and one it has let go of goes. A light the campaign placed itself (no foundryLightId) +// is none of the world's business and stays. +function writeSceneLights(map, scene, sources) { + const ratio = map.gridSize / scene.grid; + const kept = new Set(); + let changed = false; + + for (const source of sources) { + const id = String(source?.id || '').trim().slice(0, 120); + if (!id || kept.has(id)) continue; + kept.add(id); + + const radius = Math.max(1, scenePixelToMap(source?.radius, ratio)); + const spot = { + x: scenePixelToMap(source?.x, ratio), + y: scenePixelToMap(source?.y, ratio), + radius, + bright: Math.max(0, Math.min(radius, scenePixelToMap(source?.bright, ratio))), + color: sceneLightColor(source?.color) + }; + const light = map.lights.find((entry) => entry.foundryLightId && String(entry.foundryLightId) === id); + if (light) { + Object.assign(light, spot); + } else { + map.lights.push({ ...spot, foundryLightId: id }); + } + changed = true; + } + + // Only the world's own lights are pruned, and only by a push that speaks of lights at all. + const remaining = map.lights.filter((entry) => !entry.foundryLightId || kept.has(String(entry.foundryLightId))); + if (remaining.length !== map.lights.length) changed = true; + map.lights = remaining; + return changed; +} + +// The walls of a scene, likewise: the world drew them, so its own walls arrive whole with every push. +function writeSceneWalls(map, scene, sources) { + const ratio = map.gridSize / scene.grid; + const kept = new Set(); + let changed = false; + + for (const source of sources) { + const id = String(source?.id || '').trim().slice(0, 120); + if (!id || kept.has(id)) continue; + kept.add(id); + + const corner = { + x1: toMapGridVertex(scenePixelToMap(source?.x1, ratio), map.offsetX, map.gridSize), + y1: toMapGridVertex(scenePixelToMap(source?.y1, ratio), map.offsetY, map.gridSize), + x2: toMapGridVertex(scenePixelToMap(source?.x2, ratio), map.offsetX, map.gridSize), + y2: toMapGridVertex(scenePixelToMap(source?.y2, ratio), map.offsetY, map.gridSize) + }; + // A wall from a corner to itself blocks nothing, and neither does its twin drawn backwards. + if (corner.x1 === corner.x2 && corner.y1 === corner.y2) continue; + + const wall = map.walls.find((entry) => entry.foundryWallId && String(entry.foundryWallId) === id); + if (wall) Object.assign(wall, corner); + else map.walls.push({ ...corner, foundryWallId: id }); + changed = true; + } + + const remaining = map.walls.filter((entry) => !entry.foundryWallId || kept.has(String(entry.foundryWallId))); + if (remaining.length !== map.walls.length) changed = true; + map.walls = remaining; + return changed; +} + +// The maps the module reconciles its scenes against: which campaign lights belong in which world +// scene, and how far a pixel of that map is worth. Only the maps that speak of lighting are sent, and +// a map mirroring a scene is sent even empty of lights, because that is what tells the world its +// campaign has put every one of its lights out. +function sceneLightingList(maps) { + return maps + .filter((map) => (map.lights?.length ?? 0) > 0 || map.foundrySceneId) + .map((map) => ({ + _id: map._id, + name: map.name, + foundrySceneId: map.foundrySceneId || '', + gridSize: map.gridSize, + scale: map.scale, + lights: (map.lights ?? []).map((light) => ({ + _id: light._id, + x: light.x, + y: light.y, + radius: light.radius, + bright: light.bright, + color: light.color || '', + foundryLightId: light.foundryLightId || '' + })) + })); +} + // Linking a world to a campaign happens through the sign-up link every service // uses (routes/service-link.js); what stays here is the sync that world keeps up @@ -477,6 +661,82 @@ router.post('/sync/map-item', async (req, res) => { } }); +// The lighting of one of the world's scenes: its ambient lights and the walls that stop them, sent +// whole so the campaign's map of that scene reads like the ground the players are standing on. +router.post('/sync/scene', async (req, res) => { + try { + const campaign = await syncCampaign(req, res); + if (!campaign) return; + + const scene = readSceneSource(req.body.scene); + const lights = Array.isArray(req.body.lights) ? req.body.lights : null; + const walls = Array.isArray(req.body.walls) ? req.body.walls : null; + if (!requestMatchesWorld(campaign, req.body.worldId) || !scene || (!lights && !walls)) { + return res.json({ status: 'error', msg: 'errors.missing-data' }); + } + + const map = await sceneMap(campaign, scene, (lights?.length ?? 0) + (walls?.length ?? 0) > 0); + // A world pushing a scene empty of lighting onto a campaign that has no map for it: there is + // nothing here to remember, so nothing is remembered. + if (!map) return res.json({ status: 'ok', map: null, lights: 0, walls: 0 }); + + // A push owns the lighting it carries and nothing else: not the map's name, not its picture, + // not the grid whoever lined it up by hand settled on. + if (lights) writeSceneLights(map, scene, lights); + if (walls) writeSceneWalls(map, scene, walls); + await map.save(); + + res.json({ + status: 'ok', + map: { _id: map.id, name: map.name, gridSize: map.gridSize, scale: map.scale, foundrySceneId: map.foundrySceneId }, + lights: map.lights.filter((entry) => entry.foundryLightId).length, + walls: map.walls.filter((entry) => entry.foundryWallId).length + }); + } catch (err) { + console.error(err); + res.json({ status: 'error', msg: 'errors.internal' }); + } +}); + +// The campaign's lighting as the world reads it: which of its lights stand in which scene, at the map +// pixels the module scales back onto the world's own grid. +router.get('/sync/scenes', async (req, res) => { + try { + const campaign = await syncCampaign(req, res); + if (!campaign) return; + const maps = await MapModel.find({ campaign: campaign._id }).sort({ name: 1 }).lean(); + res.json({ status: 'ok', scenes: sceneLightingList(maps) }); + } catch (err) { + console.error(err); + res.json({ status: 'error', msg: 'errors.internal' }); + } +}); + +// A light the campaign placed and the world has taken on: the AmbientLight document standing for it, so +// the next write of that light knows which document to move instead of adding a second one. +router.post('/sync/map-scene-light', async (req, res) => { + try { + const campaign = await syncCampaign(req, res); + if (!campaign) return; + const { map, light, foundryLightId, worldId } = req.body; + if (!requestMatchesWorld(campaign, worldId) || !map || !light || !foundryLightId) { + return res.json({ status: 'error', msg: 'errors.missing-data' }); + } + + const mapDoc = await MapModel.findOne({ _id: map, campaign: campaign._id }); + if (!mapDoc) return res.json({ status: 'error', msg: 'errors.notfound' }); + const entry = mapDoc.lights.find((current) => String(current._id) === String(light)); + if (!entry) return res.json({ status: 'error', msg: 'errors.notfound' }); + + entry.foundryLightId = String(foundryLightId).trim().slice(0, 120); + await mapDoc.save(); + res.json({ status: 'ok', light: { _id: entry._id, foundryLightId: entry.foundryLightId } }); + } catch (err) { + console.error(err); + res.json({ status: 'error', msg: 'errors.internal' }); + } +}); + module.exports = router; // The writers every Foundry document goes through: the sync pushes above, and the // force import a campaign asks for from its sidebar (routes/foundry.js). One set of diff --git a/backend/src/routes/map.js b/backend/src/routes/map.js index 5bff4435..a28d1570 100644 --- a/backend/src/routes/map.js +++ b/backend/src/routes/map.js @@ -238,4 +238,205 @@ router.post('/remove-token', async (req, res) => { } }); +// --- Lights --- +// A light shines from one spot of the image and is as free as a pin: it is not tied to a cell, so it +// lands wherever it is placed. Its reach is measured in image pixels too, so it covers the same ground +// whatever the zoom is, and it is that reach the viewer cuts its shadow against the walls below with. + +// How far a light of the map reaches when nothing is asked for: about three cells of the default grid. +const DEFAULT_LIGHT_RADIUS = 150; + +function toReach(value, fallback) { + const number = Number(value); + if (!Number.isFinite(number) || number <= 0) return fallback; + return Math.max(1, Math.round(number)); +} + +// The bright core of a light: never wider than the light itself, and never negative. A light with no +// core is still a light, so 0 is a value of its own here and not a missing one. +function toBright(value, radius, fallback) { + if (value === undefined || value === null || value === '') return Math.min(radius, Math.round(fallback)); + const number = Number(value); + if (!Number.isFinite(number)) return Math.min(radius, Math.round(fallback)); + return Math.max(0, Math.min(radius, Math.round(number))); +} + +// A tint is a hex colour and nothing else: the viewer paints the light with it, so a value carrying +// more than colour codes is dropped instead of trusted. +function toColor(value) { + const color = String(value ?? '').trim().toLowerCase(); + return /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/.test(color) ? color : ''; +} + +router.post('/place-light', async (req, res) => { + try { + const { id, x, y, radius, bright, color } = req.body; + if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' }); + + const map = await Map.findById(id); + if (!map) return res.json({ status: 'error', msg: 'errors.notfound' }); + if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' }); + + const reach = toReach(radius, DEFAULT_LIGHT_RADIUS); + map.lights.push({ + x: toCoordinate(x), + y: toCoordinate(y), + radius: reach, + bright: toBright(bright, reach, reach / 2), + color: toColor(color) + }); + + await map.save(); + res.json({ status: 'ok', map }); + } catch (err) { + console.error(err); + res.json({ status: 'error', msg: 'errors.internal' }); + } +}); + +router.post('/update-light', async (req, res) => { + try { + const { id, light, x, y, radius, bright, color } = req.body; + if (!id || !light) return res.json({ status: 'error', msg: 'errors.missing-data' }); + + const map = await Map.findById(id); + if (!map) return res.json({ status: 'error', msg: 'errors.notfound' }); + if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' }); + + const current = map.lights.find((entry) => String(entry._id) === String(light)); + if (!current) return res.json({ status: 'error', msg: 'errors.notfound' }); + + if (x !== undefined) current.x = toCoordinate(x); + if (y !== undefined) current.y = toCoordinate(y); + if (color !== undefined) current.color = toColor(color); + if (radius !== undefined) { + current.radius = toReach(radius, current.radius); + // A light shrunk below its own core takes the core with it, unless this request is + // setting the core as well, which is clamped to the new reach below. + current.bright = Math.min(current.bright, current.radius); + } + if (bright !== undefined) current.bright = toBright(bright, current.radius, current.bright); + + await map.save(); + res.json({ status: 'ok', map }); + } catch (err) { + console.error(err); + res.json({ status: 'error', msg: 'errors.internal' }); + } +}); + +router.post('/remove-light', async (req, res) => { + try { + const { id, light } = req.body; + if (!id || !light) return res.json({ status: 'error', msg: 'errors.missing-data' }); + + const map = await Map.findById(id); + if (!map) return res.json({ status: 'error', msg: 'errors.notfound' }); + if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' }); + + // `_id` stays with the lights that remain, the same way the tokens are removed. + map.lights = map.lights + .filter((entry) => String(entry._id) !== String(light)) + .map((entry) => ({ + _id: entry._id, + x: entry.x, + y: entry.y, + radius: entry.radius, + bright: entry.bright, + color: entry.color, + foundryLightId: entry.foundryLightId + })); + await map.save(); + res.json({ status: 'ok', map }); + } catch (err) { + console.error(err); + res.json({ status: 'error', msg: 'errors.internal' }); + } +}); + +// --- Walls --- +// The segments that stop a light. They are drawn from one corner of the grid to another — the same +// corners the tokens' cells are counted from — so a wall lines up with the grid of the map it belongs +// to. A world's walls travel to the map they light (routes/foundry-link.js) and arrive at the corners +// of the grid the same way. + +function toGridVertex(value, offset, size) { + const grid = Math.max(1, Number(size) || 50); + const origin = Number(offset) || 0; + const steps = Math.round((toCoordinate(value) - origin) / grid); + return Math.max(0, Math.round(origin + steps * grid)); +} + +// The two ends of a wall are corners of this map's grid, whatever the pointer asked for. +function wallCorners(body, map) { + return { + x1: toGridVertex(body.x1, map.offsetX, map.gridSize), + y1: toGridVertex(body.y1, map.offsetY, map.gridSize), + x2: toGridVertex(body.x2, map.offsetX, map.gridSize), + y2: toGridVertex(body.y2, map.offsetY, map.gridSize) + }; +} + +function isSameWall(wall, corner) { + return (String(wall.x1) === String(corner.x1) && String(wall.y1) === String(corner.y1) + && String(wall.x2) === String(corner.x2) && String(wall.y2) === String(corner.y2)) + // A wall drawn backwards is the same wall. + || (String(wall.x1) === String(corner.x2) && String(wall.y1) === String(corner.y2) + && String(wall.x2) === String(corner.x1) && String(wall.y2) === String(corner.y1)); +} + +router.post('/wall', async (req, res) => { + try { + const { id } = req.body; + if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' }); + + const map = await Map.findById(id); + if (!map) return res.json({ status: 'error', msg: 'errors.notfound' }); + if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' }); + + const corner = wallCorners(req.body, map); + // A wall from a corner to itself blocks nothing and cannot be clicked off again. + if (corner.x1 === corner.x2 && corner.y1 === corner.y2) { + return res.json({ status: 'error', msg: 'errors.missing-data' }); + } + // Drawing over a wall that is already there does not add a second one. + if (map.walls.some((wall) => isSameWall(wall, corner))) return res.json({ status: 'ok', map }); + + map.walls.push(corner); + await map.save(); + res.json({ status: 'ok', map }); + } catch (err) { + console.error(err); + res.json({ status: 'error', msg: 'errors.internal' }); + } +}); + +router.post('/remove-wall', async (req, res) => { + try { + const { id, wall } = req.body; + if (!id || !wall) return res.json({ status: 'error', msg: 'errors.missing-data' }); + + const map = await Map.findById(id); + if (!map) return res.json({ status: 'error', msg: 'errors.notfound' }); + if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' }); + + // `_id` stays with the walls that remain, like everything else hanging off a map. + map.walls = map.walls + .filter((entry) => String(entry._id) !== String(wall)) + .map((entry) => ({ + _id: entry._id, + x1: entry.x1, + y1: entry.y1, + x2: entry.x2, + y2: entry.y2, + foundryWallId: entry.foundryWallId + })); + await map.save(); + res.json({ status: 'ok', map }); + } catch (err) { + console.error(err); + res.json({ status: 'error', msg: 'errors.internal' }); + } +}); + module.exports = router; diff --git a/dragonroll-foundry/scripts/api.js b/dragonroll-foundry/scripts/api.js index baeb988b..ced25522 100644 --- a/dragonroll-foundry/scripts/api.js +++ b/dragonroll-foundry/scripts/api.js @@ -36,6 +36,12 @@ let folderSyncRunning = false; const syncingItemIds = new Set(); const syncingFolderIds = new Set(); const queuedItemChanges = new Map(); +// The lighting of the scene being played: queued while the GM drags walls about, and written back into +// the world from the campaign on a timer. +let sceneLightingTimeout; +let sceneLightingRunning = false; +let sceneLightingErrorLogged = false; +const syncingLightIds = new Set(); function getCollectionContents(collection, collectionName) { if (!collection) { @@ -441,6 +447,7 @@ function handleAutoSyncChange(value) { clearTimeout(actorSyncTimeout); clearTimeout(itemSyncTimeout); clearTimeout(folderSyncTimeout); + clearTimeout(sceneLightingTimeout); return; } if (!game.user?.isGM || !getSyncToken()) return; @@ -450,6 +457,10 @@ function handleAutoSyncChange(value) { initializeCharacterSync(); reconcileDragonrollItems(); queueFoundryItemFolders(400); + // The lighting of the scene the campaign mirrors converges too: a wall or a lamp moved while + // autosync was off is the world's, and the campaign's own lights are written back into the scene. + queueSceneLightingChange(400); + reconcileDragonrollSceneLighting(); if (queuedActorChanges.size) { clearTimeout(actorSyncTimeout); actorSyncTimeout = setTimeout(flushActorChanges, 400); @@ -1061,6 +1072,371 @@ async function reconcileDragonrollItems() { } } +// --- Scene lighting ------------------------------------------------------------ +// The lights of the scene being played, and the walls that stop them, travel to the Dragonroll map +// mirroring that scene; the lights the campaign places on that map travel back into the scene as +// ambient lights. Lighting belongs to a world the same way whatever system it runs, so unlike the +// actors and the items this asks for no particular one. +// +// Foundry measures a scene in canvas pixels (its background image as it is drawn) and a light's reach +// in the scene's distance units; Dragonroll measures both in pixels of the map image and of its grid. +// So a scene goes over as pixels of its own background image, and comes back through the grid cell, +// which is the one unit the two share. + +// The canvas of the scene being played. `canvas` is a global only where a scene has been drawn, and +// only in a game client at that, so it is asked for the way the module asks for any global it cannot +// be sure of. +function foundryCanvas() { + return typeof canvas === "undefined" ? null : canvas; +} + +// The scene whose lighting travels: the one being played. Foundry loads the walls and lights of a scene +// when it draws it, so nothing else of the world's is at hand to send. +function currentScene() { + return foundryCanvas()?.scene ?? game.scenes?.active ?? game.scenes?.current ?? null; +} + +// A scene's embedded documents of one kind. Which collection holds them has moved about between Foundry +// versions, so each way is tried, best first, and only documents of the kind asked for are taken. +function sceneDocuments(scene, kind) { + if (!scene) return []; + for (const candidate of [ + scene.getEmbeddedCollection?.(kind)?.contents, + scene[kind === "Wall" ? "walls" : "lighting"]?.contents, + scene.embedded?.[kind]?.contents, + scene.embeddedContents, + ]) { + if (!Array.isArray(candidate)) continue; + return candidate.filter((document) => document?.documentName === kind); + } + return []; +} + +function findSceneDocument(scene, kind, id) { + return sceneDocuments(scene, kind).find((document) => String(document.id) === String(id)) ?? null; +} + +// Scene canvas pixels → pixels of the scene's background image at the size it has on disk, which is +// what a Dragonroll map is measured in. `dimensions.sceneRatio` is the scale that image is drawn at. +function sceneImageScale() { + const ratio = Number(foundryCanvas()?.dimensions?.sceneRatio); + return Number.isFinite(ratio) && ratio > 0 ? ratio : 1; +} + +function toSceneImagePixels(value) { + const number = Number(value); + return Number.isFinite(number) ? Math.round(number / sceneImageScale()) : 0; +} + +// How wide one of the scene's cells is, in its image pixels. +function sceneImageGrid(scene) { + const grid = Number(scene?.grid ?? foundryCanvas()?.dimensions?.grid); + return Number.isFinite(grid) && grid > 0 ? Math.round(grid) : 50; +} + +function sceneGridDistance(scene) { + const distance = Number(scene?.gridDistance); + return Number.isFinite(distance) && distance > 0 ? distance : 5; +} + +// A light's reach, which Foundry measures in the scene's distance units, as pixels of its image: so +// many cells, at the scene's own pixels per cell. +function lightReachToImagePixels(value, scene) { + const reach = Number(value); + if (!Number.isFinite(reach) || reach <= 0) return 0; + return Math.round((reach / sceneGridDistance(scene)) * sceneImageGrid(scene)); +} + +// A colour of a Foundry light as its document writes it: a hex string, or a number in the versions +// that stored one that way. Empty for a light with no tint of its own. +function sceneLightColor(color) { + if (typeof color === "string") return /^#[0-9a-f]{3,8}$/i.test(color.trim()) ? color.trim().toLowerCase() : ""; + if (Number.isFinite(color) && color > 0) return `#${Math.round(color).toString(16).padStart(6, "0")}`; + return ""; +} + +// Foundry's wall kinds and restrictions: a wall that lets the players see through it lights whatever +// it is drawn over, a wall only sensing shapes what a sensor reaches and lets light through, and a +// door left open lets the light through along with whoever opened it. +const WALL_KIND_SENSES = "sense"; +const WALL_MOVEMENT_OPEN = 2; +const WALL_RESTRICTION_BLOCK = 2; + +function blocksSceneLight(wall) { + if (String(wall?.wall ?? "walls") === WALL_KIND_SENSES) return false; + if (Number(wall?.move) === WALL_MOVEMENT_OPEN) return false; + return Number(wall?.sight) === WALL_RESTRICTION_BLOCK || Number(wall?.light) === WALL_RESTRICTION_BLOCK; +} + +function serializeSceneLight(light, scene) { + const config = light?.config ?? {}; + return { + id: String(light.id), + x: toSceneImagePixels(light.x), + y: toSceneImagePixels(light.y), + radius: lightReachToImagePixels(config.dim, scene), + bright: lightReachToImagePixels(config.bright, scene), + color: sceneLightColor(config.color), + }; +} + +function serializeSceneWall(wall) { + const corner = wall?.c ?? {}; + return { + id: String(wall.id), + x1: toSceneImagePixels(corner.x), + y1: toSceneImagePixels(corner.y), + x2: toSceneImagePixels(corner.x2), + y2: toSceneImagePixels(corner.y2), + }; +} + +function sceneLightingMeta(scene) { + return { + id: scene.id, + title: String(scene.title ?? scene.name ?? ""), + grid: sceneImageGrid(scene), + gridDistance: sceneGridDistance(scene), + image: sceneBackgroundImage(scene), + }; +} + +// The scene's own artwork, as an address a campaign outside the world can read — the same as every +// other image the module sends (see serializeFoundryActor). +function sceneBackgroundImage(scene) { + const image = scene?.texture?.src ?? scene?.img ?? ""; + if (typeof image !== "string" || !image || /^(https?:|data:|\/\/)/i.test(image)) return image || ""; + return new URL(image, window.location.origin).toString(); +} + +// What a scene is lit by, whole. A scene with neither lights nor walls is worth sending for what it +// takes off the campaign; it is the campaign's own business whether that is worth a map of. +function sceneLightingSnapshot(scene) { + const target = scene ?? currentScene(); + if (!target) return null; + return { + scene: sceneLightingMeta(target), + lights: sceneDocuments(target, "AmbientLight").map((light) => serializeSceneLight(light, target)), + walls: sceneDocuments(target, "Wall").filter(blocksSceneLight).map(serializeSceneWall), + }; +} + +async function pushSceneLighting() { + const token = getSyncToken(); + if (!token || !game.user?.isGM || !game.world) return; + const snapshot = sceneLightingSnapshot(); + if (!snapshot) return; + + await postDragonroll("foundry/sync/scene", { worldId: game.world.id, ...snapshot }, token); +} + +function queueSceneLightingChange(delay = 400) { + clearTimeout(sceneLightingTimeout); + sceneLightingTimeout = setTimeout(flushSceneLighting, delay); +} + +async function flushSceneLighting() { + // Autosync off: the lighting edits wait with the actor and item ones, so turning it back on sends them. + if (!isAutoSyncEnabled()) return; + try { + await pushSceneLighting(); + sceneLightingErrorLogged = false; + } catch (error) { + if (!sceneLightingErrorLogged) { + sceneLightingErrorLogged = true; + console.warn(`${MODULE_ID} | Scene lighting sync failed and will retry.`, error); + } + queueSceneLightingChange(5000); + } +} + +// Writing into the world from the campaign is marked the same way every other Dragonroll write is, so +// the world does not echo it straight back to the campaign. +function dragonrollLightId(light) { + return light.getFlag?.(MODULE_ID, "lightId") || light.flags?.[MODULE_ID]?.lightId || ""; +} + +function isSceneLightingMutation(document) { + return document?.flags?.[MODULE_ID]?.syncMutation === true || syncingLightIds.has(document?.id); +} + +async function withLightSyncSuppressed(light, callback) { + if (!light?.id) return callback(); + syncingLightIds.add(light.id); + try { + return await callback(); + } finally { + syncingLightIds.delete(light.id); + } +} + +// How many canvas pixels one pixel of the campaign's map is worth in the scene being written to: cells +// first, then the cell as the world's canvas draws it. +function mapPixelsToSceneCanvas(value, mirror) { + const cell = Number(mirror?.gridSize) || sceneImageGrid(currentScene()); + const gridPixels = Number(foundryCanvas()?.dimensions?.gridPixels) || sceneImageGrid(currentScene()) * sceneImageScale(); + const number = Number(value); + if (!Number.isFinite(number)) return 0; + return Math.round((number / Math.max(1, cell)) * gridPixels); +} + +// A reach of the campaign's map, in its pixels, as so many of the scene's distance units. `scale` is +// how much distance one cell of the map stands for, which is what Foundry measures a light in. +function mapPixelsToSceneDistance(value, mirror) { + const cell = Number(mirror?.gridSize) || sceneImageGrid(currentScene()); + const perCell = Number(mirror?.scale) || sceneGridDistance(currentScene()); + const number = Number(value); + if (!Number.isFinite(number) || number <= 0) return 0; + return Math.round(((number / Math.max(1, cell)) * perCell * 100)) / 100; +} + +function sceneLightUpdateData(entry, mirror) { + return { + x: mapPixelsToSceneCanvas(entry.x, mirror), + y: mapPixelsToSceneCanvas(entry.y, mirror), + "config.dim": mapPixelsToSceneDistance(entry.radius, mirror), + "config.bright": mapPixelsToSceneDistance(entry.bright, mirror), + "config.color": entry.color || null, + }; +} + +// Whether a light of the world already says what the campaign's light says — within a pixel, and within +// a hundredth of a distance unit. Writing a light that is already where it belongs is how a sync would +// never come to rest: the two sides measure in different units and round differently doing it. +function sceneLightMatches(light, entry, mirror) { + const updates = sceneLightUpdateData(entry, mirror); + const near = (foundry, wanted, tolerance) => Math.abs(Number(foundry ?? 0) - Number(wanted ?? 0)) <= tolerance; + return near(light.x, updates.x, 1) + && near(light.y, updates.y, 1) + && near(light.config?.radius?.dim, updates["config.dim"], 0.01) + && near(light.config?.radius?.bright, updates["config.bright"], 0.01) + && sceneLightColor(light.config?.color) === String(entry.color ?? "").toLowerCase(); +} + +async function mapDragonrollSceneLight(mapId, lightId, foundryLightId) { + const token = getSyncToken(); + return postDragonroll("foundry/sync/map-scene-light", { + worldId: game.world.id, + map: String(mapId), + light: String(lightId), + foundryLightId: String(foundryLightId), + }, token); +} + +function makeSceneLightData(entry, mirror) { + return { + name: String(mirror?.name || "Dragonroll") + " light", + hidden: false, + x: mapPixelsToSceneCanvas(entry.x, mirror), + y: mapPixelsToSceneCanvas(entry.y, mirror), + config: { + alpha: 1, + dim: mapPixelsToSceneDistance(entry.radius, mirror), + bright: mapPixelsToSceneDistance(entry.bright, mirror), + color: entry.color || null, + }, + flags: { [MODULE_ID]: { lightId: String(entry._id), syncMutation: true } }, + }; +} + +async function createSceneLightFromDragonroll(scene, entry, mirror) { + const LightDocument = CONFIG.AmbientLight?.documentClass ?? (typeof AmbientLight === "undefined" ? null : AmbientLight); + if (!LightDocument?.create) return null; + const created = await LightDocument.create(makeSceneLightData(entry, mirror), { parent: scene }); + const light = Array.isArray(created) ? created[0] : created; + if (!light) return null; + + await withLightSyncSuppressed(light, async () => { + await light.update({ [`flags.${MODULE_ID}.syncMutation`]: false }); + }); + await mapDragonrollSceneLight(mirror._id, entry._id, light.id); + return light; +} + +async function applyDragonrollSceneLight(light, entry, mirror) { + const retag = dragonrollLightId(light) !== String(entry._id) + ? { [`flags.${MODULE_ID}.lightId`]: String(entry._id) } + : null; + // Already where the campaign says it is: nothing is written, which is what keeps this from + // rewriting the world's lighting every few seconds for the rest of the evening. + if (sceneLightMatches(light, entry, mirror)) { + if (retag) await light.update(retag); + return; + } + + await withLightSyncSuppressed(light, async () => { + await light.update(sceneLightUpdateData(entry, mirror)); + if (retag) await light.update(retag); + }); +} + +// Which of the campaign's maps the scene being played mirrors: the one that says it does, failing that +// a map of the same name — the same courtesy the item sync offers a hand-written row, and refused the +// moment two maps of that name leave it a guess. +function sceneMirrorMap(scenes, scene) { + const rows = Array.isArray(scenes) ? scenes : []; + const mapped = rows.find((row) => row.foundrySceneId && String(row.foundrySceneId) === String(scene.id)); + if (mapped) return mapped; + + const title = String(scene.title ?? scene.name ?? "").trim(); + if (!title) return null; + const namesakes = rows.filter((row) => !row.foundrySceneId && String(row.name ?? "").trim() === title); + return namesakes.length === 1 ? namesakes[0] : null; +} + +async function reconcileDragonrollSceneLighting() { + const token = getSyncToken(); + if (!token || !game.user?.isGM || !game.world || sceneLightingRunning || !isAutoSyncEnabled()) return; + const scene = currentScene(); + if (!scene) return; + sceneLightingRunning = true; + try { + const result = await getDragonroll("foundry/sync/scenes", token); + const mirror = sceneMirrorMap(result.scenes, scene); + if (!mirror) return; + + const entries = Array.isArray(mirror.lights) ? mirror.lights : []; + const wanted = new Set(entries.map((entry) => String(entry._id))); + const localByRemoteId = new Map(sceneDocuments(scene, "AmbientLight") + .map((light) => [String(dragonrollLightId(light)), light]) + .filter(([lightId]) => lightId)); + const retained = new Set(); + + for (const entry of entries) { + let light = entry.foundryLightId ? findSceneDocument(scene, "AmbientLight", entry.foundryLightId) : null; + if (!light) light = localByRemoteId.get(String(entry._id)); + if (light) { + retained.add(light.id); + await applyDragonrollSceneLight(light, entry, mirror); + if (!entry.foundryLightId) await mapDragonrollSceneLight(mirror._id, entry._id, light.id); + } else if (entry.foundryLightId) { + // A light of another world's scene, or one the campaign read from a scene that is not this one: + // its own scene owns it, so cloning it here would light the room twice. + continue; + } else { + const created = await createSceneLightFromDragonroll(scene, entry, mirror); + if (created) retained.add(created.id); + } + } + + // A light the campaign put out is taken out of the world along with it — only one the world was + // told it wrote, never a lamp the GM lit themselves. + for (const light of sceneDocuments(scene, "AmbientLight")) { + const lightId = dragonrollLightId(light); + if (!lightId || retained.has(light.id) || wanted.has(String(lightId))) continue; + await withLightSyncSuppressed(light, () => light.delete()); + } + sceneLightingErrorLogged = false; + } catch (error) { + if (!sceneLightingErrorLogged) { + sceneLightingErrorLogged = true; + console.warn(`${MODULE_ID} | Scene lighting reconcile failed and will retry.`, error); + } + } finally { + sceneLightingRunning = false; + } +} + function getDragonrollImageUrl(image) { if (!image) return ""; if (/^(https?:|data:|\/\/)/i.test(image)) return image; @@ -1448,11 +1824,17 @@ Hooks.once("ready", () => { // already seen the world directory when it starts sending its own items back. setTimeout(reconcileDragonrollItems, 2000); setInterval(reconcileDragonrollItems, 5000); + // The scene being played is lit once its canvas is drawn: send what lights it, and write back the + // lights the campaign has placed on the map mirroring it. + queueSceneLightingChange(3000); + setInterval(reconcileDragonrollSceneLighting, 5000); for (const event of [ "createActor", "updateActor", "deleteActor", "createItem", "updateItem", "deleteItem", "createFolder", "updateFolder", "deleteFolder", + "createAmbientLight", "updateAmbientLight", "deleteAmbientLight", + "createWall", "updateWall", "deleteWall", ]) { Hooks.on(event, (document) => { scheduleSnapshotSync(); @@ -1462,6 +1844,13 @@ Hooks.once("ready", () => { queueFoundryActorChange(isDelete ? "delete" : "upsert", document); return; } + // A wall the GM draws or a lamp they move changes how the scene reads, so the whole of its + // lighting goes over. A light Dragonroll has just written into the scene is not the GM's doing. + if (document.documentName === "AmbientLight" || document.documentName === "Wall") { + if (isSceneLightingMutation(document)) return; + queueSceneLightingChange(); + return; + } // An item folder the GM made, renamed or nested changes the tree the campaign // mirrors; nothing about the items themselves changed, so only the tree goes. // A colour Dragonroll has just written into the folder is not the GM changing it. @@ -1483,6 +1872,15 @@ Hooks.once("ready", () => { } }); +// Moving to another scene changes which of the world's lighting the campaign mirrors: what lights the +// new scene is sent, and the lights the campaign placed on its map are written back into it. A canvas +// is not worth reading the moment it is initialised, so both are asked for a little later. +Hooks.on("canvasInit", () => { + if (!game.user?.isGM || !getSyncToken()) return; + queueSceneLightingChange(1200); + setTimeout(reconcileDragonrollSceneLighting, 1500); +}); + // A GM sends selected actors to Dragonroll from the actor directory's context // menu. This works with autosync on and off: it is the one push done on purpose. Hooks.on("getActorDirectoryEntryContext", (html, options) => { diff --git a/frontend/app/assets/css/colors.scss b/frontend/app/assets/css/colors.scss index b2df6627..82cf6a22 100644 --- a/frontend/app/assets/css/colors.scss +++ b/frontend/app/assets/css/colors.scss @@ -22,6 +22,11 @@ $themes: ( note-border: #202324, + // A map's lighting: the dark the lights are carved out of, and the walls that cut them. The map + // canvas reads both off these variables (see components/viewer/map/MapViewerPane.vue). + map-darkness: #000000d9, + map-wall: #e06c75, + hover: #21262d, selected: #4a4a4b, border-color: #819796, @@ -70,6 +75,11 @@ $themes: ( note-border: #e0e0e0, + // Same lighting keys as the dark map; the dark over a map is the dark of a room whichever theme + // the app is drawn in, and its walls are darkened to stay readable over a light image. + map-darkness: #000000d9, + map-wall: #c62828, + border-color: #e0e0e0, border: #f0f0f0, hover: #e9e9e9, diff --git a/frontend/app/components/viewer/map/MapViewerPane.vue b/frontend/app/components/viewer/map/MapViewerPane.vue index 6f9ed1e8..5ddf2cce 100644 --- a/frontend/app/components/viewer/map/MapViewerPane.vue +++ b/frontend/app/components/viewer/map/MapViewerPane.vue @@ -5,6 +5,7 @@ import { ClearWindow, CreateWindow, GetFirstWindowId } from '@/services/Windows' import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu'; import { BuildNoteOptions, OptionLabel, ToImagePoint, ToScreenPoint } from '~/services/MapPins'; import { ActorDragId, CellCentre, IsActorDrag, MoveByCells, TokenSize } from '~/services/MapTokens'; +import { CastLight, SnapToGridVertex, WallAt } from '~/services/MapLighting'; import { DisplayToast } from '~/services/Toaster'; import Server, { getBaseUrl } from '~/services/Server'; import { emitter } from '~/services/Emitter'; @@ -29,6 +30,15 @@ const zoom = ref(1); const pan = ref({ x: 0, y: 0 }); const imageSize = ref({ width: 0, height: 0 }); const showGrid = ref(true); +// Lighting over the map: the dark the lights are carved out of. Off by default, so a map reads as the +// picture it is until whoever is running the table asks for the dark. +const showLighting = ref(false); +// Drawing walls instead of panning the map: a wall is dragged from one corner of the grid to another. +const wallMode = ref(false); +// The wall being drawn — the corner it starts at and the one the pointer has reached. It is written +// once, when the pointer lets go, so drawing a wall is not one request per mouse move. +const drawingWall = ref(null); +let wallPointerId = null; const dragging = ref(false); const minZoom = 0.05; @@ -114,6 +124,8 @@ let lastPointer = { x: 0, y: 0 }; function onPointerDown(event) { if (event.button !== 0 || !viewport.value) return; + // The wall tool takes the pointer for itself: holding the map then draws a wall instead of moving it. + if (wallMode.value && startWallDrag(event)) return; dragging.value = true; pointerId = event.pointerId; lastPointer = { x: event.clientX, y: event.clientY }; @@ -121,12 +133,14 @@ function onPointerDown(event) { } function onPointerMove(event) { + if (moveWallDrag(event)) return; if (!dragging.value || event.pointerId !== pointerId) return; pan.value = { x: pan.value.x + (event.clientX - lastPointer.x), y: pan.value.y + (event.clientY - lastPointer.y) }; lastPointer = { x: event.clientX, y: event.clientY }; } -function onPointerUp(event) { +async function onPointerUp(event) { + if (await endWallDrag(event)) return; if (event.pointerId !== pointerId) return; dragging.value = false; pointerId = null; @@ -195,20 +209,37 @@ function onMapContextMenu(event) { const spot = ToImagePoint({ x: event.clientX - bounds.left, y: event.clientY - bounds.top }, viewState()); if (!spot) return; - if (!noteOptions.value.length) { - ShowContextMenu([{ name: t('campaigns.map.pins.none'), action: () => HideContextMenu() }]); - return; + const items = []; + if (!noteOptions.value.length) items.push({ name: t('campaigns.map.pins.none'), action: () => HideContextMenu() }); + else { + items.push({ + name: t('campaigns.map.pins.add'), + icon: '/icons/iconoir/regular/map-pin-plus.svg', + context: noteOptions.value.map((option) => ({ + name: option.label, + icon: '/icons/iconoir/regular/notes.svg', + action: () => { HideContextMenu(); savePin(option.value, spot); } + })) + }); } - ShowContextMenu([{ - name: t('campaigns.map.pins.add'), - icon: '/icons/iconoir/regular/map-pin-plus.svg', - context: noteOptions.value.map((option) => ({ - name: option.label, - icon: '/icons/iconoir/regular/notes.svg', - action: () => { HideContextMenu(); savePin(option.value, spot); } - })) - }]); + items.push({ divider: true }); + items.push({ + name: t('campaigns.map.lights.add'), + icon: '/icons/iconoir/regular/fire-flame.svg', + action: () => { HideContextMenu(); placeLight(spot); } + }); + // A wall is a line, not a marker to hold: right clicking along it is how it is taken off again. + const wall = WallAt(spot, walls.value, WALL_PICK_PX / Math.max(0.05, zoom.value)); + if (wall) { + items.push({ + name: t('campaigns.map.walls.remove'), + icon: '/icons/iconoir/regular/xmark-circle.svg', + action: () => { HideContextMenu(); removeWall(wall); } + }); + } + + ShowContextMenu(items); } function onPinContextMenu(pin) { @@ -503,6 +534,328 @@ function handleActorEntry({ entityType, entry }) { actors.value = [entry, ...actors.value.filter((current) => String(current._id) !== String(entry._id))]; } +// --- Lights, and the walls that stop them --- +// A light shines from one spot of the image and is as free to place as a pin. The walls of the map are +// what cuts its reach into a shadow: CastLight works out the shape a light paints and the canvas below +// paints that shape out of the dark laid over the map. + +// A new light covers this much of the map it is placed on, and half of that is bright light. +const LIGHT_CELLS = 3; +// How near a line a right click has to come to mean that wall, in screen pixels (it is divided by the +// zoom to become image pixels, so picking a wall is as easy zoomed out as zoomed in). +const WALL_PICK_PX = 10; + +const lightingCanvas = ref(null); +const lights = computed(() => map.value?.lights ?? []); +const walls = computed(() => map.value?.walls ?? []); +// The light a pointer is holding, and the spot it holds it at: like a token, the move stays local until +// the pointer lets go, so dragging a light across the map is one save and not one per mouse move. +const movingLight = ref(null); +let lightPointerId = null; + +// A colour from the theme the canvas paints with. The canvas cannot be styled with `var(--color-…)` +// like a stylesheet, so it asks the document for the same variable the stylesheets use. +function themeColor(name, fallback) { + if (typeof window === 'undefined' || typeof getComputedStyle !== 'function') return fallback; + return getComputedStyle(document.documentElement).getPropertyValue(name).trim() || fallback; +} + +// A hex colour with an alpha end ('#ffc46b' + '4d'), because a canvas gradient needs its stops spelled +// out. Anything that is not a plain hex colour is painted as it is. +function withAlpha(color, alpha) { + const value = String(color ?? '').trim(); + if (/^#[0-9a-f]{6}$/i.test(value)) return `${value}${alpha}`; + if (/^#[0-9a-f]{3}$/i.test(value)) return `#${value.slice(1)}${value.slice(1)}${alpha}`; + return value; +} + +// The light a marker is drawn for: the spot it is being held at while a pointer drags it, and its own +// spot otherwise. +function heldLight(light) { + if (movingLight.value && String(movingLight.value.light?._id) === String(light?._id)) return movingLight.value; + return { x: Number(light?.x) || 0, y: Number(light?.y) || 0 }; +} + +function lightStyle(light) { + const point = ToScreenPoint(heldLight(light), viewState()); + return { left: `${point.x}px`, top: `${point.y}px` }; +} + +// The reach a light is given when it is placed: enough of the map to matter at the grid it stands on. +function defaultLightReach() { + const cell = Math.max(1, Number(map.value?.gridSize) || 50); + const radius = Math.round(cell * LIGHT_CELLS); + return { radius, bright: Math.round(radius / 2) }; +} + +async function placeLight(spot) { + const reach = defaultLightReach(); + await updateMap('/map/place-light', { + id: map.value?._id, x: spot.x, y: spot.y, ...reach + }, t('campaigns.map.lights.error')); +} + +async function removeLight(light) { + await updateMap('/map/remove-light', { id: map.value?._id, light: light?._id }, t('campaigns.map.lights.error')); +} + +function onLightPointerDown(event, light) { + // Holding a light moves the light, never the map. + event.stopPropagation(); + if (event.button !== 0) return; + + lightPointerId = event.pointerId; + event.currentTarget.setPointerCapture?.(event.pointerId); + movingLight.value = { light: { ...light }, x: Number(light.x) || 0, y: Number(light.y) || 0 }; +} + +function onLightPointerMove(event) { + if (!movingLight.value || event.pointerId !== lightPointerId) return; + + const spot = imagePointOf(event); + // Dragged off the image, the light keeps its spot: a light is never lost over the edge. + if (!spot) return; + movingLight.value = { ...movingLight.value, x: spot.x, y: spot.y }; +} + +async function onLightPointerUp(event) { + if (!movingLight.value || event.pointerId !== lightPointerId) return; + + const { light, x, y } = movingLight.value; + lightPointerId = null; + movingLight.value = null; + event.currentTarget?.releasePointerCapture?.(event.pointerId); + + if (x === Number(light.x) && y === Number(light.y)) return; + await updateMap('/map/update-light', { id: map.value?._id, light: light._id, x, y }, t('campaigns.map.lights.error')); +} + +function onLightContextMenu(light) { + ShowContextMenu([{ + name: t('campaigns.map.lights.remove'), + icon: '/icons/iconoir/regular/xmark-circle.svg', + action: () => { HideContextMenu(); removeLight(light); } + }]); +} + +// Delete takes a focused light off the map, like it does a focused token. +async function onLightKeydown(event, light) { + if (event.key === 'Delete' || event.key === 'Backspace') { + event.preventDefault(); + await removeLight(light); + } +} + +// --- Drawing walls --- +// With the wall tool on, the pointer draws instead of panning: it is held down at one corner of the +// grid and let go at another, and the wall between those two corners is what gets saved. + +// Holds down the first corner of a wall, or says the wall tool has nothing to hold (off the image). +function startWallDrag(event) { + const spot = imagePointOf(event); + if (!spot) return false; + const corner = SnapToGridVertex(spot, grid.value); + if (!corner) return false; + + wallPointerId = event.pointerId; + viewport.value?.setPointerCapture?.(event.pointerId); + drawingWall.value = { x1: corner.x, y1: corner.y, x2: corner.x, y2: corner.y }; + return true; +} + +function moveWallDrag(event) { + if (!drawingWall.value || event.pointerId !== wallPointerId) return false; + + const spot = imagePointOf(event); + // Off the image the wall keeps the end it had: a wall cannot hang outside of the map. + if (!spot) return true; + const corner = SnapToGridVertex(spot, grid.value); + if (!corner) return true; + if (corner.x === drawingWall.value.x2 && corner.y === drawingWall.value.y2) return true; + drawingWall.value = { ...drawingWall.value, x2: corner.x, y2: corner.y }; + return true; +} + +async function endWallDrag(event) { + if (!drawingWall.value || event.pointerId !== wallPointerId) return false; + + const wall = drawingWall.value; + wallPointerId = null; + drawingWall.value = null; + viewport.value?.releasePointerCapture?.(event.pointerId); + + // Dragged out and back to the same corner is not a wall: it stops nothing and cannot be picked + // up again, so it is dropped where it was drawn. + if (wall.x1 === wall.x2 && wall.y1 === wall.y2) return true; + await saveWall(wall); + return true; +} + +async function saveWall(wall) { + await updateMap('/map/wall', { id: map.value?._id, ...wall }, t('campaigns.map.walls.error')); +} + +async function removeWall(wall) { + await updateMap('/map/remove-wall', { id: map.value?._id, wall: wall?._id }, t('campaigns.map.walls.error')); +} + +// --- Painting the lights --- +// One canvas over the map, drawn in screen pixels like the pins and the tokens, and repainted whenever +// the view or the map changes. With the lighting on it lays the dark over the image and erases the shape +// of every light out of it, so what is left dark is exactly what its walls hide. With the lighting off +// the same shapes are drawn as thin outlines, which is what makes reaching for a light's size possible +// while it is still being placed. + +function imageScreenRect() { + const origin = ToScreenPoint({ x: 0, y: 0 }, viewState()); + return { + x: origin.x, + y: origin.y, + width: imageSize.value.width * zoom.value, + height: imageSize.value.height * zoom.value + }; +} + +function tracePolygon(context, points, view) { + context.beginPath(); + points.forEach((point, index) => { + const screen = ToScreenPoint(point, view); + if (index) context.lineTo(screen.x, screen.y); + else context.moveTo(screen.x, screen.y); + }); + context.closePath(); +} + +function paintDarkness(context, image) { + const view = viewState(); + context.save(); + context.fillStyle = themeColor('--color-map-darkness', '#000000d9'); + context.fillRect(image.x, image.y, image.width, image.height); + + // The lights erase the dark they stand in: only how much a gradient is transparent matters here, so + // a light fades from fully lit at its middle to nothing at the end of its reach. + context.globalCompositeOperation = 'destination-out'; + for (const light of lights.value) { + const shape = CastLight(light, walls.value); + if (!shape.length) continue; + const centre = ToScreenPoint(heldLight(light), view); + const reach = Math.max(1, (Number(light.radius) || 0) * zoom.value); + const core = Math.max(0, Math.min(1, (Number(light.bright) || 0) / (Number(light.radius) || 1))); + + context.save(); + tracePolygon(context, shape, view); + context.clip(); + const gradient = context.createRadialGradient(centre.x, centre.y, 0, centre.x, centre.y, reach); + gradient.addColorStop(0, '#000000ff'); + gradient.addColorStop(core, '#000000f5'); + gradient.addColorStop(1, '#00000000'); + context.fillStyle = gradient; + context.fillRect(image.x, image.y, image.width, image.height); + context.restore(); + } + + // The tint of a coloured light, laid back over the light it colours: a lantern reads warm and a + // spell cold, and a light with no colour of its own leaves the map as it is. + context.globalCompositeOperation = 'source-over'; + for (const light of lights.value) { + if (!light.color) continue; + const shape = CastLight(light, walls.value); + if (!shape.length) continue; + const centre = ToScreenPoint(heldLight(light), view); + const reach = Math.max(1, (Number(light.radius) || 0) * zoom.value); + + context.save(); + tracePolygon(context, shape, view); + context.clip(); + const gradient = context.createRadialGradient(centre.x, centre.y, 0, centre.x, centre.y, reach); + gradient.addColorStop(0, withAlpha(light.color, '33')); + gradient.addColorStop(1, withAlpha(light.color, '00')); + context.fillStyle = gradient; + context.fillRect(image.x, image.y, image.width, image.height); + context.restore(); + } + context.restore(); +} + +function paintLightOutlines(context) { + const view = viewState(); + context.save(); + context.lineWidth = 1; + for (const light of lights.value) { + const shape = CastLight(light, walls.value); + if (!shape.length) continue; + tracePolygon(context, shape, view); + context.strokeStyle = withAlpha(light.color || '#ffffff', '59'); + context.stroke(); + } + context.restore(); +} + +function paintWalls(context) { + if (!walls.value.length && !drawingWall.value) return; + const view = viewState(); + context.save(); + context.lineCap = 'round'; + context.strokeStyle = themeColor('--color-map-wall', '#e06c75'); + // The wall tool asks for a firmer line: it is the tool that has to see what it has drawn already. + context.lineWidth = wallMode.value ? 3 : 2; + for (const wall of walls.value) { + const from = ToScreenPoint({ x: Number(wall.x1) || 0, y: Number(wall.y1) || 0 }, view); + const to = ToScreenPoint({ x: Number(wall.x2) || 0, y: Number(wall.y2) || 0 }, view); + context.beginPath(); + context.moveTo(from.x, from.y); + context.lineTo(to.x, to.y); + context.stroke(); + } + // The wall being drawn, along the grid corners the pointer has reached so far. + if (drawingWall.value) { + context.setLineDash([6, 4]); + const from = ToScreenPoint({ x: drawingWall.value.x1, y: drawingWall.value.y1 }, view); + const to = ToScreenPoint({ x: drawingWall.value.x2, y: drawingWall.value.y2 }, view); + context.beginPath(); + context.moveTo(from.x, from.y); + context.lineTo(to.x, to.y); + context.stroke(); + } + context.restore(); +} + +function drawLighting() { + const canvas = lightingCanvas.value; + const bounds = viewport.value?.getBoundingClientRect(); + if (!canvas || !bounds) return; + + const width = Math.max(1, Math.round(bounds.width)); + const height = Math.max(1, Math.round(bounds.height)); + if (canvas.width !== width) canvas.width = width; + if (canvas.height !== height) canvas.height = height; + + const context = canvas.getContext?.('2d'); + if (!context) return; + context.clearRect(0, 0, width, height); + if (!imageUrl.value) return; + + if (showLighting.value) paintDarkness(context, imageScreenRect()); + else paintLightOutlines(context); + paintWalls(context); +} + +// Every move of the view, and every light or wall that changes, is painted again. +watch( + [zoom, pan, imageSize, showLighting, wallMode, drawingWall, lights, walls, imageUrl], + () => nextTick(drawLighting), + { deep: true } +); + +onMounted(() => { + window.addEventListener('resize', drawLighting); + nextTick(drawLighting); +}); + +onBeforeUnmount(() => { + window.removeEventListener('resize', drawLighting); +}); + // A different map was anchored while this pane was already mounted. watch(() => props.map, (incoming, previous) => { if (incoming === previous) return; @@ -510,6 +863,9 @@ watch(() => props.map, (incoming, previous) => { imageSize.value = { width: 0, height: 0 }; movingToken.value = null; draggingActor.value = false; + movingLight.value = null; + drawingWall.value = null; + wallPointerId = null; }); watch(campaignId, () => { @@ -550,6 +906,14 @@ onBeforeUnmount(() => { :aria-label="$t('campaigns.map.toggle-grid')" :aria-pressed="showGrid.toString()" @click="showGrid = !showGrid"> + + @@ -573,7 +937,7 @@ onBeforeUnmount(() => {