1 Commits

Author SHA1 Message Date
Gitea OpenCode Agent
8510a93027 Fix issue #101: Add lights to maps
All checks were successful
Test / test (push) Successful in 2s
2026-10-16 01:59:57 +00:00
18 changed files with 1455 additions and 1462 deletions

View File

@@ -27,18 +27,31 @@ const MapSchema = new Schema({
x: { type: Number, default: 0 }, x: { type: Number, default: 0 },
y: { type: Number, default: 0 } y: { type: Number, default: 0 }
}], }],
// Segments that block the map like walls. The endpoints are image pixels from the top left corner // Lights placed on the map. x/y are image pixels like a pin — a light is not tied to a cell — and
// of the image, like a pin — and the very space Foundry draws a scene's walls in, so a paired // `radius` is how far it reaches in image pixels, of which `bright` is the part that is bright
// scene and map trade them as they stand. `move`/`sight` say what passes through the segment, and // light and the rest dim light. The walls below are what stops one, see the viewer's
// `door` is 0 (not a door), 1 (open) or 2 (closed), following Foundry's own wall values. // 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: [{ walls: [{
x1: { type: Number, default: 0 }, x1: { type: Number, default: 0 },
y1: { type: Number, default: 0 }, y1: { type: Number, default: 0 },
x2: { type: Number, default: 0 }, x2: { type: Number, default: 0 },
y2: { type: Number, default: 0 }, y2: { type: Number, default: 0 },
move: { type: Boolean, default: true }, // The Foundry Wall document this segment came from, when the world sent it. The world owns its
sight: { type: Boolean, default: true }, // walls, so a synced one is drawn back over by the next push of that scene.
door: { type: Number, min: 0, max: 2, default: 0 } foundryWallId: { type: String, default: '' }
}], }],
campaign: { campaign: {
type: Schema.Types.ObjectId, type: Schema.Types.ObjectId,
@@ -52,16 +65,10 @@ const MapSchema = new Schema({
ref: 'Folder', ref: 'Folder',
default: null default: null
}, },
// The Foundry scene whose walls this map mirrors once the linked world has paired them (see // The Foundry scene whose lights and walls this map mirrors (see routes/foundry-link.js). Empty for
// routes/foundry-link.js): the whole wall set of one is the whole wall set of the other. // a map the campaign made for itself, which is the one kind of light a world never hears about.
foundrySceneId: { type: String }, foundrySceneId: { type: String, default: '' },
date: { type: Date, default: Date.now } date: { type: Date, default: Date.now }
}); });
// A scene walls one map of a campaign at most, like a Foundry actor one actor row.
MapSchema.index(
{ campaign: 1, foundrySceneId: 1 },
{ unique: true, partialFilterExpression: { foundrySceneId: { $type: 'string' } } }
);
module.exports = mongoose.model('Map', MapSchema); module.exports = mongoose.model('Map', MapSchema);

View File

@@ -7,7 +7,8 @@ const Campaign = require('../models/Campaign');
const Actor = require('../models/Actor'); const Actor = require('../models/Actor');
const Item = require('../models/Item'); const Item = require('../models/Item');
const Folder = require('../models/Folder'); const Folder = require('../models/Folder');
// `MapModel`, not `Map`: this file uses the built-in `Map` for the item folder maps. // 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 MapModel = require('../models/Map');
const { foundryActorToCharacter } = require('../services/actor-foundry'); const { foundryActorToCharacter } = require('../services/actor-foundry');
const { foundryItemToItemData } = require('../services/item-foundry'); const { foundryItemToItemData } = require('../services/item-foundry');
@@ -270,6 +271,187 @@ function resolveFoundryItemFolder(source, folders) {
return folders.get(foundryFolderId.trim())?._id || null; 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 // 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 // uses (routes/service-link.js); what stays here is the sync that world keeps up
@@ -479,97 +661,76 @@ router.post('/sync/map-item', async (req, res) => {
} }
}); });
// --- Scene walls ----------------------------------------------------------- // The lighting of one of the world's scenes: its ambient lights and the walls that stop them, sent
// A campaign map can mirror the walls of a Foundry scene: the whole set travels whoever edits // whole so the campaign's map of that scene reads like the ground the players are standing on.
// it, so the map's editor and the scene's wall tool see the same segments. A map is paired with router.post('/sync/scene', async (req, res) => {
// a scene by name while the module reconciles its campaign — the way an unmapped item maps to
// the world document it shares its name with — and `POST /sync/map-scene` records that pairing.
// The endpoints are image pixels of the scene's background there too, so a segment crosses
// unchanged; `door` follows Foundry's own wall values (1 open, 2 closed), and locked doors
// arrive closed.
// Same shape the campaign's own `/map/walls` saves by: finite endpoints or nothing, whole pixels
// that never go off the top left corner, no segment without length.
function toSyncedWall(source) {
const corners = [source?.x1, source?.y1, source?.x2, source?.y2];
if (!corners.every((value) => Number.isFinite(Number(value)))) return null;
const toPixel = (value) => Math.max(0, Math.round(Number(value)));
const wall = {
x1: toPixel(source.x1),
y1: toPixel(source.y1),
x2: toPixel(source.x2),
y2: toPixel(source.y2),
move: source.move !== false,
sight: source.sight !== false,
door: [1, 2].includes(Math.round(Number(source.door))) ? Math.round(Number(source.door)) : 0
};
return wall.x1 === wall.x2 && wall.y1 === wall.y2 ? null : wall;
}
// The maps the module pairs scenes with and reconciles walls against: what a wall set needs to
// land on a scene, and nothing the module has no use for.
router.get('/sync/maps', async (req, res) => {
try { try {
const campaign = await syncCampaign(req, res); const campaign = await syncCampaign(req, res);
if (!campaign) return; if (!campaign) return;
const maps = await MapModel.find({ campaign: campaign._id }) const scene = readSceneSource(req.body.scene);
.select('_id name image foundrySceneId walls') const lights = Array.isArray(req.body.lights) ? req.body.lights : null;
.sort({ name: 1 }) const walls = Array.isArray(req.body.walls) ? req.body.walls : null;
.lean(); if (!requestMatchesWorld(campaign, req.body.worldId) || !scene || (!lights && !walls)) {
res.json({ status: 'ok', maps }); 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) { } catch (err) {
console.error(err); console.error(err);
res.json({ status: 'error', msg: 'errors.internal' }); res.json({ status: 'error', msg: 'errors.internal' });
} }
}); });
router.post('/sync/map-scene', async (req, res) => { // 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 { try {
const campaign = await syncCampaign(req, res); const campaign = await syncCampaign(req, res);
if (!campaign) return; if (!campaign) return;
const { mapId, foundrySceneId, worldId } = req.body; const maps = await MapModel.find({ campaign: campaign._id }).sort({ name: 1 }).lean();
if (!requestMatchesWorld(campaign, worldId) || !mapId || !foundrySceneId) { res.json({ status: 'ok', scenes: sceneLightingList(maps) });
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const map = await MapModel.findOne({ _id: mapId, campaign: campaign._id });
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
const existing = await MapModel.findOne({
campaign: campaign._id,
foundrySceneId: String(foundrySceneId).trim(),
_id: { $ne: map._id }
});
if (existing) return res.json({ status: 'error', msg: 'foundry.errors.scene-already-synced' });
map.foundrySceneId = String(foundrySceneId).trim().slice(0, 120);
await map.save();
res.json({ status: 'ok', map });
} catch (err) { } catch (err) {
console.error(err); console.error(err);
res.json({ status: 'error', msg: 'errors.internal' }); res.json({ status: 'error', msg: 'errors.internal' });
} }
}); });
// A scene's whole wall set, as the module draws it: the paired map takes it over, like the // A light the campaign placed and the world has taken on: the AmbientLight document standing for it, so
// world's item folders take over the campaign's tree. A scene the campaign has no map paired // the next write of that light knows which document to move instead of adding a second one.
// with answers `notfound` — most scenes are none of the campaign's business. router.post('/sync/map-scene-light', async (req, res) => {
router.post('/sync/map-walls', async (req, res) => {
try { try {
const campaign = await syncCampaign(req, res); const campaign = await syncCampaign(req, res);
if (!campaign) return; if (!campaign) return;
const { foundrySceneId, walls, worldId } = req.body; const { map, light, foundryLightId, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !foundrySceneId || !Array.isArray(walls)) { if (!requestMatchesWorld(campaign, worldId) || !map || !light || !foundryLightId) {
return res.json({ status: 'error', msg: 'errors.missing-data' }); return res.json({ status: 'error', msg: 'errors.missing-data' });
} }
const map = await MapModel.findOne({ campaign: campaign._id, foundrySceneId: String(foundrySceneId).trim() }); const mapDoc = await MapModel.findOne({ _id: map, campaign: campaign._id });
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' }); 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' });
map.walls = walls.map(toSyncedWall).filter(Boolean); entry.foundryLightId = String(foundryLightId).trim().slice(0, 120);
await map.save(); await mapDoc.save();
res.json({ status: 'ok', map: { _id: map.id } }); res.json({ status: 'ok', light: { _id: entry._id, foundryLightId: entry.foundryLightId } });
} catch (err) { } catch (err) {
console.error(err); console.error(err);
res.json({ status: 'error', msg: 'errors.internal' }); res.json({ status: 'error', msg: 'errors.internal' });

View File

@@ -238,44 +238,199 @@ router.post('/remove-token', async (req, res) => {
} }
}); });
// A wall is a segment of the map that blocks it like one does. The editor saves the whole set at // --- Lights ---
// once — drawing, moving, re-typing and taking off segments are all the same request — and a paired // 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
// Foundry scene takes that set whole too, so the set is the contract on both sides. Endpoints are // lands wherever it is placed. Its reach is measured in image pixels too, so it covers the same ground
// image pixels like a pin's, and a wall keeps the `_id` it is sent with when one of the current // whatever the zoom is, and it is that reach the viewer cuts its shadow against the walls below with.
// walls has it, so the markers on screen do not jump through a save. A segment with no length is
// dropped: it is a click that was not meant to draw anything.
function toStoredWall(source, currentWalls) {
const corners = [source?.x1, source?.y1, source?.x2, source?.y2];
if (!corners.every((value) => Number.isFinite(Number(value)))) return null;
const wall = { // How far a light of the map reaches when nothing is asked for: about three cells of the default grid.
x1: toCoordinate(source.x1), const DEFAULT_LIGHT_RADIUS = 150;
y1: toCoordinate(source.y1),
x2: toCoordinate(source.x2),
y2: toCoordinate(source.y2),
// What the editor draws is a wall, not an opening: both stay out unless it says otherwise.
move: source.move !== false,
sight: source.sight !== false,
door: [1, 2].includes(Math.round(Number(source.door))) ? Math.round(Number(source.door)) : 0
};
if (wall.x1 === wall.x2 && wall.y1 === wall.y2) return null;
const id = String(source?._id ?? '').trim(); function toReach(value, fallback) {
if (id && currentWalls.some((current) => String(current?._id) === id)) wall._id = id; const number = Number(value);
return wall; if (!Number.isFinite(number) || number <= 0) return fallback;
return Math.max(1, Math.round(number));
} }
router.post('/walls', async (req, res) => { // 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 { try {
const { id, walls } = req.body; const { id, x, y, radius, bright, color } = req.body;
if (!id || !Array.isArray(walls)) return res.json({ status: 'error', msg: 'errors.missing-data' }); if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' });
const map = await Map.findById(id); const map = await Map.findById(id);
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' }); 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' }); if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' });
const currentWalls = Array.from(map.walls ?? []); const reach = toReach(radius, DEFAULT_LIGHT_RADIUS);
map.walls = walls.map((source) => toStoredWall(source, currentWalls)).filter(Boolean); 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(); await map.save();
res.json({ status: 'ok', map }); res.json({ status: 'ok', map });
} catch (err) { } catch (err) {

View File

@@ -36,11 +36,12 @@ let folderSyncRunning = false;
const syncingItemIds = new Set(); const syncingItemIds = new Set();
const syncingFolderIds = new Set(); const syncingFolderIds = new Set();
const queuedItemChanges = new Map(); const queuedItemChanges = new Map();
let wallSyncTimeout; // The lighting of the scene being played: queued while the GM drags walls about, and written back into
let mapSyncRunning = false; // the world from the campaign on a timer.
let mapSyncErrorLogged = false; let sceneLightingTimeout;
const queuedWallSceneIds = new Set(); let sceneLightingRunning = false;
const applyingWallsSceneIds = new Set(); let sceneLightingErrorLogged = false;
const syncingLightIds = new Set();
function getCollectionContents(collection, collectionName) { function getCollectionContents(collection, collectionName) {
if (!collection) { if (!collection) {
@@ -305,7 +306,6 @@ async function applyDragonrollLink(result) {
scheduleSnapshotSync(0); scheduleSnapshotSync(0);
setTimeout(initializeCharacterSync, 0); setTimeout(initializeCharacterSync, 0);
setTimeout(reconcileDragonrollItems, 2000); setTimeout(reconcileDragonrollItems, 2000);
setTimeout(reconcileDragonrollMaps, 2500);
} else { } else {
// Without a token this client cannot sync, and only a fresh link gives one. // Without a token this client cannot sync, and only a fresh link gives one.
linkProblem = "this client could not save the token it was given"; linkProblem = "this client could not save the token it was given";
@@ -447,7 +447,7 @@ function handleAutoSyncChange(value) {
clearTimeout(actorSyncTimeout); clearTimeout(actorSyncTimeout);
clearTimeout(itemSyncTimeout); clearTimeout(itemSyncTimeout);
clearTimeout(folderSyncTimeout); clearTimeout(folderSyncTimeout);
clearTimeout(wallSyncTimeout); clearTimeout(sceneLightingTimeout);
return; return;
} }
if (!game.user?.isGM || !getSyncToken()) return; if (!game.user?.isGM || !getSyncToken()) return;
@@ -457,7 +457,10 @@ function handleAutoSyncChange(value) {
initializeCharacterSync(); initializeCharacterSync();
reconcileDragonrollItems(); reconcileDragonrollItems();
queueFoundryItemFolders(400); queueFoundryItemFolders(400);
reconcileDragonrollMaps(); // 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) { if (queuedActorChanges.size) {
clearTimeout(actorSyncTimeout); clearTimeout(actorSyncTimeout);
actorSyncTimeout = setTimeout(flushActorChanges, 400); actorSyncTimeout = setTimeout(flushActorChanges, 400);
@@ -466,10 +469,6 @@ function handleAutoSyncChange(value) {
clearTimeout(itemSyncTimeout); clearTimeout(itemSyncTimeout);
itemSyncTimeout = setTimeout(flushItemChanges, 400); itemSyncTimeout = setTimeout(flushItemChanges, 400);
} }
if (queuedWallSceneIds.size) {
clearTimeout(wallSyncTimeout);
wallSyncTimeout = setTimeout(flushFoundrySceneWalls, 400);
}
} }
function dragonrollActorId(actor) { function dragonrollActorId(actor) {
@@ -930,239 +929,6 @@ async function flushItemChanges() {
} }
} }
// --- Scene walls -----------------------------------------------------------
// A campaign map can mirror the walls of a Foundry scene: the whole set travels to whoever did
// not edit it, so the map's wall editor and the scene's wall tool see the same segments. The
// endpoints are image pixels of the scene's background there too, so a segment crosses unchanged.
// Walls need no D&D 5e — they are plain scene geometry — and unlike actors and items, a scene is
// never made or deleted here: only its walls are read and written.
// Wall endpoints are whole image pixels on either side, rounded the same way before a set is
// compared, written or sent, so a set that only differs in Foundry's float precision is still
// recognised as unchanged and no write is made for it.
function toWallPixel(value) {
return Math.max(0, Math.round(Number(value) || 0));
}
function toWallDoor(value) {
const door = Number(value) || 0;
return door === 1 || door === 2 ? door : 0;
}
// A Foundry wall in the campaign's shape: `sense` blocks sight, `move` passage, and a door is
// open or closed by its state (`ds`) — Foundry's locked doors read as closed.
function campaignWallFromFoundry(wall) {
const c = Array.from(wall?.c ?? []);
return {
x1: toWallPixel(c[0]),
y1: toWallPixel(c[1]),
x2: toWallPixel(c[2]),
y2: toWallPixel(c[3]),
move: (Number(wall?.move) || 0) !== 0,
sight: (Number(wall?.sense) || 0) !== 0,
door: Number(wall?.door) > 0 ? (Number(wall?.ds) === 1 ? 1 : 2) : 0,
};
}
function campaignWallFromSync(wall) {
return {
x1: toWallPixel(wall?.x1),
y1: toWallPixel(wall?.y1),
x2: toWallPixel(wall?.x2),
y2: toWallPixel(wall?.y2),
move: wall?.move !== false,
sight: wall?.sight !== false,
door: toWallDoor(wall?.door),
};
}
// A campaign wall in Foundry's own shape: blocking sight is its opaque wall (light and sense
// alike, the way the wall tool sets them), blocking movement its impassable one, and a door
// carries the open/closed state it has.
function foundryWallData(wall) {
const sight = wall?.sight !== false;
const door = toWallDoor(wall?.door);
return {
c: [
toWallPixel(wall?.x1),
toWallPixel(wall?.y1),
toWallPixel(wall?.x2),
toWallPixel(wall?.y2),
],
light: sight ? 2 : 0,
sense: sight ? 2 : 0,
move: wall?.move === false ? 0 : 1,
door,
ds: door === 1 ? 1 : 0,
};
}
// Whether the scene already stands with the campaign's set, both read in the campaign's shape.
function wallsMatch(localWalls, remoteWalls) {
if (localWalls.length !== remoteWalls.length) return false;
return remoteWalls.every((entry, index) => {
const wanted = campaignWallFromSync(entry);
const local = localWalls[index];
return ["x1", "y1", "x2", "y2", "move", "sight", "door"].every((key) => local?.[key] === wanted[key]);
});
}
function wallDocumentsOf(scene) {
return (scene?.wallDocuments?.contents || scene?.walls?.contents || []).slice();
}
function sceneWallSnapshots(scene) {
return wallDocumentsOf(scene).map(campaignWallFromFoundry);
}
function reportMapSyncError(error) {
if (mapSyncErrorLogged) return;
mapSyncErrorLogged = true;
console.warn(`${MODULE_ID} | Map sync failed and will retry.`, error);
}
// The scene a wall hook is about: Foundry v11 hands the Wall document and older versions the
// Scene, and both are taken for one.
function wallSceneFromHook(...hookArgs) {
for (const argument of hookArgs) {
if (argument?.documentName === "Scene") return argument;
if (argument?.documentName === "Wall") return argument.parent ?? null;
}
return null;
}
function queueFoundrySceneWalls(...hookArgs) {
const scene = wallSceneFromHook(...hookArgs);
if (!scene || !game.user?.isGM || !game.world || !getSyncToken()) return;
// Walls Dragonroll itself just wrote into the scene are not the GM editing them.
if (applyingWallsSceneIds.has(scene.id)) return;
queuedWallSceneIds.add(scene.id);
clearTimeout(wallSyncTimeout);
wallSyncTimeout = setTimeout(flushFoundrySceneWalls, 400);
}
async function flushFoundrySceneWalls() {
// Autosync off: the queued wall sets wait, like the item edits do.
if (!isAutoSyncEnabled()) return;
const sceneIds = [...queuedWallSceneIds];
queuedWallSceneIds.clear();
for (const sceneId of sceneIds) {
const scene = game.scenes?.get(sceneId);
if (!scene) continue;
try {
await pushFoundrySceneWalls(scene);
mapSyncErrorLogged = false;
} catch (error) {
// A scene no campaign map mirrors is the normal case — most of a world's scenes are
// none of the campaign's business — so it is not a failure worth retrying.
if (error.message === "errors.notfound") continue;
reportMapSyncError(error);
queuedWallSceneIds.add(sceneId);
}
}
if (queuedWallSceneIds.size) {
clearTimeout(wallSyncTimeout);
wallSyncTimeout = setTimeout(flushFoundrySceneWalls, 5000);
}
}
async function pushFoundrySceneWalls(scene) {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || !scene) return;
await postDragonroll("foundry/sync/map-walls", {
worldId: game.world.id,
foundrySceneId: scene.id,
walls: sceneWallSnapshots(scene),
}, token);
}
// The campaign's walls reconciled onto its maps: paired with a scene by name where they are not
// paired yet, and every paired scene brought to the campaign's set. Live wall edits in the scene
// run the other way — they push the scene's set to the campaign as they happen.
async function reconcileDragonrollMaps() {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || mapSyncRunning || !isAutoSyncEnabled()) return;
mapSyncRunning = true;
try {
const result = await getDragonroll("foundry/sync/maps", token);
const remoteMaps = result.maps || [];
const pairedSceneIds = new Set(remoteMaps.map((entry) => entry.foundrySceneId).filter(Boolean));
for (const entry of remoteMaps) {
let scene = entry.foundrySceneId ? game.scenes?.get(entry.foundrySceneId) : null;
if (!scene) {
// Pair by name, the way an unmapped item maps to the world document that shares its
// name — but only when map and scene are each other's only one with it: writing the
// walls into the wrong scene is not a mistake to make on an ambiguous name. A map
// whose paired scene is gone (deleted, or a copied world) is paired anew the same way.
const namesakes = (game.scenes?.contents || [])
.filter((candidate) => !pairedSceneIds.has(candidate.id)
&& candidate.name === String(entry.name).trim());
scene = namesakes.length === 1 ? namesakes[0] : null;
if (scene) {
pairedSceneIds.add(scene.id);
await postDragonroll("foundry/sync/map-scene", {
worldId: game.world.id,
mapId: String(entry._id),
foundrySceneId: scene.id,
}, token);
}
}
if (!scene) continue;
const localWalls = sceneWallSnapshots(scene);
const campaignWalls = Array.isArray(entry.walls) ? entry.walls : [];
// A map with no walls of its own adopts the walls the scene already has: they are the
// GM's work, and writing an empty set over them would undo it before the campaign's
// editor ever opened. Once both sides hold walls, the campaign's set rules the scene.
if (!campaignWalls.length && localWalls.length) {
await pushFoundrySceneWalls(scene);
continue;
}
await applyDragonrollWalls(scene, campaignWalls, localWalls);
}
mapSyncErrorLogged = false;
} catch (error) {
reportMapSyncError(error);
} finally {
mapSyncRunning = false;
}
}
// The campaign's whole set lands on the scene: segments are updated in place while a wall
// document exists for them, ones beyond the documents are made, and ones the campaign let go of
// are deleted. Marked as Dragonroll's own write while it runs, so the scene's wall hooks do not
// push the set straight back to the campaign.
async function applyDragonrollWalls(scene, walls, current = sceneWallSnapshots(scene)) {
if (wallsMatch(current, walls)) return;
const documents = wallDocumentsOf(scene);
const updates = [];
const creates = [];
for (const [index, wall] of walls.entries()) {
// A document that already stands where the campaign wants it is left alone; one index
// over the documents is made, and the ones the campaign let go of are deleted.
if (documents[index]) {
if (wallsMatch([campaignWallFromFoundry(documents[index])], [wall])) continue;
updates.push({ _id: documents[index].id, ...foundryWallData(wall) });
} else {
creates.push(foundryWallData(wall));
}
}
const deleteIds = documents.slice(walls.length).map((document) => document.id);
applyingWallsSceneIds.add(scene.id);
try {
if (updates.length) await scene.updateEmbeddedDocuments("Wall", updates);
if (creates.length) await scene.createEmbeddedDocuments("Wall", creates);
if (deleteIds.length) await scene.deleteEmbeddedDocuments("Wall", deleteIds);
} finally {
applyingWallsSceneIds.delete(scene.id);
}
}
const CATEGORY_TO_FOUNDRY_ITEM_TYPE = { const CATEGORY_TO_FOUNDRY_ITEM_TYPE = {
weapon: "weapon", weapon: "weapon",
armor: "equipment", armor: "equipment",
@@ -1306,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) { function getDragonrollImageUrl(image) {
if (!image) return ""; if (!image) return "";
if (/^(https?:|data:|\/\/)/i.test(image)) return image; if (/^(https?:|data:|\/\/)/i.test(image)) return image;
@@ -1693,13 +1824,17 @@ Hooks.once("ready", () => {
// already seen the world directory when it starts sending its own items back. // already seen the world directory when it starts sending its own items back.
setTimeout(reconcileDragonrollItems, 2000); setTimeout(reconcileDragonrollItems, 2000);
setInterval(reconcileDragonrollItems, 5000); setInterval(reconcileDragonrollItems, 5000);
setTimeout(reconcileDragonrollMaps, 2500); // The scene being played is lit once its canvas is drawn: send what lights it, and write back the
setInterval(reconcileDragonrollMaps, 5000); // lights the campaign has placed on the map mirroring it.
queueSceneLightingChange(3000);
setInterval(reconcileDragonrollSceneLighting, 5000);
for (const event of [ for (const event of [
"createActor", "updateActor", "deleteActor", "createActor", "updateActor", "deleteActor",
"createItem", "updateItem", "deleteItem", "createItem", "updateItem", "deleteItem",
"createFolder", "updateFolder", "deleteFolder", "createFolder", "updateFolder", "deleteFolder",
"createAmbientLight", "updateAmbientLight", "deleteAmbientLight",
"createWall", "updateWall", "deleteWall",
]) { ]) {
Hooks.on(event, (document) => { Hooks.on(event, (document) => {
scheduleSnapshotSync(); scheduleSnapshotSync();
@@ -1709,6 +1844,13 @@ Hooks.once("ready", () => {
queueFoundryActorChange(isDelete ? "delete" : "upsert", document); queueFoundryActorChange(isDelete ? "delete" : "upsert", document);
return; 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 // 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. // 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. // A colour Dragonroll has just written into the folder is not the GM changing it.
@@ -1728,13 +1870,15 @@ Hooks.once("ready", () => {
queueFoundryItemChange(isDelete ? "delete" : "upsert", document); queueFoundryItemChange(isDelete ? "delete" : "upsert", document);
}); });
} }
});
// A GM's wall edit sends the scene's whole set to the campaign map mirroring it, // Moving to another scene changes which of the world's lighting the campaign mirrors: what lights the
// debounced like the item changes: dragging a wall fires an update per move. // new scene is sent, and the lights the campaign placed on its map are written back into it. A canvas
// Scenes no campaign map mirrors answer `notfound`, and the queue lets those go. // is not worth reading the moment it is initialised, so both are asked for a little later.
for (const event of ["createWall", "updateWall", "deleteWall"]) { Hooks.on("canvasInit", () => {
Hooks.on(event, (...args) => queueFoundrySceneWalls(...args)); if (!game.user?.isGM || !getSyncToken()) return;
} queueSceneLightingChange(1200);
setTimeout(reconcileDragonrollSceneLighting, 1500);
}); });
// A GM sends selected actors to Dragonroll from the actor directory's context // A GM sends selected actors to Dragonroll from the actor directory's context

View File

@@ -22,6 +22,11 @@ $themes: (
note-border: #202324, 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, hover: #21262d,
selected: #4a4a4b, selected: #4a4a4b,
border-color: #819796, border-color: #819796,
@@ -70,6 +75,11 @@ $themes: (
note-border: #e0e0e0, 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-color: #e0e0e0,
border: #f0f0f0, border: #f0f0f0,
hover: #e9e9e9, hover: #e9e9e9,

View File

@@ -5,7 +5,7 @@ import { ClearWindow, CreateWindow, GetFirstWindowId } from '@/services/Windows'
import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu'; import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu';
import { BuildNoteOptions, OptionLabel, ToImagePoint, ToScreenPoint } from '~/services/MapPins'; import { BuildNoteOptions, OptionLabel, ToImagePoint, ToScreenPoint } from '~/services/MapPins';
import { ActorDragId, CellCentre, IsActorDrag, MoveByCells, TokenSize } from '~/services/MapTokens'; import { ActorDragId, CellCentre, IsActorDrag, MoveByCells, TokenSize } from '~/services/MapTokens';
import { IsWall, MoveWall, SnapToGrid, ToDrawPoint, ToScreenWall } from '~/services/MapWalls'; import { CastLight, SnapToGridVertex, WallAt } from '~/services/MapLighting';
import { DisplayToast } from '~/services/Toaster'; import { DisplayToast } from '~/services/Toaster';
import Server, { getBaseUrl } from '~/services/Server'; import Server, { getBaseUrl } from '~/services/Server';
import { emitter } from '~/services/Emitter'; import { emitter } from '~/services/Emitter';
@@ -30,6 +30,15 @@ const zoom = ref(1);
const pan = ref({ x: 0, y: 0 }); const pan = ref({ x: 0, y: 0 });
const imageSize = ref({ width: 0, height: 0 }); const imageSize = ref({ width: 0, height: 0 });
const showGrid = ref(true); 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 dragging = ref(false);
const minZoom = 0.05; const minZoom = 0.05;
@@ -115,18 +124,8 @@ let lastPointer = { x: 0, y: 0 };
function onPointerDown(event) { function onPointerDown(event) {
if (event.button !== 0 || !viewport.value) return; if (event.button !== 0 || !viewport.value) return;
if (editingWalls.value && imageUrl.value) { // The wall tool takes the pointer for itself: holding the map then draws a wall instead of moving it.
// While the wall editor is open the left pointer draws instead of panning: the wheel and if (wallMode.value && startWallDrag(event)) return;
// the zoom buttons still move the view about.
const spot = wallSpot(event);
const first = spot && SnapToGrid(spot, grid.value);
if (!first) return;
pointerId = event.pointerId;
viewport.value.setPointerCapture?.(event.pointerId);
drawingWall.value = { x1: first.x, y1: first.y, x2: first.x, y2: first.y };
selectedWall.value = null;
return;
}
dragging.value = true; dragging.value = true;
pointerId = event.pointerId; pointerId = event.pointerId;
lastPointer = { x: event.clientX, y: event.clientY }; lastPointer = { x: event.clientX, y: event.clientY };
@@ -134,28 +133,15 @@ function onPointerDown(event) {
} }
function onPointerMove(event) { function onPointerMove(event) {
if (drawingWall.value && event.pointerId === pointerId) { if (moveWallDrag(event)) return;
const spot = wallSpot(event);
const snapped = spot && SnapToGrid(spot, grid.value);
if (snapped) drawingWall.value = { ...drawingWall.value, x2: snapped.x, y2: snapped.y };
return;
}
if (!dragging.value || event.pointerId !== pointerId) 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) }; 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 }; lastPointer = { x: event.clientX, y: event.clientY };
} }
async function onPointerUp(event) { async function onPointerUp(event) {
if (await endWallDrag(event)) return;
if (event.pointerId !== pointerId) return; if (event.pointerId !== pointerId) return;
if (drawingWall.value) {
const segment = drawingWall.value;
pointerId = null;
drawingWall.value = null;
viewport.value?.releasePointerCapture?.(event.pointerId);
// A drag that ended where it started drew no wall; anything with length becomes one.
if (IsWall(segment)) await saveWalls([...walls.value, segment]);
return;
}
dragging.value = false; dragging.value = false;
pointerId = null; pointerId = null;
viewport.value?.releasePointerCapture?.(event.pointerId); viewport.value?.releasePointerCapture?.(event.pointerId);
@@ -223,12 +209,10 @@ function onMapContextMenu(event) {
const spot = ToImagePoint({ x: event.clientX - bounds.left, y: event.clientY - bounds.top }, viewState()); const spot = ToImagePoint({ x: event.clientX - bounds.left, y: event.clientY - bounds.top }, viewState());
if (!spot) return; if (!spot) return;
if (!noteOptions.value.length) { const items = [];
ShowContextMenu([{ name: t('campaigns.map.pins.none'), action: () => HideContextMenu() }]); if (!noteOptions.value.length) items.push({ name: t('campaigns.map.pins.none'), action: () => HideContextMenu() });
return; else {
} items.push({
ShowContextMenu([{
name: t('campaigns.map.pins.add'), name: t('campaigns.map.pins.add'),
icon: '/icons/iconoir/regular/map-pin-plus.svg', icon: '/icons/iconoir/regular/map-pin-plus.svg',
context: noteOptions.value.map((option) => ({ context: noteOptions.value.map((option) => ({
@@ -236,7 +220,26 @@ function onMapContextMenu(event) {
icon: '/icons/iconoir/regular/notes.svg', icon: '/icons/iconoir/regular/notes.svg',
action: () => { HideContextMenu(); savePin(option.value, spot); } 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) { function onPinContextMenu(pin) {
@@ -531,214 +534,327 @@ function handleActorEntry({ entityType, entry }) {
actors.value = [entry, ...actors.value.filter((current) => String(current._id) !== String(entry._id))]; actors.value = [entry, ...actors.value.filter((current) => String(current._id) !== String(entry._id))];
} }
// --- Walls blocking the map --- // --- Lights, and the walls that stop them ---
// The wall editor: with walls on, dragging over the map draws a segment from one grid intersection // A light shines from one spot of the image and is as free to place as a pin. The walls of the map are
// to the next, dragging an endpoint retypes it, dragging the segment itself moves it, and right // what cuts its reach into a shadow: CastLight works out the shape a light paints and the canvas below
// clicking one (or Delete on a focused one) opens its controls and takes it off. Walls are stored // paints that shape out of the dark laid over the map.
// in image pixels like the pins, and every edit saves the whole set — the same set a paired
// Foundry scene takes over, so the two see the same walls.
// 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 ?? []); const walls = computed(() => map.value?.walls ?? []);
const editingWalls = ref(false); // The light a pointer is holding, and the spot it holds it at: like a token, the move stays local until
// The wall a pointer is holding: a new segment being dragged, the whole segment being slid, or one // the pointer lets go, so dragging a light across the map is one save and not one per mouse move.
// endpoint being retyped. Like a token's move, the change stays local until the pointer lets go, const movingLight = ref(null);
// so a drag across the map is one save and not one per mouse move. let lightPointerId = null;
const drawingWall = ref(null);
const draggingWall = ref(null);
const draggingEnd = ref(null);
// The wall whose controls are asked for: selected before its menu opens, kept while it is dragged.
const selectedWall = ref(null);
const END_KEYS = [['x1', 'y1'], ['x2', 'y2']]; // A colour from the theme the canvas paints with. The canvas cannot be styled with `var(--color-…)`
let wallDragPointerId = null; // like a stylesheet, so it asks the document for the same variable the stylesheets use.
let lastWallDrag = { x: 0, y: 0 }; function themeColor(name, fallback) {
if (typeof window === 'undefined' || typeof getComputedStyle !== 'function') return fallback;
return getComputedStyle(document.documentElement).getPropertyValue(name).trim() || fallback;
}
function toggleWallEditing() { // A hex colour with an alpha end ('#ffc46b' + '4d'), because a canvas gradient needs its stops spelled
editingWalls.value = !editingWalls.value; // out. Anything that is not a plain hex colour is painted as it is.
if (!editingWalls.value) { 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; drawingWall.value = null;
draggingWall.value = null; viewport.value?.releasePointerCapture?.(event.pointerId);
draggingEnd.value = null;
selectedWall.value = null; // 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;
} }
// The spot of the viewport in image pixels, clamped to the image: while a wall is being held the async function saveWall(wall) {
// pointer may cross an edge, and the wall should stay on the map rather than vanish. await updateMap('/map/wall', { id: map.value?._id, ...wall }, t('campaigns.map.walls.error'));
function wallSpot(event) {
const bounds = viewport.value?.getBoundingClientRect();
if (!bounds) return null;
return ToDrawPoint({ x: event.clientX - bounds.left, y: event.clientY - bounds.top }, viewState());
}
// The wall as it should be drawn right now: with the drag's preview on top of what is stored.
function wallGeometry(wall) {
if (draggingWall.value && String(draggingWall.value.wall?._id) === String(wall?._id)) {
const moved = MoveWall(wall, draggingWall.value.dx, draggingWall.value.dy);
if (moved) return { ...wall, ...moved };
}
if (draggingEnd.value && String(draggingEnd.value.wall?._id) === String(wall?._id) && draggingEnd.value.point) {
const [keyX, keyY] = END_KEYS[draggingEnd.value.end];
return { ...wall, [keyX]: draggingEnd.value.point.x, [keyY]: draggingEnd.value.point.y };
}
return wall;
}
function wallScreen(wall) {
return ToScreenWall(wallGeometry(wall), viewState());
}
function wallClasses(wall) {
return {
'wall-door': Number(wall?.door) > 0,
'wall-move-only': !wall?.sight && Number(wall?.door) === 0,
selected: Boolean(selectedWall.value) && String(selectedWall.value) === String(wall?._id)
};
}
// The wire shape of a wall: what the server keeps, with the `_id` of the ones it already has so a
// save neither doubles them nor re-ids them under the viewer's feet.
function plainWall(wall) {
const stored = {
x1: Number(wall.x1), y1: Number(wall.y1), x2: Number(wall.x2), y2: Number(wall.y2),
move: wall.move !== false, sight: wall.sight !== false, door: Number(wall.door) || 0
};
return wall._id ? { _id: String(wall._id), ...stored } : stored;
}
async function saveWalls(next) {
return updateMap('/map/walls', { id: map.value?._id, walls: next.map(plainWall) }, t('campaigns.map.walls.error'));
}
async function replaceWall(wall, patch) {
const next = walls.value.map((current) => (
String(current?._id) === String(wall?._id) ? { ...current, ...patch } : current
));
await saveWalls(next);
} }
async function removeWall(wall) { async function removeWall(wall) {
if (String(selectedWall.value) === String(wall?._id)) selectedWall.value = null; await updateMap('/map/remove-wall', { id: map.value?._id, wall: wall?._id }, t('campaigns.map.walls.error'));
await saveWalls(walls.value.filter((current) => String(current?._id) !== String(wall?._id)));
} }
function onWallPointerDown(event, wall) { // --- Painting the lights ---
// The segment is what is being held here: the map must not start panning under the pointer. // One canvas over the map, drawn in screen pixels like the pins and the tokens, and repainted whenever
event.stopPropagation(); // the view or the map changes. With the lighting on it lays the dark over the image and erases the shape
if (event.button !== 0) return; // 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.
wallDragPointerId = event.pointerId; function imageScreenRect() {
event.currentTarget.setPointerCapture?.(event.pointerId); const origin = ToScreenPoint({ x: 0, y: 0 }, viewState());
lastWallDrag = { x: event.clientX, y: event.clientY }; return {
selectedWall.value = String(wall?._id ?? ''); x: origin.x,
draggingWall.value = { wall, dx: 0, dy: 0 }; y: origin.y,
} width: imageSize.value.width * zoom.value,
height: imageSize.value.height * zoom.value
function onWallPointerMove(event) {
if (!draggingWall.value || event.pointerId !== wallDragPointerId) return;
const zoomScale = zoom.value || 1;
draggingWall.value = {
...draggingWall.value,
// The drag is measured in screen pixels and applied in image ones, and the whole segment
// goes by the same delta: a moved wall keeps its shape and the grid it was drawn on.
dx: draggingWall.value.dx + (event.clientX - lastWallDrag.x) / zoomScale,
dy: draggingWall.value.dy + (event.clientY - lastWallDrag.y) / zoomScale
}; };
lastWallDrag = { x: event.clientX, y: event.clientY };
} }
async function onWallPointerUp(event) { function tracePolygon(context, points, view) {
if (!draggingWall.value || event.pointerId !== wallDragPointerId) return; context.beginPath();
points.forEach((point, index) => {
const { wall, dx, dy } = draggingWall.value; const screen = ToScreenPoint(point, view);
wallDragPointerId = null; if (index) context.lineTo(screen.x, screen.y);
draggingWall.value = null; else context.moveTo(screen.x, screen.y);
event.currentTarget?.releasePointerCapture?.(event.pointerId); });
context.closePath();
const moved = MoveWall(wall, dx, dy);
if (!moved || (moved.x1 === Number(wall.x1) && moved.y1 === Number(wall.y1)
&& moved.x2 === Number(wall.x2) && moved.y2 === Number(wall.y2))) return;
await replaceWall(wall, moved);
} }
function onWallEndPointerDown(event, wall, end) { function paintDarkness(context, image) {
event.stopPropagation(); const view = viewState();
if (event.button !== 0) return; context.save();
context.fillStyle = themeColor('--color-map-darkness', '#000000d9');
context.fillRect(image.x, image.y, image.width, image.height);
wallDragPointerId = event.pointerId; // The lights erase the dark they stand in: only how much a gradient is transparent matters here, so
event.currentTarget.setPointerCapture?.(event.pointerId); // a light fades from fully lit at its middle to nothing at the end of its reach.
selectedWall.value = String(wall?._id ?? ''); context.globalCompositeOperation = 'destination-out';
draggingEnd.value = { wall, end, point: { x: Number(wall[END_KEYS[end][0]]), y: Number(wall[END_KEYS[end][1]]) } }; 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();
} }
function onWallEndPointerMove(event) { // The tint of a coloured light, laid back over the light it colours: a lantern reads warm and a
if (!draggingEnd.value || event.pointerId !== wallDragPointerId) return; // spell cold, and a light with no colour of its own leaves the map as it is.
const spot = wallSpot(event); context.globalCompositeOperation = 'source-over';
const snapped = spot && SnapToGrid(spot, grid.value); for (const light of lights.value) {
if (!snapped) return; if (!light.color) continue;
draggingEnd.value = { ...draggingEnd.value, point: snapped }; 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();
} }
async function onWallEndPointerUp(event) { function paintLightOutlines(context) {
if (!draggingEnd.value || event.pointerId !== wallDragPointerId) return; const view = viewState();
context.save();
const { wall, end, point } = draggingEnd.value; context.lineWidth = 1;
wallDragPointerId = null; for (const light of lights.value) {
draggingEnd.value = null; const shape = CastLight(light, walls.value);
event.currentTarget?.releasePointerCapture?.(event.pointerId); if (!shape.length) continue;
tracePolygon(context, shape, view);
const [keyX, keyY] = END_KEYS[end]; context.strokeStyle = withAlpha(light.color || '#ffffff', '59');
if (point.x === Number(wall[keyX]) && point.y === Number(wall[keyY])) return; context.stroke();
const retyped = { ...wall, [keyX]: point.x, [keyY]: point.y }; }
// Retyped into its own end, the segment has no length left: the wall is gone. context.restore();
if (!IsWall(retyped)) await removeWall(wall);
else await replaceWall(wall, { [keyX]: point.x, [keyY]: point.y });
} }
function onWallContextMenu(wall) { function paintWalls(context) {
selectedWall.value = String(wall?._id ?? ''); if (!walls.value.length && !drawingWall.value) return;
ShowContextMenu([ const view = viewState();
{ context.save();
name: t(wall.sight ? 'campaigns.map.walls.sight-open' : 'campaigns.map.walls.sight-block'), context.lineCap = 'round';
icon: '/icons/iconoir/regular/eye.svg', context.strokeStyle = themeColor('--color-map-wall', '#e06c75');
action: () => { HideContextMenu(); replaceWall(wall, { sight: !wall.sight }); } // 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) {
name: t(wall.move ? 'campaigns.map.walls.move-open' : 'campaigns.map.walls.move-block'), const from = ToScreenPoint({ x: Number(wall.x1) || 0, y: Number(wall.y1) || 0 }, view);
icon: '/icons/iconoir/regular/lock.svg', const to = ToScreenPoint({ x: Number(wall.x2) || 0, y: Number(wall.y2) || 0 }, view);
action: () => { HideContextMenu(); replaceWall(wall, { move: !wall.move }); } context.beginPath();
}, context.moveTo(from.x, from.y);
{ context.lineTo(to.x, to.y);
name: t('campaigns.map.walls.door'), context.stroke();
icon: '/icons/iconoir/regular/home-simple-door.svg',
context: [
{ name: t('campaigns.map.walls.door-none'), action: () => { HideContextMenu(); replaceWall(wall, { door: 0 }); } },
{ name: t('campaigns.map.walls.door-closed'), action: () => { HideContextMenu(); replaceWall(wall, { door: 2 }); } },
{ name: t('campaigns.map.walls.door-open'), action: () => { HideContextMenu(); replaceWall(wall, { door: 1 }); } }
]
},
{ divider: true },
{
name: t('campaigns.map.walls.remove'),
icon: '/icons/iconoir/regular/xmark-circle.svg',
action: () => { HideContextMenu(); removeWall(wall); }
} }
]); // 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();
} }
// A focused wall answers Delete too, the way a focused token does. function drawLighting() {
async function onWallKeydown(event, wall) { const canvas = lightingCanvas.value;
if (event.key !== 'Delete' && event.key !== 'Backspace') return; const bounds = viewport.value?.getBoundingClientRect();
event.preventDefault(); if (!canvas || !bounds) return;
await removeWall(wall);
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);
} }
// Escape lets go of whatever the editor is holding: an unfinished segment first, the selection next. // Every move of the view, and every light or wall that changes, is painted again.
function onWindowKeydown(event) { watch(
if (event.key !== 'Escape') return; [zoom, pan, imageSize, showLighting, wallMode, drawingWall, lights, walls, imageUrl],
if (drawingWall.value) drawingWall.value = null; () => nextTick(drawLighting),
else if (selectedWall.value) selectedWall.value = null; { 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. // A different map was anchored while this pane was already mounted.
watch(() => props.map, (incoming, previous) => { watch(() => props.map, (incoming, previous) => {
@@ -747,10 +863,9 @@ watch(() => props.map, (incoming, previous) => {
imageSize.value = { width: 0, height: 0 }; imageSize.value = { width: 0, height: 0 };
movingToken.value = null; movingToken.value = null;
draggingActor.value = false; draggingActor.value = false;
movingLight.value = null;
drawingWall.value = null; drawingWall.value = null;
draggingWall.value = null; wallPointerId = null;
draggingEnd.value = null;
selectedWall.value = null;
}); });
watch(campaignId, () => { watch(campaignId, () => {
@@ -766,7 +881,6 @@ onMounted(() => {
emitter.on('campaign-entry-updated', handleActorEntry); emitter.on('campaign-entry-updated', handleActorEntry);
emitter.on('delete-note', handlePinnedNoteDeleted); emitter.on('delete-note', handlePinnedNoteDeleted);
emitter.on('title-updated', handlePinnedNoteRenamed); emitter.on('title-updated', handlePinnedNoteRenamed);
window.addEventListener('keydown', onWindowKeydown);
fetchPinnableNotes(); fetchPinnableNotes();
fetchTokenActors(); fetchTokenActors();
}); });
@@ -777,7 +891,6 @@ onBeforeUnmount(() => {
emitter.off('campaign-entry-updated', handleActorEntry); emitter.off('campaign-entry-updated', handleActorEntry);
emitter.off('delete-note', handlePinnedNoteDeleted); emitter.off('delete-note', handlePinnedNoteDeleted);
emitter.off('title-updated', handlePinnedNoteRenamed); emitter.off('title-updated', handlePinnedNoteRenamed);
window.removeEventListener('keydown', onWindowKeydown);
}); });
</script> </script>
@@ -793,9 +906,13 @@ onBeforeUnmount(() => {
:aria-label="$t('campaigns.map.toggle-grid')" :aria-pressed="showGrid.toString()" @click="showGrid = !showGrid"> :aria-label="$t('campaigns.map.toggle-grid')" :aria-pressed="showGrid.toString()" @click="showGrid = !showGrid">
<img class="tool-icon" src="/icons/iconoir/regular/view-grid.svg" alt="" aria-hidden="true"> <img class="tool-icon" src="/icons/iconoir/regular/view-grid.svg" alt="" aria-hidden="true">
</button> </button>
<button class="viewer-tool" :class="{ selected: editingWalls }" type="button" :title="$t('campaigns.map.walls.edit')" <button class="viewer-tool" :class="{ selected: showLighting }" type="button" :title="$t('campaigns.map.toggle-lighting')"
:aria-label="$t('campaigns.map.walls.edit')" :aria-pressed="editingWalls.toString()" @click="toggleWallEditing"> :aria-label="$t('campaigns.map.toggle-lighting')" :aria-pressed="showLighting.toString()" @click="showLighting = !showLighting">
<img class="tool-icon" src="/icons/iconoir/regular/border-out.svg" alt="" aria-hidden="true"> <img class="tool-icon" src="/icons/iconoir/regular/light-bulb-on.svg" alt="" aria-hidden="true">
</button>
<button class="viewer-tool" :class="{ selected: wallMode }" type="button" :title="$t('campaigns.map.toggle-walls')"
:aria-label="$t('campaigns.map.toggle-walls')" :aria-pressed="wallMode.toString()" @click="wallMode = !wallMode">
<img class="tool-icon" src="/icons/iconoir/regular/linear.svg" alt="" aria-hidden="true">
</button> </button>
<button class="viewer-tool" type="button" :title="$t('campaigns.map.zoom-out')" :aria-label="$t('campaigns.map.zoom-out')" @click="zoomFromToolbar(false)"> <button class="viewer-tool" type="button" :title="$t('campaigns.map.zoom-out')" :aria-label="$t('campaigns.map.zoom-out')" @click="zoomFromToolbar(false)">
<img class="tool-icon" src="/icons/iconoir/regular/minus.svg" alt="" aria-hidden="true"> <img class="tool-icon" src="/icons/iconoir/regular/minus.svg" alt="" aria-hidden="true">
@@ -820,7 +937,7 @@ onBeforeUnmount(() => {
<div <div
ref="viewport" ref="viewport"
class="map-viewport" class="map-viewport"
:class="{ dragging }" :class="{ dragging, 'wall-mode': wallMode }"
@wheel.prevent="onWheel" @wheel.prevent="onWheel"
@pointerdown="onPointerDown" @pointerdown="onPointerDown"
@pointermove="onPointerMove" @pointermove="onPointerMove"
@@ -834,42 +951,28 @@ onBeforeUnmount(() => {
<template v-if="imageUrl"> <template v-if="imageUrl">
<img class="map-image" :src="imageUrl" :style="stageStyle" :alt="map?.name" draggable="false" @load="onImageLoaded"> <img class="map-image" :src="imageUrl" :style="stageStyle" :alt="map?.name" draggable="false" @load="onImageLoaded">
<div class="map-grid" :style="gridStyle" aria-hidden="true"></div> <div class="map-grid" :style="gridStyle" aria-hidden="true"></div>
<!-- Walls are drawn in screen space like the pins, so their lines stay thin at any <canvas ref="lightingCanvas" class="map-lighting" aria-hidden="true"></canvas>
zoom. They only catch the mouse while the editor is open, and never when there <div class="map-lights">
is no image to hold them. --> <button
<svg v-if="imageUrl && (walls.length || drawingWall || editingWalls)" class="map-walls" :class="{ editing: editingWalls }"> v-for="light in lights"
<g v-for="wall in walls" :key="wall._id"> :key="light._id"
<line class="wall-line" :class="wallClasses(wall)" v-bind="wallScreen(wall)"></line> class="map-light"
<template v-if="editingWalls"> :class="{ moving: movingLight && String(movingLight.light?._id) === String(light._id) }"
<line type="button"
class="wall-hit" :style="lightStyle(light)"
role="button" :title="$t('campaigns.map.lights.light')"
tabindex="0" :aria-label="$t('campaigns.map.lights.light')"
:aria-label="$t('campaigns.map.walls.wall')" draggable="false"
v-bind="wallScreen(wall)" @pointerdown="onLightPointerDown($event, light)"
@pointerdown="onWallPointerDown($event, wall)" @pointermove="onLightPointerMove"
@pointermove="onWallPointerMove" @pointerup="onLightPointerUp"
@pointerup="onWallPointerUp" @pointercancel="onLightPointerUp"
@pointercancel="onWallPointerUp" @contextmenu.stop.prevent="onLightContextMenu(light)"
@contextmenu.stop.prevent="onWallContextMenu(wall)" @keydown="onLightKeydown($event, light)"
@keydown="onWallKeydown($event, wall)" >
></line> <img class="light-icon" src="/icons/iconoir/regular/fire-flame.svg" alt="" aria-hidden="true">
<circle </button>
v-for="end in [0, 1]" </div>
:key="end"
class="wall-end"
:cx="end === 0 ? wallScreen(wall).x1 : wallScreen(wall).x2"
:cy="end === 0 ? wallScreen(wall).y1 : wallScreen(wall).y2"
r="5"
@pointerdown="onWallEndPointerDown($event, wall, end)"
@pointermove="onWallEndPointerMove"
@pointerup="onWallEndPointerUp"
@pointercancel="onWallEndPointerUp"
></circle>
</template>
</g>
<line v-if="drawingWall" class="wall-draft" v-bind="ToScreenWall(drawingWall, viewState())"></line>
</svg>
<div class="map-pins"> <div class="map-pins">
<button <button
v-for="pin in pins" v-for="pin in pins"
@@ -912,7 +1015,7 @@ onBeforeUnmount(() => {
</button> </button>
</div> </div>
<div v-if="draggingActor" class="map-drop-hint">{{ $t('campaigns.map.tokens.drop-hint') }}</div> <div v-if="draggingActor" class="map-drop-hint">{{ $t('campaigns.map.tokens.drop-hint') }}</div>
<div v-if="editingWalls" class="map-walls-hint">{{ $t('campaigns.map.walls.hint') }}</div> <div v-if="wallMode" class="map-drop-hint">{{ $t('campaigns.map.walls.hint') }}</div>
</template> </template>
<div v-else class="map-empty"> <div v-else class="map-empty">
{{ $t('campaigns.map.no-image') }} {{ $t('campaigns.map.no-image') }}
@@ -938,6 +1041,23 @@ onBeforeUnmount(() => {
.map-viewport.dragging { cursor: grabbing; } .map-viewport.dragging { cursor: grabbing; }
.map-image { position: absolute; top: 0; left: 0; max-width: none; transform-origin: top left; user-select: none; } .map-image { position: absolute; top: 0; left: 0; max-width: none; transform-origin: top left; user-select: none; }
.map-grid { position: absolute; top: 0; left: 0; opacity: .55; pointer-events: none; } .map-grid { position: absolute; top: 0; left: 0; opacity: .55; pointer-events: none; }
.map-viewport.wall-mode { cursor: crosshair; }
/* The lights are painted on a canvas over the image and in screen space, like the pins: the dark over
the map and the shape each light cuts in it are redrawn whenever the view moves (see drawLighting).
The canvas never catches the mouse; the light markers below do that. */
.map-lighting { position: absolute; top: 0; left: 0; pointer-events: none; }
.map-lights { position: absolute; inset: 0; pointer-events: none; }
.map-light {
position: absolute; transform: translate(-50%, -50%); pointer-events: auto;
display: flex; align-items: center; justify-content: center; width: 26px; height: 26px;
margin: 0; padding: 0; border: 1px solid var(--color-link); border-radius: 50%;
background: var(--color-background-soft); color: var(--color-text);
cursor: grab; user-select: none; box-shadow: 0px 0px 6px -1px rgba(0,0,0,0.55);
}
.map-light:hover { background: var(--color-button-hover); }
.map-light:focus-visible { outline: 1px solid var(--color-link); outline-offset: 2px; }
.map-light.moving { cursor: grabbing; }
.light-icon { width: 14px; height: 14px; filter: invert(var(--color-icon-invert)); }
/* Pins live in image pixels but are drawn in screen space (see ToScreenPoint), so the overlay stays /* Pins live in image pixels but are drawn in screen space (see ToScreenPoint), so the overlay stays
unscaled and their markers are readable at every zoom. Only the markers catch the mouse. */ unscaled and their markers are readable at every zoom. Only the markers catch the mouse. */
.map-pins { position: absolute; inset: 0; pointer-events: none; } .map-pins { position: absolute; inset: 0; pointer-events: none; }
@@ -983,27 +1103,6 @@ onBeforeUnmount(() => {
background: var(--color-background-soft); color: var(--color-text); font-size: 12px; background: var(--color-background-soft); color: var(--color-text); font-size: 12px;
pointer-events: none; box-shadow: 0px 0px 6px -1px rgba(0,0,0,0.55); pointer-events: none; box-shadow: 0px 0px 6px -1px rgba(0,0,0,0.55);
} }
/* Walls are drawn in screen space like the pins, so their lines stay thin at any zoom. A sight
wall is red, a wall that only stops movement grey, a door green — close to how Foundry paints
them on its own scenes. Only the editor's hit lines and handles catch the mouse. */
.map-walls { position: absolute; inset: 0; width: 100%; height: 100%; pointer-events: none; overflow: visible; }
.wall-line { stroke: var(--color-red); stroke-width: 2; opacity: .85; pointer-events: none; }
.wall-line.wall-move-only { stroke: var(--color-gray); }
.wall-line.wall-door { stroke: var(--color-green); stroke-width: 3; }
.wall-line.selected { stroke: var(--color-link); opacity: 1; }
/* The grabbable line and the endpoint handles: each wall gives its own hit area, wide enough that
the pointer finds it at any zoom. */
.wall-hit { stroke: transparent; stroke-width: 16; stroke-linecap: round; pointer-events: stroke; cursor: move; }
.wall-hit:focus-visible { stroke: var(--color-link); stroke-opacity: .35; outline: none; }
.wall-end { fill: var(--color-background-soft); stroke: var(--color-link); stroke-width: 1.5; pointer-events: auto; cursor: crosshair; }
.wall-draft { stroke: var(--color-link); stroke-width: 2; stroke-dasharray: 6 4; pointer-events: none; }
/* Shown while the wall editor is open, so the gestures it answers to are at hand. */
.map-walls-hint {
position: absolute; bottom: 10px; left: 50%; transform: translateX(-50%);
padding: 5px 10px; border: 1px dashed var(--color-link); border-radius: 7px;
background: var(--color-background-soft); color: var(--color-text); font-size: 12px;
pointer-events: none; box-shadow: 0px 0px 6px -1px rgba(0,0,0,0.55);
}
.map-empty { width: 100%; height: 100%; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 8px; font-size: 13px; opacity: .8; } .map-empty { width: 100%; height: 100%; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 8px; font-size: 13px; opacity: .8; }
.map-edit { border: 1px solid var(--color-border); border-radius: 7px; padding: 6px 11px; background: var(--color-background-soft); color: var(--color-text); font-size: 12px; cursor: pointer; } .map-edit { border: 1px solid var(--color-border); border-radius: 7px; padding: 6px 11px; background: var(--color-background-soft); color: var(--color-text); font-size: 12px; cursor: pointer; }
.map-edit:hover { background: var(--color-button-hover); } .map-edit:hover { background: var(--color-button-hover); }

View File

@@ -0,0 +1,200 @@
// The rules behind the lights of a map (place a light, draw the walls that stop it, know which wall a
// click landed on). Like the pins and the tokens, a light is stored in image pixels, so these helpers
// only work out geometry: they hold no state and talk to no API.
//
// The shadow of a light is the standard visibility polygon: rays are aimed at every corner of every
// wall (just past it, so a corner never leaves a slit open) and at the midpoints between them, and each
// ray stops at the first wall it meets or at the reach of the light. Joining where those rays end gives
// the shape the light paints, walls cutting it wherever they stand.
// Aiming a hair to either side of a wall corner, so the ray passes it instead of landing on it.
const RAY_EPSILON = 0.0001;
// How finely an open arc is drawn where no wall corner asks for a ray of its own (about 7.5°).
const MAX_ARC_STEP = Math.PI / 24;
// A wall touching the light itself does not hide it, and a ray that close has nothing to say.
const MIN_HIT = 1e-6;
// The walls of a map as plain segments: only the ones with two real ends count, and a light is not
// asked to block anything it is standing on.
function ToWallSegments(walls) {
return (walls ?? [])
.map((wall) => ({
x1: Number(wall?.x1),
y1: Number(wall?.y1),
x2: Number(wall?.x2),
y2: Number(wall?.y2)
}))
.filter((wall) => [wall.x1, wall.y1, wall.x2, wall.y2].every(Number.isFinite)
&& (wall.x1 !== wall.x2 || wall.y1 !== wall.y2));
}
// The corner of the grid a point of the image is closest to, in image pixels: this is where a wall end
// is kept, so a wall runs along the lines of the grid it was drawn on. The backend snaps the same way,
// so a wall does not move when the line that drew it is saved.
function SnapToGridVertex(point, grid) {
const size = Math.max(1, Number(grid?.gridSize) || 50);
const offsetX = Number(grid?.offsetX) || 0;
const offsetY = Number(grid?.offsetY) || 0;
const x = Number(point?.x);
const y = Number(point?.y);
if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
// Spots off the top left corner count from the corner itself, and only whole pixels count: both
// the way the route reads a coordinate, like the cells a token stands in.
const column = Math.round((Math.max(0, Math.round(x)) - offsetX) / size);
const row = Math.round((Math.max(0, Math.round(y)) - offsetY) / size);
return {
x: Math.max(0, Math.round(offsetX + column * size)),
y: Math.max(0, Math.round(offsetY + row * size))
};
}
// Wrapping an angle into [-PI, PI), so the rays of a light are counted once round and not twice.
function NormalizeAngle(angle) {
const full = Math.PI * 2;
let wrapped = angle % full;
if (wrapped >= Math.PI) wrapped -= full;
if (wrapped < -Math.PI) wrapped += full;
return wrapped;
}
// The directions to aim a ray: every wall corner from the light, a hair either side, and enough
// midpoints between them that the lit arc stays round instead of turning into a star.
function RayAngles(centre, segments) {
const angles = [];
for (const segment of segments) {
for (const corner of [{ x: segment.x1, y: segment.y1 }, { x: segment.x2, y: segment.y2 }]) {
const angle = Math.atan2(corner.y - centre.y, corner.x - centre.x);
if (!Number.isFinite(angle)) continue;
angles.push(NormalizeAngle(angle - RAY_EPSILON), NormalizeAngle(angle), NormalizeAngle(angle + RAY_EPSILON));
}
}
if (!angles.length) return EvenAngles();
// Two corners in a line from the light ask for the same ray: keep it once.
angles.sort((a, b) => a - b);
const ordered = [];
for (const angle of angles) {
if (ordered.length && angle - ordered[ordered.length - 1] < RAY_EPSILON) continue;
ordered.push(angle);
}
// The first and the last angle can be the same ray seen across the wrap round.
if (ordered.length > 1 && (ordered[0] + Math.PI * 2) - ordered[ordered.length - 1] < RAY_EPSILON) ordered.pop();
const rays = [];
for (let index = 0; index < ordered.length; index += 1) {
const current = ordered[index];
// The last angle wraps round to the first: a light shines the whole way round.
const next = index + 1 < ordered.length ? ordered[index + 1] : ordered[0] + Math.PI * 2;
rays.push(current);
const steps = Math.max(1, Math.ceil((next - current) / MAX_ARC_STEP));
for (let step = 1; step < steps; step += 1) rays.push(NormalizeAngle(current + ((next - current) * step) / steps));
}
return rays;
}
// A light with no walls in sight still has an edge, so it is drawn as a circle of as many rays as an
// open arc is cut into.
function EvenAngles() {
const angles = [];
const steps = Math.ceil((Math.PI * 2) / MAX_ARC_STEP);
for (let step = 0; step < steps; step += 1) angles.push(NormalizeAngle((Math.PI * 2) * (step / steps)));
return angles;
}
// How far along the ray from `centre` (aimed at unit direction `dx`/`dy`) a segment stands, or null
// when the ray misses it. Parallel rays miss, and so does a segment behind the light.
function RaySegmentDistance(centre, dx, dy, segment) {
const bx = segment.x2 - segment.x1;
const by = segment.y2 - segment.y1;
const cross = dx * by - dy * bx;
if (Math.abs(cross) < 1e-12) return null;
const ax = segment.x1 - centre.x;
const ay = segment.y1 - centre.y;
const along = (ax * by - ay * bx) / cross;
const across = (ax * dy - ay * dx) / cross;
if (along <= MIN_HIT || across < 0 || across > 1) return null;
return along;
}
// The first wall a ray runs into, or Infinity when it reaches into the open.
function RayDistance(centre, angle, segments) {
const dx = Math.cos(angle);
const dy = Math.sin(angle);
let nearest = Infinity;
for (const segment of segments) {
const hit = RaySegmentDistance(centre, dx, dy, segment);
if (hit !== null && hit < nearest) nearest = hit;
}
return nearest;
}
// The shape a light paints, in image pixels: the points of its visibility polygon, aimed round from
// the light itself. Nothing is lit where a wall stands between it and the light, and a light that
// cannot be placed lights nothing at all.
function CastLight(light, walls) {
const centre = { x: Number(light?.x), y: Number(light?.y) };
const radius = Number(light?.radius);
if (!Number.isFinite(centre.x) || !Number.isFinite(centre.y) || !Number.isFinite(radius) || radius <= 0) return [];
const segments = ToWallSegments(walls);
const points = [];
for (const angle of RayAngles(centre, segments)) {
const reached = Math.min(radius, RayDistance(centre, angle, segments));
// A wall crossing the light itself leaves that ray with no lit pixel of its own to end on.
if (reached <= MIN_HIT) continue;
points.push({
x: centre.x + Math.cos(angle) * reached,
y: centre.y + Math.sin(angle) * reached
});
}
return points;
}
// How far a point of the image stands from a wall, in image pixels.
function DistanceToWall(point, wall) {
const x = Number(point?.x);
const y = Number(point?.y);
const x1 = Number(wall?.x1);
const y1 = Number(wall?.y1);
const x2 = Number(wall?.x2);
const y2 = Number(wall?.y2);
if (![x, y, x1, y1, x2, y2].every(Number.isFinite)) return Infinity;
const bx = x2 - x1;
const by = y2 - y1;
const length = bx * bx + by * by;
if (!length) return Math.hypot(x - x1, y - y1);
// The closest point of the segment is the perpendicular foot, held inside its own ends.
const along = Math.max(0, Math.min(1, ((x - x1) * bx + (y - y1) * by) / length));
return Math.hypot(x - (x1 + bx * along), y - (y1 + by * along));
}
// The wall a point is standing on — the one nearest to it within `tolerance` image pixels, or null
// when there is no wall there. This is what lets a right click pick the wall it meant.
function WallAt(point, walls, tolerance) {
const limit = Number(tolerance);
if (!Number.isFinite(limit)) return null;
let nearest = null;
let nearestDistance = Math.max(0, limit);
for (const wall of walls ?? []) {
const distance = DistanceToWall(point, wall);
if (distance > nearestDistance) continue;
nearest = wall;
nearestDistance = distance;
}
return nearest;
}
export {
CastLight,
DistanceToWall,
NormalizeAngle,
SnapToGridVertex,
ToWallSegments,
WallAt
};

View File

@@ -1,87 +0,0 @@
// The rules behind the wall segments of a map (the wall editor: drag to draw a segment from grid
// intersection to grid intersection, drag an endpoint to retype it, drag the segment itself to move
// it). Like pins and tokens, walls are stored in image pixels — the very space Foundry draws a
// scene's walls in — so these helpers only translate and snap: they hold no state and talk to no
// API, and the editor saves the whole set the way the viewer ends up with it.
// Screen pixels (relative to the top left corner of the map viewport) → image pixels, clamped to
// the image but never refused: while a wall is being drawn the pointer does leave the image, and
// the endpoint then sticks to its edge instead of vanishing.
function ToDrawPoint(point, view) {
const zoom = Number(view?.zoom);
if (!Number.isFinite(zoom) || zoom <= 0) return null;
const x = (Number(point?.x) - Number(view?.pan?.x ?? 0)) / zoom;
const y = (Number(point?.y) - Number(view?.pan?.y ?? 0)) / zoom;
if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
return { x: Math.max(0, x), y: Math.max(0, y) };
}
// The nearest intersection of the grid, in image pixels: a drawn wall's endpoints snap to these,
// so walls line up with the cells whatever offset the map has — the way Foundry snaps its walls
// to the grid too.
function SnapToGrid(point, grid) {
const size = Math.max(1, Number(grid?.gridSize) || 50);
const offsetX = Number(grid?.offsetX) || 0;
const offsetY = Number(grid?.offsetY) || 0;
const x = Number(point?.x);
const y = Number(point?.y);
if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
return {
x: Math.max(0, Math.round(offsetX + Math.round((x - offsetX) / size) * size)),
y: Math.max(0, Math.round(offsetY + Math.round((y - offsetY) / size) * size))
};
}
// A wall (image pixels) → screen pixels of the map viewport. Walls are drawn in screen space like
// the pins, so their lines stay one pixel wide whatever the zoom is.
function ToScreenPoint(x, y, view) {
const zoom = Number(view?.zoom) || 0;
return {
x: Number(view?.pan?.x ?? 0) + Number(x ?? 0) * zoom,
y: Number(view?.pan?.y ?? 0) + Number(y ?? 0) * zoom
};
}
function ToScreenWall(wall, view) {
const from = ToScreenPoint(wall?.x1, wall?.y1, view);
const to = ToScreenPoint(wall?.x2, wall?.y2, view);
return { x1: from.x, y1: from.y, x2: to.x, y2: to.y };
}
// A whole wall slid over the map: both endpoints by the same delta, so a moved wall keeps its
// shape and its alignment to the grid it was drawn on. Never off the top left corner.
function MoveWall(wall, dx, dy) {
const x1 = Number(wall?.x1);
const y1 = Number(wall?.y1);
const x2 = Number(wall?.x2);
const y2 = Number(wall?.y2);
const stepX = Number(dx);
const stepY = Number(dy);
if (![x1, y1, x2, y2, stepX, stepY].every(Number.isFinite)) return null;
return {
x1: Math.max(0, Math.round(x1 + stepX)),
y1: Math.max(0, Math.round(y1 + stepY)),
x2: Math.max(0, Math.round(x2 + stepX)),
y2: Math.max(0, Math.round(y2 + stepY))
};
}
// Two endpoints of a segment, snapped or not, long enough to be a wall: a drag that ends where it
// started drew nothing.
function IsWall(wall) {
return Boolean(wall) && Number.isFinite(wall.x1) && Number.isFinite(wall.y1)
&& Number.isFinite(wall.x2) && Number.isFinite(wall.y2)
&& !(wall.x1 === wall.x2 && wall.y1 === wall.y2);
}
export {
IsWall,
MoveWall,
SnapToGrid,
ToDrawPoint,
ToScreenWall
};

View File

@@ -99,6 +99,7 @@
"save-error": "No s'ha pogut desar aquest mapa.", "save-error": "No s'ha pogut desar aquest mapa.",
"no-image": "Aquest mapa encara no té imatge.", "no-image": "Aquest mapa encara no té imatge.",
"zoom-in": "Apropar", "zoom-out": "Allunyar", "fit": "Ajustar a la finestra", "toggle-grid": "Mostrar la quadrícula", "zoom-in": "Apropar", "zoom-out": "Allunyar", "fit": "Ajustar a la finestra", "toggle-grid": "Mostrar la quadrícula",
"toggle-lighting": "Mostrar la il·luminació", "toggle-walls": "Dibuixar murs",
"open-window": "Obre en una finestra", "anchored": "Ancorat", "open-window": "Obre en una finestra", "anchored": "Ancorat",
"pins": { "pins": {
"add": "Fixa una nota aquí", "none": "Encara no hi ha notes per fixar", "add": "Fixa una nota aquí", "none": "Encara no hi ha notes per fixar",
@@ -112,15 +113,14 @@
"open": "Obre la fitxa de personatge", "remove": "Treu la fitxa", "open": "Obre la fitxa de personatge", "remove": "Treu la fitxa",
"error": "No s'han pogut canviar les fitxes d'aquest mapa." "error": "No s'han pogut canviar les fitxes d'aquest mapa."
}, },
"lights": {
"light": "Llum", "add": "Afegeix una llum aquí", "remove": "Treu la llum",
"error": "No s'han pogut canviar les llums d'aquest mapa."
},
"walls": { "walls": {
"edit": "Edita murs", "remove": "Treu el mur d'aquí",
"hint": "Arrossega sobre el mapa per dibuixar un mur · arrossega'n els extrems per canviar-lo, el cos per moure'l", "hint": "Arrossega d'una cantonada de la quadrícula a l'altra per dibuixar un mur",
"wall": "Mur", "error": "No s'han pogut canviar els murs d'aquest mapa."
"sight-block": "Bloqueja la vista", "sight-open": "Permet la vista",
"move-block": "Bloqueja el moviment", "move-open": "Permet el moviment",
"door": "Porta", "door-none": "No és porta", "door-closed": "Porta tancada", "door-open": "Porta oberta",
"remove": "Treu el mur",
"error": "No s'han pogut guardar els murs d'aquest mapa."
} }
}, },
"character-sheet": { "character-sheet": {

View File

@@ -4,7 +4,6 @@
"world-already-linked": "Aquest món de Foundry ja està enllaçat amb una altra campanya.", "world-already-linked": "Aquest món de Foundry ja està enllaçat amb una altra campanya.",
"actor-already-synced": "Un altre actor d'aquesta campanya ja està sincronitzat amb aquell actor del Foundry.", "actor-already-synced": "Un altre actor d'aquesta campanya ja està sincronitzat amb aquell actor del Foundry.",
"item-already-synced": "Un altre objecte d'aquesta campanya ja està sincronitzat amb aquell objecte del Foundry.", "item-already-synced": "Un altre objecte d'aquesta campanya ja està sincronitzat amb aquell objecte del Foundry.",
"scene-already-synced": "Un altre mapa d'aquesta campanya ja està sincronitzat amb aquella escena del Foundry.",
"icons-unavailable": "Les icones del Foundry no són disponibles: el seu bridge no està configurat o ara mateix no hi arriba.", "icons-unavailable": "Les icones del Foundry no són disponibles: el seu bridge no està configurat o ara mateix no hi arriba.",
"icons-no-world-url": "Aquesta campanya no té adreça del món del Foundry. Definiu-la als ajustos de la campanya, a la pestanya d'integracions.", "icons-no-world-url": "Aquesta campanya no té adreça del món del Foundry. Definiu-la als ajustos de la campanya, a la pestanya d'integracions.",
"import-not-linked": "Aquesta campanya no té cap món del Foundry vinculat. Connecteu-ne un als ajustos de la campanya, a la pestanya d'integracions.", "import-not-linked": "Aquesta campanya no té cap món del Foundry vinculat. Connecteu-ne un als ajustos de la campanya, a la pestanya d'integracions.",

View File

@@ -103,6 +103,7 @@
"save-error": "Unable to save this map.", "save-error": "Unable to save this map.",
"no-image": "This map has no image yet.", "no-image": "This map has no image yet.",
"zoom-in": "Zoom in", "zoom-out": "Zoom out", "fit": "Fit to window", "toggle-grid": "Show grid", "zoom-in": "Zoom in", "zoom-out": "Zoom out", "fit": "Fit to window", "toggle-grid": "Show grid",
"toggle-lighting": "Show lighting", "toggle-walls": "Draw walls",
"open-window": "Open in window", "anchored": "Anchored", "open-window": "Open in window", "anchored": "Anchored",
"pins": { "pins": {
"add": "Pin a note here", "none": "No notes to pin yet", "add": "Pin a note here", "none": "No notes to pin yet",
@@ -116,15 +117,14 @@
"open": "Open character sheet", "remove": "Remove token", "open": "Open character sheet", "remove": "Remove token",
"error": "Unable to change the tokens of this map." "error": "Unable to change the tokens of this map."
}, },
"lights": {
"light": "Light", "add": "Add light here", "remove": "Remove light",
"error": "Unable to change the lights of this map."
},
"walls": { "walls": {
"edit": "Edit walls", "remove": "Remove wall here",
"hint": "Drag on the map to draw a wall · drag its ends to retype it, its body to move it", "hint": "Drag from one corner of the grid to another to draw a wall",
"wall": "Wall", "error": "Unable to change the walls of this map."
"sight-block": "Block sight", "sight-open": "Let sight through",
"move-block": "Block movement", "move-open": "Let movement through",
"door": "Door", "door-none": "Not a door", "door-closed": "Closed door", "door-open": "Open door",
"remove": "Remove wall",
"error": "Unable to save the walls of this map."
} }
}, },
"character-sheet": { "character-sheet": {

View File

@@ -4,7 +4,6 @@
"world-already-linked": "This Foundry world is already linked to another campaign.", "world-already-linked": "This Foundry world is already linked to another campaign.",
"actor-already-synced": "Another actor in this campaign is already synced with that Foundry actor.", "actor-already-synced": "Another actor in this campaign is already synced with that Foundry actor.",
"item-already-synced": "Another item in this campaign is already synced with that Foundry item.", "item-already-synced": "Another item in this campaign is already synced with that Foundry item.",
"scene-already-synced": "Another map in this campaign is already synced with that Foundry scene.",
"icons-unavailable": "Foundry's icons are not available: its bridge is not set up, or it cannot be reached right now.", "icons-unavailable": "Foundry's icons are not available: its bridge is not set up, or it cannot be reached right now.",
"icons-no-world-url": "This campaign has no Foundry world address. Set it under campaign settings, in the Integrations tab.", "icons-no-world-url": "This campaign has no Foundry world address. Set it under campaign settings, in the Integrations tab.",
"import-not-linked": "This campaign has no Foundry world linked to it. Connect one under campaign settings, in the Integrations tab.", "import-not-linked": "This campaign has no Foundry world linked to it. Connect one under campaign settings, in the Integrations tab.",

View File

@@ -99,6 +99,7 @@
"save-error": "No se pudo guardar este mapa.", "save-error": "No se pudo guardar este mapa.",
"no-image": "Este mapa aún no tiene imagen.", "no-image": "Este mapa aún no tiene imagen.",
"zoom-in": "Acercar", "zoom-out": "Alejar", "fit": "Ajustar a la ventana", "toggle-grid": "Mostrar cuadrícula", "zoom-in": "Acercar", "zoom-out": "Alejar", "fit": "Ajustar a la ventana", "toggle-grid": "Mostrar cuadrícula",
"toggle-lighting": "Mostrar iluminación", "toggle-walls": "Dibujar muros",
"open-window": "Abrir en una ventana", "anchored": "Anclado", "open-window": "Abrir en una ventana", "anchored": "Anclado",
"pins": { "pins": {
"add": "Fija una nota aquí", "none": "Aún no hay notas que fijar", "add": "Fija una nota aquí", "none": "Aún no hay notas que fijar",
@@ -112,15 +113,14 @@
"open": "Abrir hoja de personaje", "remove": "Quitar la ficha", "open": "Abrir hoja de personaje", "remove": "Quitar la ficha",
"error": "No se pudieron cambiar las fichas de este mapa." "error": "No se pudieron cambiar las fichas de este mapa."
}, },
"lights": {
"light": "Luz", "add": "Añadir luz aquí", "remove": "Quitar la luz",
"error": "No se pudieron cambiar las luces de este mapa."
},
"walls": { "walls": {
"edit": "Editar muros", "remove": "Quitar el muro de aquí",
"hint": "Arrastra sobre el mapa para dibujar un muro · arrastra sus extremos para cambiarlo, su cuerpo para moverlo", "hint": "Arrastra de una esquina de la cuadrícula a otra para dibujar un muro",
"wall": "Muro", "error": "No se pudieron cambiar los muros de este mapa."
"sight-block": "Bloquear la visión", "sight-open": "Permitir la visión",
"move-block": "Bloquear el movimiento", "move-open": "Permitir el movimiento",
"door": "Puerta", "door-none": "No es puerta", "door-closed": "Puerta cerrada", "door-open": "Puerta abierta",
"remove": "Quitar muro",
"error": "No se pudieron guardar los muros de este mapa."
} }
}, },
"character-sheet": { "character-sheet": {

View File

@@ -4,7 +4,6 @@
"world-already-linked": "Este mundo de Foundry ya está vinculado a otra campaña.", "world-already-linked": "Este mundo de Foundry ya está vinculado a otra campaña.",
"actor-already-synced": "Otro actor de esta campaña ya está sincronizado con ese actor de Foundry.", "actor-already-synced": "Otro actor de esta campaña ya está sincronizado con ese actor de Foundry.",
"item-already-synced": "Otro objeto de esta campaña ya está sincronizado con ese objeto de Foundry.", "item-already-synced": "Otro objeto de esta campaña ya está sincronizado con ese objeto de Foundry.",
"scene-already-synced": "Otro mapa de esta campaña ya está sincronizado con esa escena de Foundry.",
"icons-unavailable": "Los iconos de Foundry no están disponibles: su bridge no está configurado o no es accesible ahora.", "icons-unavailable": "Los iconos de Foundry no están disponibles: su bridge no está configurado o no es accesible ahora.",
"icons-no-world-url": "Esta campaña no tiene dirección del mundo de Foundry. Defínala en los ajustes de la campaña, en la pestaña de integraciones.", "icons-no-world-url": "Esta campaña no tiene dirección del mundo de Foundry. Defínala en los ajustes de la campaña, en la pestaña de integraciones.",
"import-not-linked": "Esta campaña no tiene ningún mundo de Foundry vinculado. Conecte uno en los ajustes de la campaña, en la pestaña de integraciones.", "import-not-linked": "Esta campaña no tiene ningún mundo de Foundry vinculado. Conecte uno en los ajustes de la campaña, en la pestaña de integraciones.",

View File

@@ -143,6 +143,8 @@ function loadFoundryWriters({ seed = {}, settings } = {}) {
if (id === "../services/actor-foundry") return repoRequire(path.join("backend", "src", "services", "actor-foundry.js")); if (id === "../services/actor-foundry") return repoRequire(path.join("backend", "src", "services", "actor-foundry.js"));
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js")); if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js")); if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
// The Map model is only there for the scene lighting sync, which these tests do not run.
if (id === "../models/Map") return { find: () => mongooseQuery([]), findOne: async () => null };
if (models[id]) return models[id]; if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`); throw new Error(`require("${id}") is not stubbed`);
}; };

View File

@@ -281,6 +281,8 @@ function loadFoundryWriters({ seed = {} } = {}) {
if (id === "../services/actor-foundry") return repoRequire(path.join("backend", "src", "services", "actor-foundry.js")); if (id === "../services/actor-foundry") return repoRequire(path.join("backend", "src", "services", "actor-foundry.js"));
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js")); if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js")); if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
// The Map model is only there for the scene lighting sync, which these tests do not run.
if (id === "../models/Map") return { find: () => mongooseQuery([]), findOne: async () => null };
if (models[id]) return models[id]; if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`); throw new Error(`require("${id}") is not stubbed`);
}; };

View File

@@ -142,6 +142,8 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) }; if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) };
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js")); if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js")); if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
// The Map model is only there for the scene lighting sync, which these tests do not run.
if (id === "../models/Map") return { find: () => mongooseQuery([]), findOne: async () => null };
if (models[id]) return models[id]; if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`); throw new Error(`require("${id}") is not stubbed`);
}; };

View File

@@ -1,699 +0,0 @@
// Tests for the walls of maps (Syndria98/dragonroll#100): a wall editor on the map viewer, the
// walls kept on the map document, and the sync that lets a paired Foundry scene and a campaign
// map trade the same segments.
//
// Like map-pins.test.js, the express routers run against a stubbed `require` inside `node:vm`,
// the `MapWalls.js` service is loaded the way the map tests load the other services, and the
// Foundry module is loaded into a stubbed Foundry world whose embedded-document writes are
// observable. The last checks read the template of the map viewer, because there the wiring
// itself is what has to stay right.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const vm = require("node:vm");
const MODULE_ID = "dragonroll-foundry";
function readRepoFile(...parts) {
return fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
}
// A mongoose query answers whatever `await query` and `query.lean()` answer with, and lets
// `select()` and `sort()` sit in between.
function mongooseQuery(value) {
const result = {
select: () => result,
sort: () => result,
lean: () => Promise.resolve(value),
then: (onFulfilled, onRejected) => Promise.resolve(value).then(onFulfilled, onRejected),
};
return result;
}
// Loads an express router file with every module it requires stubbed out: `stubs` maps a require
// path to the module the route should see.
function loadRouter(relativeParts, stubs) {
const routes = new Map();
const router = {
get: (route, ...handlers) => routes.set(`GET ${route}`, handlers),
post: (route, ...handlers) => routes.set(`POST ${route}`, handlers),
};
const requireStub = (id) => {
if (id === "express") return { Router: () => router };
if (id === "../services/storage") return { single: () => (req, res, next) => next() };
if (!(id in stubs)) throw new Error(`require("${id}") is not stubbed`);
return stubs[id];
};
const moduleStub = { exports: {} };
vm.compileFunction(readRepoFile(...relativeParts), ["require", "module", "exports"])(
requireStub, moduleStub, moduleStub.exports
);
async function call(route, { body = {}, query = {}, params = {}, user = { id: "user-1" }, get = () => "" } = {}) {
const handlers = routes.get(route);
assert.ok(handlers, `${route} is not mounted`);
const res = { payload: null, json(payload) { this.payload = payload; } };
await handlers[handlers.length - 1]({ body, query, params, user, get }, res);
return res.payload;
}
return { routes, call };
}
// --- POST /map/walls: the wall editor's save ------------------------------------------------
function makeMapDoc(walls = []) {
return { _id: "map-1", campaign: "campaign-1", walls, save: async () => {} };
}
function loadMapRoutes({ ownsCampaign = true, maps = [] } = {}) {
return loadRouter(["backend", "src", "routes", "map.js"], {
"../models/Campaign": { findOne: () => mongooseQuery(ownsCampaign ? { _id: "campaign-1" } : null) },
"../models/Map": { findById: (id) => mongooseQuery(maps.find((map) => map._id === id) ?? null) },
"../models/Note": { findOne: () => mongooseQuery(null) },
"../models/Actor": { findOne: () => mongooseQuery(null) },
"../models/Folder": { find: () => mongooseQuery([]), belongsToSection: async () => true },
});
}
function wallSaveRouteTests() {
test("the wall editor saves the whole set, sanitised to whole image pixels", async () => {
const map = makeMapDoc();
const api = loadMapRoutes({ maps: [map] });
const response = await api.call("POST /walls", {
body: {
id: "map-1",
walls: [
// Coordinates arrive as strings from a form-ish body and can leave the image.
{ x1: "10.4", y1: -8, x2: 50, y2: 50.5, move: false },
{ _id: "wall-2", x1: 100, y1: 0, x2: 100, y2: 75, door: 2 },
],
},
});
assert.equal(response.status, "ok");
assert.deepEqual(map.walls, [
{ x1: 10, y1: 0, x2: 50, y2: 51, move: false, sight: true, door: 0 },
{ _id: "wall-2", x1: 100, y1: 0, x2: 100, y2: 75, move: true, sight: true, door: 2 },
]);
});
test("a save replaces the set: walls the editor dropped are gone", async () => {
const map = makeMapDoc([
{ _id: "wall-1", x1: 0, y1: 0, x2: 50, y2: 0 },
{ _id: "wall-2", x1: 0, y1: 0, x2: 0, y2: 50 },
]);
const api = loadMapRoutes({ maps: [map] });
await api.call("POST /walls", { body: { id: "map-1", walls: [{ _id: "wall-2", x1: 5, y1: 5, x2: 0, y2: 60 }] } });
assert.deepEqual(map.walls.map((wall) => String(wall._id)), ["wall-2"]);
assert.equal(map.walls[0].y1, 5);
});
test("segments without length or with unreadable endpoints are dropped", async () => {
const map = makeMapDoc();
const api = loadMapRoutes({ maps: [map] });
await api.call("POST /walls", {
body: {
id: "map-1",
walls: [
{ x1: 40, y1: 40, x2: 40, y2: 40 },
{ x1: "wide", y1: 0, x2: 50, y2: 50 },
{ x1: 0, y1: 0, x2: 50, y2: 50 },
],
},
});
assert.equal(map.walls.length, 1);
});
test("an unknown _id does not smuggle an id into the set, and a door outside 1 and 2 is no door", async () => {
const map = makeMapDoc([{ _id: "wall-1", x1: 0, y1: 0, x2: 50, y2: 0 }]);
const api = loadMapRoutes({ maps: [map] });
await api.call("POST /walls", {
body: {
id: "map-1",
walls: [
{ _id: "wall-9", x1: 0, y1: 0, x2: 50, y2: 0, door: 5 },
{ _id: "wall-1", x1: 60, y1: 0, x2: 60, y2: 50, door: "1" },
],
},
});
assert.deepEqual(map.walls, [
{ x1: 0, y1: 0, x2: 50, y2: 0, move: true, sight: true, door: 0 },
{ _id: "wall-1", x1: 60, y1: 0, x2: 60, y2: 50, move: true, sight: true, door: 1 },
]);
});
test("saving walls needs the map and an array, and only of one's own campaign", async () => {
const map = makeMapDoc();
const api = loadMapRoutes({ maps: [map] });
const foreign = loadMapRoutes({ ownsCampaign: false, maps: [makeMapDoc()] });
assert.equal((await api.call("POST /walls", { body: { walls: [] } })).msg, "errors.missing-data");
assert.equal((await api.call("POST /walls", { body: { id: "map-1" } })).msg, "errors.missing-data");
assert.equal((await api.call("POST /walls", { body: { id: "map-1", walls: "nope" } })).msg, "errors.missing-data");
assert.equal((await api.call("POST /walls", { body: { id: "map-404", walls: [] } })).msg, "errors.notfound");
assert.equal((await foreign.call("POST /walls", { body: { id: "map-1", walls: [] } })).msg, "unauthorized");
assert.deepEqual(map.walls, []);
});
}
// --- The module's sync routes: pairing a scene and trading wall sets -------------------------
function loadSyncRoutes({ campaign = { _id: "campaign-1", foundryWorldId: "world-1", settings: {} }, maps = [] } = {}) {
const matches = (map, filter) => {
if (filter._id !== undefined) {
if (typeof filter._id === "object" && filter._id.$ne !== undefined) {
if (String(map._id) === String(filter._id.$ne)) return false;
} else if (String(map._id) !== String(filter._id)) return false;
}
if (filter.campaign !== undefined && String(map.campaign) !== String(filter.campaign)) return false;
if (filter.foundrySceneId !== undefined
&& String(map.foundrySceneId ?? "") !== String(filter.foundrySceneId)) return false;
return true;
};
return loadRouter(["backend", "src", "routes", "foundry-link.js"], {
"node:crypto": require("node:crypto"),
mongoose: { isValidObjectId: () => false },
"../models/Campaign": { findOne: () => mongooseQuery(campaign) },
"../models/Actor": { find: () => mongooseQuery([]), findOne: () => mongooseQuery(null) },
"../models/Item": { find: () => mongooseQuery([]), findOne: () => mongooseQuery(null) },
"../models/Folder": { find: () => mongooseQuery([]) },
"../models/Map": {
find: (filter) => mongooseQuery(maps.filter((map) => matches(map, filter))),
findOne: (filter) => mongooseQuery(maps.find((map) => matches(map, filter)) ?? null),
},
"../services/actor-foundry": { foundryActorToCharacter: () => ({}) },
"../services/item-foundry": { foundryItemToItemData: () => null },
"../services/foundry-icons": { joinFoundryAssetUrl: () => "" },
});
}
// The sync routes authenticate with the token, not a JWT.
function asModule(request) {
return { ...request, get: (name) => (String(name).toLowerCase() === "authorization" ? "Bearer sync-token-1" : "") };
}
function syncRoutesTests() {
test("the module reads the campaign's maps with their walls and pairings", async () => {
const maps = [
{ _id: "map-1", campaign: "campaign-1", name: "Dungeon", image: "d.png", foundrySceneId: "scene-1", walls: [{ x1: 0, y1: 0, x2: 50, y2: 0 }] },
{ _id: "map-2", campaign: "campaign-1", name: "Town", image: "", foundrySceneId: null, walls: [] },
];
const api = loadSyncRoutes({ maps });
const response = await api.call("GET /sync/maps", asModule({}));
assert.equal(response.status, "ok");
assert.deepEqual(response.maps.map((map) => map.name), ["Dungeon", "Town"]);
assert.deepEqual(response.maps[0].walls, [{ x1: 0, y1: 0, x2: 50, y2: 0 }]);
});
test("a paired scene's whole wall set replaces the map's, sanitised", async () => {
const map = { _id: "map-1", campaign: "campaign-1", name: "Dungeon", foundrySceneId: "scene-1", walls: [{ x1: 9, y1: 9, x2: 9, y2: 60 }], save: async () => {} };
const api = loadSyncRoutes({ maps: [map] });
const response = await api.call("POST /sync/map-walls", asModule({
body: {
worldId: "world-1",
foundrySceneId: "scene-1",
walls: [
{ x1: 10.4, y1: -3, x2: 60, y2: 50.5, move: true, sight: false, door: 0 },
{ x1: 0, y1: 0, x2: 0, y2: 0, door: 2 },
{ x1: 0, y1: 0, x2: 50, y2: 0, door: 1 },
],
},
}));
assert.equal(response.status, "ok");
assert.deepEqual(map.walls, [
{ x1: 10, y1: 0, x2: 60, y2: 51, move: true, sight: false, door: 0 },
{ x1: 0, y1: 0, x2: 50, y2: 0, move: true, sight: true, door: 1 },
]);
});
test("a scene with no paired map answers notfound and changes no map", async () => {
const map = { _id: "map-1", campaign: "campaign-1", name: "Dungeon", foundrySceneId: "scene-1", walls: [{ x1: 0, y1: 0, x2: 50, y2: 50 }], save: async () => {} };
const api = loadSyncRoutes({ maps: [map] });
const response = await api.call("POST /sync/map-walls", asModule({
body: { worldId: "world-1", foundrySceneId: "scene-2", walls: [] },
}));
assert.equal(response.msg, "errors.notfound");
assert.equal(map.walls.length, 1);
});
test("the wall push needs the paired world, the scene and an array", async () => {
const map = { _id: "map-1", campaign: "campaign-1", name: "Dungeon", foundrySceneId: "scene-1", walls: [{ x1: 0, y1: 0, x2: 50, y2: 50 }], save: async () => {} };
const api = loadSyncRoutes({ maps: [map] });
const wrongWorld = await api.call("POST /sync/map-walls", asModule({ body: { worldId: "world-2", foundrySceneId: "scene-1", walls: [] } }));
const noScene = await api.call("POST /sync/map-walls", asModule({ body: { worldId: "world-1", walls: [] } }));
const noWalls = await api.call("POST /sync/map-walls", asModule({ body: { worldId: "world-1", foundrySceneId: "scene-1" } }));
assert.deepEqual([wrongWorld.msg, noScene.msg, noWalls.msg], ["errors.missing-data", "errors.missing-data", "errors.missing-data"]);
assert.equal(map.walls.length, 1);
});
test("an unauthenticated module hears nothing but unauthorized", async () => {
const api = loadSyncRoutes({ maps: [] });
const response = await api.call("GET /sync/maps", { get: () => "" });
assert.equal(response.msg, "unauthorized");
});
test("pairing a map with a scene records it, and one scene walls one map at most", async () => {
const maps = [
{ _id: "map-1", campaign: "campaign-1", name: "Dungeon", foundrySceneId: null, walls: [], save: async () => {} },
{ _id: "map-2", campaign: "campaign-1", name: "Crypt", foundrySceneId: "scene-1", walls: [], save: async () => {} },
];
const api = loadSyncRoutes({ maps });
const taken = await api.call("POST /sync/map-scene", asModule({ body: { worldId: "world-1", mapId: "map-1", foundrySceneId: "scene-1" } }));
assert.equal(taken.msg, "foundry.errors.scene-already-synced");
assert.equal(maps[0].foundrySceneId, null);
const paired = await api.call("POST /sync/map-scene", asModule({ body: { worldId: "world-1", mapId: "map-1", foundrySceneId: "scene-7" } }));
assert.equal(paired.status, "ok");
assert.equal(maps[0].foundrySceneId, "scene-7");
});
}
// --- The MapWalls service: snapping and drawing ---------------------------------------------
function loadMapWallsService() {
const source = readRepoFile("frontend", "app", "services", "MapWalls.js");
const body = source.replace(/export\s*\{/, "return {").concat("\n;");
return vm.compileFunction(body, [])();
}
function mapWallsServiceTests() {
const service = loadMapWallsService();
// 800x600 image, shown at 200% and panned so its top left corner sits at (20, 10) of the viewport.
const view = { zoom: 2, pan: { x: 20, y: 10 }, width: 800, height: 600 };
const grid = { gridSize: 50, offsetX: 10, offsetY: 0 };
test("a spot of the viewport becomes the image pixel it stands for, clamped but never refused", () => {
assert.deepEqual(service.ToDrawPoint({ x: 100, y: 50 }, view), { x: 40, y: 20 });
// A drag over the edge keeps drawing at the edge instead of dropping the wall.
assert.deepEqual(service.ToDrawPoint({ x: 0, y: 50 }, view), { x: 0, y: 20 });
assert.equal(service.ToDrawPoint({ x: 100, y: 50 }, { zoom: 0, pan: { x: 0, y: 0 } }), null);
});
test("endpoints snap to the nearest grid intersection, offset included", () => {
assert.deepEqual(service.SnapToGrid({ x: 112, y: 24 }, grid), { x: 110, y: 0 });
assert.deepEqual(service.SnapToGrid({ x: 112, y: 26 }, grid), { x: 110, y: 50 });
assert.deepEqual(service.SnapToGrid({ x: -8, y: -8 }, grid), { x: 0, y: 0 });
assert.equal(service.SnapToGrid(null, grid), null);
});
test("a wall becomes the screen line that draws it", () => {
assert.deepEqual(service.ToScreenWall({ x1: 40, y1: 20, x2: 90, y2: 70 }, view), { x1: 100, y1: 50, x2: 200, y2: 150 });
assert.deepEqual(service.ToScreenWall({}, view), { x1: 20, y1: 10, x2: 20, y2: 10 });
});
test("a slid wall keeps its shape and goes nowhere off the image", () => {
assert.deepEqual(service.MoveWall({ x1: 10, y1: 10, x2: 60, y2: 10 }, 13.4, -5.6), { x1: 23, y1: 4, x2: 73, y2: 4 });
assert.deepEqual(service.MoveWall({ x1: 5, y1: 5, x2: 5, y2: 55 }, -10, 0), { x1: 0, y1: 0, x2: 0, y2: 50 });
assert.equal(service.MoveWall({ x1: 0, y1: 0, x2: 5, y2: 5 }, "x", 0), null);
});
test("a segment with no length is no wall", () => {
assert.equal(service.IsWall({ x1: 40, y1: 40, x2: 41, y2: 40 }), true);
assert.equal(service.IsWall({ x1: 40, y1: 40, x2: 40, y2: 40 }), false);
assert.equal(service.IsWall(null), false);
assert.equal(service.IsWall({ x1: 0, y1: 0, x2: 0 }), false);
});
}
// --- The Foundry module: pairing scenes, trading wall sets -----------------------------------
function makeWallWorld({ autoSync = true, maps = [], scenes = [], pairedSceneIds = null } = {}) {
const state = {
hooks: new Map(),
registered: new Map(),
requests: [],
notifications: [],
timers: new Map(),
nextTimerId: 1,
maps,
embeddedWrites: [],
pairedSceneIds,
};
const settingsStore = {
autoSync,
syncToken: "sync-token-1",
dragonrollApiUrl: "http://backend.test:5000",
};
const sandbox = {
console: { log() {}, info() {}, warn() {}, error() {} },
URL,
CONFIG: {},
window: { location: { origin: "http://vtt.test" } },
ui: {
notifications: {
info: (text) => state.notifications.push(["info", text]),
warn: (text) => state.notifications.push(["warn", text]),
error: (text) => state.notifications.push(["error", text]),
},
},
Hooks: {
once(name, fn) { state.hooks.set(name, [fn]); },
on(name, fn) {
const handlers = state.hooks.get(name) || [];
handlers.push(fn);
state.hooks.set(name, handlers);
},
},
setTimeout: (fn, delay = 0) => {
const id = state.nextTimerId++;
state.timers.set(id, { fn, delay });
return id;
},
clearTimeout: (id) => state.timers.delete(id),
setInterval: () => 0,
clearInterval: () => {},
fetch: async (url, options = {}) => {
const href = String(url);
const body = options.body ? JSON.parse(options.body) : null;
state.requests.push({ href, method: options.method, body });
if (href.includes("foundry/sync/maps")) {
return { ok: true, status: 200, json: async () => ({ status: "ok", maps: state.maps }) };
}
if (href.includes("foundry/sync/map-walls") && state.pairedSceneIds
&& !state.pairedSceneIds.includes(body?.foundrySceneId)) {
return { ok: true, status: 200, json: async () => ({ status: "error", msg: "errors.notfound" }) };
}
return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [], folders: [] }) };
},
Actor: { async create() { return null; } },
Item: { async create() { return null; } },
};
sandbox.game = {
user: { isGM: true },
world: { id: "world-1", title: "Test World" },
system: { id: "dnd5e" },
modules: { get: () => ({}) },
actors: { contents: [], get: () => null },
items: { contents: [], get: () => null },
folders: { contents: [] },
scenes: { contents: scenes, get: (id) => scenes.find((scene) => scene.id === id) },
settings: {
register(module, key, definition) {
state.registered.set(key, definition);
if (!(key in settingsStore)) settingsStore[key] = definition.default;
},
get(module, key) { return settingsStore[key]; },
async set(module, key, value) {
settingsStore[key] = value;
await state.registered.get(key)?.onChange?.(value);
},
},
};
vm.createContext(sandbox);
vm.runInContext(readRepoFile("dragonroll-foundry", "scripts", "api.js"), sandbox);
state.game = sandbox.game;
// A scene holding Foundry-shape wall documents. Its embedded writes are recorded, and —
// like the real client — each one fires the scene's wall hooks while the write is under way.
state.makeScene = (id, name, walls = []) => {
const scene = {
id, name, documentName: "Scene",
wallDocuments: { contents: walls },
async updateEmbeddedDocuments(kind, updates) {
state.embeddedWrites.push([kind, "update", updates]);
for (const update of updates) {
const wall = walls.find((current) => current.id === update._id);
const { _id, ...rest } = update;
Object.assign(wall, rest);
}
await state.fireSync("updateWall", walls.map((wall) => ({ documentName: "Wall", id: wall.id, parent: scene })));
},
async createEmbeddedDocuments(kind, creates) {
state.embeddedWrites.push([kind, "create", creates]);
const created = creates.map((data, index) => ({ id: `${id}-wall-${index}`, ...data }));
walls.push(...created);
await state.fireSync("createWall", created.map((wall) => ({ documentName: "Wall", id: wall.id, parent: scene })));
},
async deleteEmbeddedDocuments(kind, ids) {
state.embeddedWrites.push([kind, "delete", ids]);
for (const documentId of ids) {
const index = walls.findIndex((wall) => wall.id === documentId);
if (index >= 0) walls.splice(index, 1);
}
await state.fireSync("deleteWall", ids.map((documentId) => ({ documentName: "Wall", id: documentId, parent: scene })));
},
};
return scene;
};
// Fire a wall hook through the sandboxed Hooks registry without awaiting each handler: the
// real client fires wall hooks synchronously while a write runs.
state.fireSync = (name, documents) => {
for (const handler of state.hooks.get(name) || []) {
for (const document of documents) handler(document);
}
};
state.fire = async (name, ...args) => {
for (const handler of state.hooks.get(name) || []) await handler(...args);
await drain();
};
state.runTimers = async () => {
for (let round = 0; round < 8; round += 1) {
if (!state.timers.size && round > 2) break;
const due = [...state.timers.values()];
state.timers.clear();
for (const timer of due) await timer.fn();
await drain();
}
};
async function drain() {
await new Promise((resolve) => setImmediate(resolve));
}
state.linkedSetup = async () => {
await state.fire("init");
await state.fire("ready");
await state.runTimers();
state.requests.length = 0;
state.embeddedWrites.length = 0;
return state;
};
state.wallPushes = () => state.requests.filter((request) => request.href.includes("foundry/sync/map-walls"));
state.scenePairings = () => state.requests.filter((request) => request.href.includes("foundry/sync/map-scene"));
return state;
}
function foundryModuleWallTests() {
test("a GM's wall edit pushes the scene's whole set, in the campaign's shape", async () => {
const scene = makeWallWorld().makeScene("scene-1", "Dungeon", [
{ id: "wall-1", c: [10.4, -3, 60, 50.5], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
{ id: "wall-2", c: [0, 0, 50, 0], light: 0, sense: 0, move: 0, door: 2, ds: 1 },
]);
const world = await scene.linkedSetup();
await world.fire("updateWall", { documentName: "Wall", id: "wall-2", parent: scene });
await world.runTimers();
const pushes = world.wallPushes();
assert.equal(pushes.length, 1);
assert.equal(pushes[0].body.foundrySceneId, "scene-1");
assert.deepEqual(pushes[0].body.walls, [
{ x1: 10, y1: 0, x2: 60, y2: 51, move: true, sight: true, door: 0 },
{ x1: 0, y1: 0, x2: 50, y2: 0, move: false, sight: false, door: 1 },
]);
assert.deepEqual(world.embeddedWrites, []);
});
test("the campaign's set lands on its paired scene: changed walls written, extra ones deleted", async () => {
const world = makeWallWorld({
maps: [{
_id: "map-1", name: "Dungeon", foundrySceneId: "scene-1",
walls: [
{ x1: 0, y1: 0, x2: 50, y2: 0, move: true, sight: true, door: 0 },
{ x1: 50, y1: 0, x2: 50, y2: 100, move: false, sight: true, door: 2 },
],
}],
scenes: [],
});
const scene = world.makeScene("scene-1", "Dungeon", [
{ id: "wall-1", c: [0, 0, 50, 0], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
{ id: "wall-2", c: [0, 0, 0, 80], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
{ id: "wall-3", c: [90, 90, 120, 90], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
]);
world.game.scenes.contents.push(scene);
await world.fire("init");
await world.fire("ready");
await world.runTimers();
// wall-1 already stands where the campaign wants it and is left alone; wall-2 is
// retyped into the campaign's second segment; wall-3 is beyond the set and goes.
const updates = world.embeddedWrites.find(([, kind, payload]) => kind === "update" && payload.length)?.[2];
assert.deepEqual(updates, [{
_id: "wall-2", c: [50, 0, 50, 100], light: 2, sense: 2, move: 0, door: 2, ds: 0,
}]);
const deletes = world.embeddedWrites.find(([, kind, payload]) => kind === "delete")?.[2];
assert.deepEqual(deletes, ["wall-3"]);
// The set landed on the scene is exactly the campaign's: it reads back unchanged, so the
// writes are not echoed to the campaign.
assert.deepEqual(world.wallPushes(), []);
});
test("a map with no walls adopts the walls the scene already has", async () => {
const world = makeWallWorld({
maps: [{ _id: "map-1", name: "Crypt", foundrySceneId: "scene-1", walls: [] }],
scenes: [],
});
const scene = world.makeScene("scene-1", "Crypt", [
{ id: "wall-1", c: [0, 0, 100, 0], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
]);
world.game.scenes.contents.push(scene);
await world.fire("init");
await world.fire("ready");
await world.runTimers();
const pushes = world.wallPushes();
assert.equal(pushes.length, 1);
assert.deepEqual(pushes[0].body.walls, [
{ x1: 0, y1: 0, x2: 100, y2: 0, move: true, sight: true, door: 0 },
]);
assert.deepEqual(world.embeddedWrites, []);
});
test("a campaign map pairs with the scene of its name, and only when it is the only one", async () => {
const paired = makeWallWorld({
maps: [{ _id: "map-1", name: "Dungeon", foundrySceneId: null, walls: [{ x1: 10, y1: 10, x2: 60, y2: 60 }] }],
scenes: [],
});
const scene = paired.makeScene("scene-1", "Dungeon", []);
paired.game.scenes.contents.push(scene);
await paired.fire("init");
await paired.fire("ready");
await paired.runTimers();
const pairings = paired.scenePairings();
assert.equal(pairings.length, 1);
assert.deepEqual(pairings[0].body, { worldId: "world-1", mapId: "map-1", foundrySceneId: "scene-1" });
// Paired, the campaign's wall lands as a new wall document on the scene.
const creates = paired.embeddedWrites.find(([, kind, payload]) => kind === "create")?.[2];
assert.deepEqual(creates, [{ c: [10, 10, 60, 60], light: 2, sense: 2, move: 1, door: 0, ds: 0 }]);
// Two scenes share the name: the map is nobody's by name alone, and nothing is paired or written.
const twin = makeWallWorld({
maps: [{ _id: "map-1", name: "Dungeon", foundrySceneId: null, walls: [{ x1: 10, y1: 10, x2: 60, y2: 60 }] }],
scenes: [],
});
twin.game.scenes.contents.push(twin.makeScene("scene-1", "Dungeon", []), twin.makeScene("scene-2", "Dungeon", []));
await twin.fire("init");
await twin.fire("ready");
await twin.runTimers();
assert.deepEqual(twin.scenePairings(), []);
assert.deepEqual(twin.embeddedWrites, []);
});
test("a scene no campaign map mirrors is let go of, not retried", async () => {
const world = makeWallWorld({ pairedSceneIds: [] });
const scene = world.makeScene("scene-9", "Not a map", [
{ id: "wall-1", c: [0, 0, 50, 50], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
]);
await world.linkedSetup();
world.game.scenes.contents.push(scene);
await world.fire("createWall", { documentName: "Wall", id: "wall-1", parent: scene });
await world.runTimers();
// The push was made once and, hearing the campaign keeps no map for this scene, the
// module stops asking about it again.
assert.equal(world.wallPushes().length, 1);
assert.deepEqual(world.notifications.filter(([kind]) => kind === "error"), []);
});
test("autosync off keeps walls at home, and on again reconciles them", async () => {
const world = makeWallWorld({ autoSync: false, scenes: [] });
const scene = world.makeScene("scene-1", "Dungeon", [
{ id: "wall-1", c: [0, 0, 50, 50], light: 2, sense: 2, move: 1, door: 0, ds: 0 },
]);
world.game.scenes.contents.push(scene);
await world.fire("init");
await world.fire("ready");
await world.runTimers();
await world.fire("updateWall", { documentName: "Wall", id: "wall-1", parent: scene });
await world.runTimers();
assert.deepEqual(world.wallPushes(), []);
assert.ok(!world.requests.some((request) => request.href.includes("foundry/sync/maps")));
await world.game.settings.set(MODULE_ID, "autoSync", true);
await world.runTimers();
assert.ok(world.requests.some((request) => request.href.includes("foundry/sync/maps")),
"the campaign's maps are asked for again");
});
}
// --- The map viewer: the editor's wiring -------------------------------------------------------
function mapViewerWiringTests() {
const pane = readRepoFile("frontend", "app", "components", "viewer", "map", "MapViewerPane.vue");
test("the viewer bar opens the wall editor", () => {
assert.match(pane, /:aria-pressed="editingWalls\.toString\(\)" @click="toggleWallEditing"/);
assert.match(pane, /\$t\('campaigns\.map\.walls\.edit'\)/);
});
test("walls are drawn in screen space and only the editor's hit areas catch the mouse", () => {
assert.match(pane, /class="wall-line"[^>]*:class="wallClasses\(wall\)"[^>]*v-bind="wallScreen\(wall\)"/);
assert.match(pane, /\.map-walls\s*\{[^}]*pointer-events:\s*none/);
assert.match(pane, /\.wall-hit\s*\{[^}]*pointer-events:\s*stroke/);
});
test("every wall edit saves the whole set through /map/walls", () => {
assert.match(pane, /updateMap\('\/map\/walls'/);
// A held drag stays local until the pointer lets go, and a wall keeps its _id through saves.
assert.match(pane, /_id: String\(wall\._id\)/);
assert.match(pane, /if \(IsWall\(segment\)\) await saveWalls\(\[\.\.\.walls\.value, segment\]\)/);
});
test("drawn endpoints snap to the grid, like Foundry's wall tool", () => {
assert.match(pane, /import \{ IsWall, MoveWall, SnapToGrid, ToDrawPoint, ToScreenWall \} from '~\/services\/MapWalls'/);
assert.match(pane, /SnapToGrid\(spot, grid\.value\)/);
});
test("a wall answers the mouse and the keyboard", () => {
assert.match(pane, /@contextmenu\.stop\.prevent="onWallContextMenu\(wall\)"/);
assert.match(pane, /@keydown="onWallKeydown\(\$event, wall\)"/);
assert.match(pane, /Delete.*removeWall|removeWall/);
assert.match(pane, /event\.key !== 'Escape'[\s\S]*drawingWall\.value = null/);
});
}
wallSaveRouteTests();
syncRoutesTests();
mapWallsServiceTests();
foundryModuleWallTests();
mapViewerWiringTests();