Fix #100: Add walls to maps #105

Closed
Agent wants to merge 1 commits from ai/issue-100 into master
13 changed files with 1546 additions and 1 deletions

View File

@@ -27,6 +27,19 @@ 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
// of the image, like a pin — and the very space Foundry draws a scene's walls in, so a paired
// scene and map trade them as they stand. `move`/`sight` say what passes through the segment, and
// `door` is 0 (not a door), 1 (open) or 2 (closed), following Foundry's own wall values.
walls: [{
x1: { type: Number, default: 0 },
y1: { type: Number, default: 0 },
x2: { type: Number, default: 0 },
y2: { type: Number, default: 0 },
move: { type: Boolean, default: true },
sight: { type: Boolean, default: true },
door: { type: Number, min: 0, max: 2, default: 0 }
}],
campaign: { campaign: {
type: Schema.Types.ObjectId, type: Schema.Types.ObjectId,
ref: 'Campaign', ref: 'Campaign',
@@ -39,7 +52,16 @@ 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
// routes/foundry-link.js): the whole wall set of one is the whole wall set of the other.
foundrySceneId: { type: String },
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,6 +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.
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');
const { joinFoundryAssetUrl } = require('../services/foundry-icons'); const { joinFoundryAssetUrl } = require('../services/foundry-icons');
@@ -477,6 +479,103 @@ router.post('/sync/map-item', async (req, res) => {
} }
}); });
// --- Scene walls -----------------------------------------------------------
// A campaign map can mirror the walls of a Foundry scene: the whole set travels whoever edits
// it, so the map's editor and the scene's wall tool see the same segments. A map is paired with
// 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 {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const maps = await MapModel.find({ campaign: campaign._id })
.select('_id name image foundrySceneId walls')
.sort({ name: 1 })
.lean();
res.json({ status: 'ok', maps });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/sync/map-scene', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const { mapId, foundrySceneId, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !mapId || !foundrySceneId) {
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) {
console.error(err);
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
// world's item folders take over the campaign's tree. A scene the campaign has no map paired
// with answers `notfound` — most scenes are none of the campaign's business.
router.post('/sync/map-walls', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const { foundrySceneId, walls, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !foundrySceneId || !Array.isArray(walls)) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const map = await MapModel.findOne({ campaign: campaign._id, foundrySceneId: String(foundrySceneId).trim() });
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
map.walls = walls.map(toSyncedWall).filter(Boolean);
await map.save();
res.json({ status: 'ok', map: { _id: map.id } });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router; module.exports = router;
// The writers every Foundry document goes through: the sync pushes above, and the // The writers every Foundry document goes through: the sync pushes above, and the
// force import a campaign asks for from its sidebar (routes/foundry.js). One set of // force import a campaign asks for from its sidebar (routes/foundry.js). One set of

View File

@@ -238,4 +238,50 @@ 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
// once — drawing, moving, re-typing and taking off segments are all the same request — and a paired
// Foundry scene takes that set whole too, so the set is the contract on both sides. Endpoints are
// image pixels like a pin's, and a wall keeps the `_id` it is sent with when one of the current
// 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 = {
x1: toCoordinate(source.x1),
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();
if (id && currentWalls.some((current) => String(current?._id) === id)) wall._id = id;
return wall;
}
router.post('/walls', async (req, res) => {
try {
const { id, walls } = req.body;
if (!id || !Array.isArray(walls)) 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 currentWalls = Array.from(map.walls ?? []);
map.walls = walls.map((source) => toStoredWall(source, currentWalls)).filter(Boolean);
await map.save();
res.json({ status: 'ok', map });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router; module.exports = router;

View File

@@ -36,6 +36,11 @@ 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;
let mapSyncRunning = false;
let mapSyncErrorLogged = false;
const queuedWallSceneIds = new Set();
const applyingWallsSceneIds = new Set();
function getCollectionContents(collection, collectionName) { function getCollectionContents(collection, collectionName) {
if (!collection) { if (!collection) {
@@ -300,6 +305,7 @@ 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";
@@ -441,6 +447,7 @@ function handleAutoSyncChange(value) {
clearTimeout(actorSyncTimeout); clearTimeout(actorSyncTimeout);
clearTimeout(itemSyncTimeout); clearTimeout(itemSyncTimeout);
clearTimeout(folderSyncTimeout); clearTimeout(folderSyncTimeout);
clearTimeout(wallSyncTimeout);
return; return;
} }
if (!game.user?.isGM || !getSyncToken()) return; if (!game.user?.isGM || !getSyncToken()) return;
@@ -450,6 +457,7 @@ function handleAutoSyncChange(value) {
initializeCharacterSync(); initializeCharacterSync();
reconcileDragonrollItems(); reconcileDragonrollItems();
queueFoundryItemFolders(400); queueFoundryItemFolders(400);
reconcileDragonrollMaps();
if (queuedActorChanges.size) { if (queuedActorChanges.size) {
clearTimeout(actorSyncTimeout); clearTimeout(actorSyncTimeout);
actorSyncTimeout = setTimeout(flushActorChanges, 400); actorSyncTimeout = setTimeout(flushActorChanges, 400);
@@ -458,6 +466,10 @@ 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) {
@@ -918,6 +930,239 @@ 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",
@@ -1448,6 +1693,8 @@ 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);
setInterval(reconcileDragonrollMaps, 5000);
for (const event of [ for (const event of [
"createActor", "updateActor", "deleteActor", "createActor", "updateActor", "deleteActor",
@@ -1481,6 +1728,13 @@ 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,
// debounced like the item changes: dragging a wall fires an update per move.
// Scenes no campaign map mirrors answer `notfound`, and the queue lets those go.
for (const event of ["createWall", "updateWall", "deleteWall"]) {
Hooks.on(event, (...args) => queueFoundrySceneWalls(...args));
}
}); });
// 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

@@ -5,6 +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 { 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';
@@ -114,6 +115,18 @@ 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) {
// While the wall editor is open the left pointer draws instead of panning: the wheel and
// 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 };
@@ -121,13 +134,28 @@ function onPointerDown(event) {
} }
function onPointerMove(event) { function onPointerMove(event) {
if (drawingWall.value && event.pointerId === pointerId) {
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 };
} }
function onPointerUp(event) { async function onPointerUp(event) {
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);
@@ -503,6 +531,215 @@ 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 ---
// The wall editor: with walls on, dragging over the map draws a segment from one grid intersection
// to the next, dragging an endpoint retypes it, dragging the segment itself moves it, and right
// clicking one (or Delete on a focused one) opens its controls and takes it off. Walls are stored
// 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.
const walls = computed(() => map.value?.walls ?? []);
const editingWalls = ref(false);
// The wall a pointer is holding: a new segment being dragged, the whole segment being slid, or one
// endpoint being retyped. Like a token's move, the change stays local until the pointer lets go,
// so a drag across the map is one save and not one per mouse move.
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']];
let wallDragPointerId = null;
let lastWallDrag = { x: 0, y: 0 };
function toggleWallEditing() {
editingWalls.value = !editingWalls.value;
if (!editingWalls.value) {
drawingWall.value = null;
draggingWall.value = null;
draggingEnd.value = null;
selectedWall.value = null;
}
}
// The spot of the viewport in image pixels, clamped to the image: while a wall is being held the
// pointer may cross an edge, and the wall should stay on the map rather than vanish.
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) {
if (String(selectedWall.value) === String(wall?._id)) selectedWall.value = null;
await saveWalls(walls.value.filter((current) => String(current?._id) !== String(wall?._id)));
}
function onWallPointerDown(event, wall) {
// The segment is what is being held here: the map must not start panning under the pointer.
event.stopPropagation();
if (event.button !== 0) return;
wallDragPointerId = event.pointerId;
event.currentTarget.setPointerCapture?.(event.pointerId);
lastWallDrag = { x: event.clientX, y: event.clientY };
selectedWall.value = String(wall?._id ?? '');
draggingWall.value = { wall, dx: 0, dy: 0 };
}
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) {
if (!draggingWall.value || event.pointerId !== wallDragPointerId) return;
const { wall, dx, dy } = draggingWall.value;
wallDragPointerId = null;
draggingWall.value = null;
event.currentTarget?.releasePointerCapture?.(event.pointerId);
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) {
event.stopPropagation();
if (event.button !== 0) return;
wallDragPointerId = event.pointerId;
event.currentTarget.setPointerCapture?.(event.pointerId);
selectedWall.value = String(wall?._id ?? '');
draggingEnd.value = { wall, end, point: { x: Number(wall[END_KEYS[end][0]]), y: Number(wall[END_KEYS[end][1]]) } };
}
function onWallEndPointerMove(event) {
if (!draggingEnd.value || event.pointerId !== wallDragPointerId) return;
const spot = wallSpot(event);
const snapped = spot && SnapToGrid(spot, grid.value);
if (!snapped) return;
draggingEnd.value = { ...draggingEnd.value, point: snapped };
}
async function onWallEndPointerUp(event) {
if (!draggingEnd.value || event.pointerId !== wallDragPointerId) return;
const { wall, end, point } = draggingEnd.value;
wallDragPointerId = null;
draggingEnd.value = null;
event.currentTarget?.releasePointerCapture?.(event.pointerId);
const [keyX, keyY] = END_KEYS[end];
if (point.x === Number(wall[keyX]) && point.y === Number(wall[keyY])) return;
const retyped = { ...wall, [keyX]: point.x, [keyY]: point.y };
// Retyped into its own end, the segment has no length left: the wall is gone.
if (!IsWall(retyped)) await removeWall(wall);
else await replaceWall(wall, { [keyX]: point.x, [keyY]: point.y });
}
function onWallContextMenu(wall) {
selectedWall.value = String(wall?._id ?? '');
ShowContextMenu([
{
name: t(wall.sight ? 'campaigns.map.walls.sight-open' : 'campaigns.map.walls.sight-block'),
icon: '/icons/iconoir/regular/eye.svg',
action: () => { HideContextMenu(); replaceWall(wall, { sight: !wall.sight }); }
},
{
name: t(wall.move ? 'campaigns.map.walls.move-open' : 'campaigns.map.walls.move-block'),
icon: '/icons/iconoir/regular/lock.svg',
action: () => { HideContextMenu(); replaceWall(wall, { move: !wall.move }); }
},
{
name: t('campaigns.map.walls.door'),
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); }
}
]);
}
// A focused wall answers Delete too, the way a focused token does.
async function onWallKeydown(event, wall) {
if (event.key !== 'Delete' && event.key !== 'Backspace') return;
event.preventDefault();
await removeWall(wall);
}
// Escape lets go of whatever the editor is holding: an unfinished segment first, the selection next.
function onWindowKeydown(event) {
if (event.key !== 'Escape') return;
if (drawingWall.value) drawingWall.value = null;
else if (selectedWall.value) selectedWall.value = null;
}
// 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) => {
if (incoming === previous) return; if (incoming === previous) return;
@@ -510,6 +747,10 @@ 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;
drawingWall.value = null;
draggingWall.value = null;
draggingEnd.value = null;
selectedWall.value = null;
}); });
watch(campaignId, () => { watch(campaignId, () => {
@@ -525,6 +766,7 @@ 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();
}); });
@@ -535,6 +777,7 @@ 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>
@@ -550,6 +793,10 @@ 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')"
:aria-label="$t('campaigns.map.walls.edit')" :aria-pressed="editingWalls.toString()" @click="toggleWallEditing">
<img class="tool-icon" src="/icons/iconoir/regular/border-out.svg" alt="" aria-hidden="true">
</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">
</button> </button>
@@ -587,6 +834,42 @@ 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
zoom. They only catch the mouse while the editor is open, and never when there
is no image to hold them. -->
<svg v-if="imageUrl && (walls.length || drawingWall || editingWalls)" class="map-walls" :class="{ editing: editingWalls }">
<g v-for="wall in walls" :key="wall._id">
<line class="wall-line" :class="wallClasses(wall)" v-bind="wallScreen(wall)"></line>
<template v-if="editingWalls">
<line
class="wall-hit"
role="button"
tabindex="0"
:aria-label="$t('campaigns.map.walls.wall')"
v-bind="wallScreen(wall)"
@pointerdown="onWallPointerDown($event, wall)"
@pointermove="onWallPointerMove"
@pointerup="onWallPointerUp"
@pointercancel="onWallPointerUp"
@contextmenu.stop.prevent="onWallContextMenu(wall)"
@keydown="onWallKeydown($event, wall)"
></line>
<circle
v-for="end in [0, 1]"
: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"
@@ -629,6 +912,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>
</template> </template>
<div v-else class="map-empty"> <div v-else class="map-empty">
{{ $t('campaigns.map.no-image') }} {{ $t('campaigns.map.no-image') }}
@@ -699,6 +983,27 @@ 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,87 @@
// 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

@@ -111,6 +111,16 @@
"drop-hint": "Deixa anar per posar l'actor en aquest mapa", "drop-hint": "Deixa anar per posar l'actor en aquest mapa",
"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."
},
"walls": {
"edit": "Edita murs",
"hint": "Arrossega sobre el mapa per dibuixar un mur · arrossega'n els extrems per canviar-lo, el cos per moure'l",
"wall": "Mur",
"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,6 +4,7 @@
"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

@@ -115,6 +115,16 @@
"drop-hint": "Drop to place the actor on this map", "drop-hint": "Drop to place the actor on this map",
"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."
},
"walls": {
"edit": "Edit walls",
"hint": "Drag on the map to draw a wall · drag its ends to retype it, its body to move it",
"wall": "Wall",
"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,6 +4,7 @@
"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

@@ -111,6 +111,16 @@
"drop-hint": "Suelta para colocar al actor en este mapa", "drop-hint": "Suelta para colocar al actor en este mapa",
"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."
},
"walls": {
"edit": "Editar muros",
"hint": "Arrastra sobre el mapa para dibujar un muro · arrastra sus extremos para cambiarlo, su cuerpo para moverlo",
"wall": "Muro",
"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,6 +4,7 @@
"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.",

699
tests/map-walls.test.js Normal file
View File

@@ -0,0 +1,699 @@
// 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();