1 Commits

Author SHA1 Message Date
Gitea OpenCode Agent
07dcf08616 Fix issue #98: Sync notes from dragonroll to foundry
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 23:19:43 +00:00
22 changed files with 757 additions and 1526 deletions

View File

@@ -83,7 +83,7 @@ campaign, and handlers check ownership with a `userOwnsCampaign(campaignId, user
- `User` — `name*`, `username*`, `email*` (both unique), `password` (bcrypt, 10 rounds), `admin`, `image`, `setupCode`, `settings`
- `Campaign` — `name*`, `createdBy*`→User, `description`, `color`, `settings`, `foundryWorldId`/`foundryWorldTitle`/`foundrySystem`, `foundrySyncTokenHash` (`select: false`), `discordGuildId`
- `Note` — `title`, `content` (markdown source), `campaign*`, `folder` (null = root), `color`
- `Note` — `title`, `content` (markdown source), `campaign*`, `folder` (null = root), `color`, `foundryPageId`
- `Folder` — `name*`, `campaign*`, `parentFolder` (null = root, self-ref), `color`
- `Actor` — `name*`, `campaign*`, `foundryActorId` (unique per campaign), `discordUserId` (the Discord player holding the character, unique per campaign — set only by `routes/discord.js`), plus free-form sheet fields (`type`, `species`, `className`, `level`, `abilityScores`, `armorClass`, `speed`, `proficiencies`, `traits`, `spells`, `image`) and `inventory[{name,quantity,weight}]` (flattened Foundry items, **not** `Item` docs)
- `Item` — `name*`, `campaign*`, `foundryItemId` (unique per campaign), `foundryNames`, `category`, `rarity`, `quantity`, `weight`, `properties`, `description`
@@ -114,11 +114,13 @@ rest, expire after 10 min, and Obsidian gets a long-lived (365 d) token back.
Foundry then syncs with that token on `/api/foundry/sync/*` (`routes/foundry-link.js`, mounted before
the JWT guard; CORS opened for it): `snapshot` (actors + world items, `fullSync` also prunes),
`item-snapshot`, `item-delete`, `characters`, `items`, `status`, `map` / `map-item`, `delete`. Rules:
`item-snapshot`, `item-delete`, `characters`, `items`, `notes` / `map-note`, `status`,
`map` / `map-item`, `delete`. Rules:
- **Identity** is `foundryActorId` / `foundryItemId` (unique per campaign, partial index); a Foundry document carrying the `dragonroll-foundry.actorId` / `.itemId` flag adopts the matching Dragonroll row.
- **Only the world's item directory reaches the item list** (Syndria98/dragonroll#67) — `snapshotItemSources` reads `body.items` (`game.items`) alone; gear embedded in a character is that actor's `inventory` (see the `Actor` model), not an `Item`. A world item still folds into a hand-made or renamed row it matches by name (`foundryNames`), so a rename does not resurrect a duplicate. `services/item-foundry.js` returns `null` for non-gear types and those are skipped.
- **Item folders mirror the world's item directory** (`Folder.foundryFolderId`, target `item`): every push carries the whole tree and the world owns its names and nesting. `color` is the one field the campaign sets too, so it travels back with the folders `GET /foundry/sync/items` answers with (`{items, folders}`) and the module writes it onto the world's folder.
- **Notes reach the world as journal pages, one way** (Syndria98/dragonroll#98): the module reads `GET /sync/notes` and stands every campaign note as a page of one world `JournalEntry` named Dragonroll — the page carries the note's id in a `dragonroll-foundry.noteId` flag, the note keeps the page's id in `foundryPageId` (`POST /sync/map-note`). The reconcile rewrites pages from the notes and drops the page of a deleted note; journal edits never travel back.
- **`fullSync` preserves Dragonroll edits** (only new rows are overwritten); live Foundry events overwrite. Only a full snapshot can prune.
- **Autosync is a Foundry-side setting** (`autoSync`, on by default): off = no CRUD push, no periodic reconcile, no startup snapshot; the actor directory's *Dragonroll: Force Sync* still upserts the selection (`fullSync:false`).
- `GET /api/foundry/*` (`routes/foundry.js`) is unrelated: a JWT-protected proxy over the read-only bridge. Its one write, `POST /import`, pulls the bridge's actors or world items into the campaign through the same writers as a sync push.

View File

@@ -27,19 +27,6 @@ const MapSchema = new Schema({
x: { 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: {
type: Schema.Types.ObjectId,
ref: 'Campaign',
@@ -52,16 +39,7 @@ const MapSchema = new Schema({
ref: 'Folder',
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 }
});
// 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);

View File

@@ -14,7 +14,16 @@ const NoteSchema = new Schema({
ref: 'Folder'
},
color: { type: String },
// The journal page this note is written as in the linked Foundry world: the
// page of the one "Dragonroll" journal whose rows carry this note's id in
// their `dragonroll-foundry.noteId` flag (see the module's notes sync).
foundryPageId: { type: String },
date: { type: Date, default: Date.now }
});
NoteSchema.index(
{ campaign: 1, foundryPageId: 1 },
{ unique: true, partialFilterExpression: { foundryPageId: { $type: 'string' } } }
);
module.exports = mongoose.model('Note', NoteSchema);

View File

@@ -7,8 +7,7 @@ const Campaign = require('../models/Campaign');
const Actor = require('../models/Actor');
const Item = require('../models/Item');
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 Note = require('../models/Note');
const { foundryActorToCharacter } = require('../services/actor-foundry');
const { foundryItemToItemData } = require('../services/item-foundry');
const { joinFoundryAssetUrl } = require('../services/foundry-icons');
@@ -479,97 +478,51 @@ 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.
// --- Note pages ------------------------------------------------------------
// The campaign's notes are read where their authors' table sits: every note
// stands as a page of the one journal the world calls "Dragonroll". Notes are
// written in Dragonroll, so this copy runs one way — the module reads the notes
// and rewrites their pages; nothing of the journal travels back. Its pages keep
// the note's id in a `dragonroll-foundry.noteId` flag, and the note keeps the
// page's id here, so either side recognises the pairing again after a restart.
// 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) => {
// Every note of the campaign, content included: enough for the module to write
// each one as a page. Folders of the notes do not travel — the journal is flat.
router.get('/sync/notes', 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 })
const notes = await Note.find({ campaign: campaign._id })
.select('_id title content foundryPageId date')
.sort({ date: -1 })
.lean();
res.json({ status: 'ok', maps });
res.json({ status: 'ok', notes });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/sync/map-scene', async (req, res) => {
// The page the module made for a note, kept on the note so the next reconcile —
// or a world whose page flags were lost — writes that page instead of a second
// one under the same title.
router.post('/sync/map-note', 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) {
const { noteId, foundryPageId, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !noteId || !foundryPageId) {
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' });
const note = await Note.findOne({ _id: noteId, campaign: campaign._id });
if (!note) return res.json({ status: 'error', msg: 'errors.notfound' });
const existing = await Note.findOne({ campaign: campaign._id, foundryPageId, _id: { $ne: note._id } });
if (existing) return res.json({ status: 'error', msg: 'foundry.errors.note-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 } });
note.foundryPageId = String(foundryPageId).trim().slice(0, 120);
await note.save();
res.json({ status: 'ok', note });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });

View File

@@ -238,50 +238,4 @@ 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;

View File

@@ -105,6 +105,17 @@ else (Syndria98/dragonroll#67):
the whole world directory and can tell which synced rows it has let go of. Deleting a synced item in
Dragonroll removes its Foundry world copy on the next reconcile.
### Notes
The campaign's notes read like the campaign's journal in the world (Syndria98/dragonroll#98): every
note stands as a page of one JournalEntry named **Dragonroll**. The module creates that journal — or
adopts one the GM already made under that name, marking it as the notes' journal — and renders each
note's markdown into page HTML with Foundry's own renderer. Notes are written in Dragonroll, so this
copy runs one way: a note made or edited in the campaign rewrites its page on the next reconcile, and
a note deleted there takes its page with it. Pages the campaign does not own — the GM's own pages in
that journal — are left alone, and nothing written in the journal travels back. Autosync off stops it
too, like the rest of the sync.
The module calls these Dragonroll routes with the campaign sync token (no Dragonroll login):
| Route | Use |
@@ -114,12 +125,16 @@ The module calls these Dragonroll routes with the campaign sync token (no Dragon
| `POST /api/foundry/sync/item-delete` | A world item was deleted |
| `GET /api/foundry/sync/characters` | Characters to apply back in Foundry |
| `GET /api/foundry/sync/items` | Items, and the item folders with their Dragonroll colours, to apply back in Foundry |
| `GET /api/foundry/sync/notes` | The campaign's notes, markdown and all, and the journal page each stands as |
| `POST /api/foundry/sync/map-note` | Store a note's journal page id after creating that page |
| `GET /api/foundry/sync/status` | The campaign this world's token belongs to, for the module's pairing status |
| `POST /api/foundry/sync/map` / `map-item` | Store an id mapping after creating a document |
| `POST /api/foundry/sync/delete` | An actor was deleted |
Foundry documents keep the Dragonroll id in the `dragonroll-foundry.actorId` / `dragonroll-foundry.itemId`
flag, and world items are marked with `dragonroll-foundry.syncMutation` while Dragonroll writes them so
flag, and a journal page the module made for a note keeps its note's id in the `dragonroll-foundry.noteId`
flag, so the notes reconcile recognises its own pages. World items are marked with
`dragonroll-foundry.syncMutation` while Dragonroll writes them so
the write is not echoed back. A folder colour is written with that folder held in the client's set of
folders being synced, for the same reason.

View File

@@ -2,7 +2,7 @@
"id": "dragonroll-foundry",
"title": "Dragonroll Foundry API",
"description": "Links a Foundry world to a Dragonroll campaign and exposes a client-side API for world data.",
"version": "0.4.0",
"version": "0.5.0",
"library": true,
"compatibility": {
"minimum": "12",

View File

@@ -36,11 +36,6 @@ let folderSyncRunning = false;
const syncingItemIds = new Set();
const syncingFolderIds = new Set();
const queuedItemChanges = new Map();
let wallSyncTimeout;
let mapSyncRunning = false;
let mapSyncErrorLogged = false;
const queuedWallSceneIds = new Set();
const applyingWallsSceneIds = new Set();
function getCollectionContents(collection, collectionName) {
if (!collection) {
@@ -305,7 +300,6 @@ async function applyDragonrollLink(result) {
scheduleSnapshotSync(0);
setTimeout(initializeCharacterSync, 0);
setTimeout(reconcileDragonrollItems, 2000);
setTimeout(reconcileDragonrollMaps, 2500);
} else {
// 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";
@@ -447,7 +441,6 @@ function handleAutoSyncChange(value) {
clearTimeout(actorSyncTimeout);
clearTimeout(itemSyncTimeout);
clearTimeout(folderSyncTimeout);
clearTimeout(wallSyncTimeout);
return;
}
if (!game.user?.isGM || !getSyncToken()) return;
@@ -457,7 +450,7 @@ function handleAutoSyncChange(value) {
initializeCharacterSync();
reconcileDragonrollItems();
queueFoundryItemFolders(400);
reconcileDragonrollMaps();
reconcileDragonrollNotes();
if (queuedActorChanges.size) {
clearTimeout(actorSyncTimeout);
actorSyncTimeout = setTimeout(flushActorChanges, 400);
@@ -466,10 +459,6 @@ function handleAutoSyncChange(value) {
clearTimeout(itemSyncTimeout);
itemSyncTimeout = setTimeout(flushItemChanges, 400);
}
if (queuedWallSceneIds.size) {
clearTimeout(wallSyncTimeout);
wallSyncTimeout = setTimeout(flushFoundrySceneWalls, 400);
}
}
function dragonrollActorId(actor) {
@@ -930,239 +919,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 = {
weapon: "weapon",
armor: "equipment",
@@ -1601,6 +1357,157 @@ function queueFoundryActorChange(kind, actor) {
queueActorChange(kind, actor);
}
// --- Note pages ------------------------------------------------------------
// The campaign's notes read like the campaign's journal in the world: every note
// stands as a page of one JournalEntry named "Dragonroll". Notes are written in
// Dragonroll, so this copy runs one way — the reconcile writes each note into its
// page and drops the page of a note the campaign deleted. Nothing of the journal
// is read back, and the GM's own pages in that journal are left alone: only the
// ones this module made carry the `dragonroll-foundry.noteId` flag.
const NOTES_JOURNAL_NAME = "Dragonroll";
let noteSyncRunning = false;
let noteSyncErrorLogged = false;
function dragonrollNoteId(page) {
return page.getFlag?.(MODULE_ID, "noteId") || page.flags?.[MODULE_ID]?.noteId || "";
}
// A note is markdown, a journal page is HTML. Foundry's own renderer keeps the
// page readable in the journal and in its styles; where this Foundry does not
// offer one, escaped paragraphs keep the text legible until it does.
function notePageHtml(content) {
const markdown = String(content ?? "");
if (!markdown.trim()) return "";
if (typeof TextEditor !== "undefined" && typeof TextEditor._getMarkdown === "function") {
const html = TextEditor._getMarkdown(markdown);
if (html) return html;
}
return markdown
.split(/\n\s*\n/)
.map((block) => `<p>${escapeNoteHtml(block.trim()).replace(/\n/g, "<br />")}</p>`)
.join("\n");
}
function escapeNoteHtml(value) {
return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
}
function notePageTitle(entry) {
return String(entry.title || "").trim() || "Untitled note";
}
// The journal this module writes the campaign's notes into: the one it flagged as
// its own, or one the GM already made under that name. An unflagged one is
// flagged on use, so renaming it afterwards still leaves the notes' home findable.
function notesJournal() {
const journals = game.journals?.contents || [];
return journals.find((journal) => journal.getFlag?.(MODULE_ID, "notesJournal"))
|| journals.find((journal) => journal.name === NOTES_JOURNAL_NAME)
|| null;
}
async function ensureNotesJournal() {
const existing = notesJournal();
if (existing) {
if (!existing.getFlag?.(MODULE_ID, "notesJournal")) {
await existing.update({ [`flags.${MODULE_ID}.notesJournal`]: true });
}
return existing;
}
const created = await JournalEntry.create(
{ name: NOTES_JOURNAL_NAME, flags: { [MODULE_ID]: { notesJournal: true } } },
{ renderSheet: false },
);
return Array.isArray(created) ? created[0] : created;
}
// The page a note stands as: rewrite what the campaign changed, and claim a page
// the campaign mapped by id but whose flag was lost.
async function applyDragonrollNotePage(page, entry) {
const title = notePageTitle(entry);
const html = notePageHtml(entry.content);
const updates = {};
if (String(page.title?.text ?? page.title ?? "") !== title) updates["title.text"] = title;
if (String(page.text?.content ?? "") !== html) updates["text.content"] = html;
if (!dragonrollNoteId(page)) updates[`flags.${MODULE_ID}.noteId`] = String(entry._id);
if (Object.keys(updates).length) await page.update(updates);
}
async function createDragonrollNotePage(journal, entry) {
const pages = await journal.createEmbeddedDocuments("JournalEntryPage", [{
title: { text: notePageTitle(entry) },
text: { content: notePageHtml(entry.content) },
flags: { [MODULE_ID]: { noteId: String(entry._id) } },
}], { renderSheet: false });
return Array.isArray(pages) ? pages[0] : pages;
}
async function mapDragonrollNote(noteId, foundryPageId) {
const token = getSyncToken();
return postDragonroll("foundry/sync/map-note", {
worldId: game.world.id,
noteId: String(noteId),
foundryPageId: String(foundryPageId),
}, token);
}
function reportNoteSyncError(error) {
if (noteSyncErrorLogged) return;
noteSyncErrorLogged = true;
console.warn(`${MODULE_ID} | Note journal sync failed and will retry.`, error);
}
async function reconcileDragonrollNotes() {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || noteSyncRunning || !isAutoSyncEnabled()) return;
noteSyncRunning = true;
try {
const result = await getDragonroll("foundry/sync/notes", token);
const remoteNotes = result.notes || [];
// A campaign without notes gets no journal of its own — but one it once had
// stays, so the pages of notes it deleted can go with them.
if (!remoteNotes.length && !notesJournal()) return;
const journal = await ensureNotesJournal();
if (!journal) return;
const remoteById = new Map(remoteNotes.map((entry) => [String(entry._id), entry]));
const localByRemoteId = new Map((journal.pages?.contents || [])
.map((page) => [String(dragonrollNoteId(page)), page])
.filter(([noteId]) => noteId));
const retainedPageIds = new Set();
for (const entry of remoteNotes) {
let page = entry.foundryPageId ? journal.pages?.get(entry.foundryPageId) : null;
if (!page) page = localByRemoteId.get(String(entry._id));
if (page) {
retainedPageIds.add(page.id);
await applyDragonrollNotePage(page, entry);
if (!entry.foundryPageId) await mapDragonrollNote(entry._id, page.id);
} else {
const created = await createDragonrollNotePage(journal, entry);
if (created) {
retainedPageIds.add(created.id);
await mapDragonrollNote(entry._id, created.id);
}
}
}
// Pages whose note the campaign deleted go with it. Only pages this module
// made are its business: an unflagged page is the GM's own.
for (const page of journal.pages?.contents || []) {
const noteId = dragonrollNoteId(page);
if (!noteId || retainedPageIds.has(page.id) || remoteById.has(String(noteId))) continue;
await page.delete();
}
noteSyncErrorLogged = false;
} catch (error) {
reportNoteSyncError(error);
} finally {
noteSyncRunning = false;
}
}
async function publishSnapshot() {
if (!game.user?.isGM || !game.world) return;
if (syncInProgress) {
@@ -1693,8 +1600,10 @@ Hooks.once("ready", () => {
// already seen the world directory when it starts sending its own items back.
setTimeout(reconcileDragonrollItems, 2000);
setInterval(reconcileDragonrollItems, 5000);
setTimeout(reconcileDragonrollMaps, 2500);
setInterval(reconcileDragonrollMaps, 5000);
// The campaign's notes arrive as pages of the world's Dragonroll journal on
// the same rhythm: a note written in the app is on the journal within seconds.
setTimeout(reconcileDragonrollNotes, 3000);
setInterval(reconcileDragonrollNotes, 5000);
for (const event of [
"createActor", "updateActor", "deleteActor",
@@ -1728,13 +1637,6 @@ Hooks.once("ready", () => {
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

View File

@@ -5,7 +5,6 @@ import { ClearWindow, CreateWindow, GetFirstWindowId } from '@/services/Windows'
import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu';
import { BuildNoteOptions, OptionLabel, ToImagePoint, ToScreenPoint } from '~/services/MapPins';
import { ActorDragId, CellCentre, IsActorDrag, MoveByCells, TokenSize } from '~/services/MapTokens';
import { IsWall, MoveWall, SnapToGrid, ToDrawPoint, ToScreenWall } from '~/services/MapWalls';
import { DisplayToast } from '~/services/Toaster';
import Server, { getBaseUrl } from '~/services/Server';
import { emitter } from '~/services/Emitter';
@@ -115,18 +114,6 @@ let lastPointer = { x: 0, y: 0 };
function onPointerDown(event) {
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;
pointerId = event.pointerId;
lastPointer = { x: event.clientX, y: event.clientY };
@@ -134,28 +121,13 @@ function onPointerDown(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;
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 };
}
async function onPointerUp(event) {
function onPointerUp(event) {
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;
pointerId = null;
viewport.value?.releasePointerCapture?.(event.pointerId);
@@ -531,215 +503,6 @@ function handleActorEntry({ entityType, entry }) {
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.
watch(() => props.map, (incoming, previous) => {
if (incoming === previous) return;
@@ -747,10 +510,6 @@ watch(() => props.map, (incoming, previous) => {
imageSize.value = { width: 0, height: 0 };
movingToken.value = null;
draggingActor.value = false;
drawingWall.value = null;
draggingWall.value = null;
draggingEnd.value = null;
selectedWall.value = null;
});
watch(campaignId, () => {
@@ -766,7 +525,6 @@ onMounted(() => {
emitter.on('campaign-entry-updated', handleActorEntry);
emitter.on('delete-note', handlePinnedNoteDeleted);
emitter.on('title-updated', handlePinnedNoteRenamed);
window.addEventListener('keydown', onWindowKeydown);
fetchPinnableNotes();
fetchTokenActors();
});
@@ -777,7 +535,6 @@ onBeforeUnmount(() => {
emitter.off('campaign-entry-updated', handleActorEntry);
emitter.off('delete-note', handlePinnedNoteDeleted);
emitter.off('title-updated', handlePinnedNoteRenamed);
window.removeEventListener('keydown', onWindowKeydown);
});
</script>
@@ -793,10 +550,6 @@ onBeforeUnmount(() => {
: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">
</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)">
<img class="tool-icon" src="/icons/iconoir/regular/minus.svg" alt="" aria-hidden="true">
</button>
@@ -834,42 +587,6 @@ onBeforeUnmount(() => {
<template v-if="imageUrl">
<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>
<!-- 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">
<button
v-for="pin in pins"
@@ -912,7 +629,6 @@ onBeforeUnmount(() => {
</button>
</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>
<div v-else class="map-empty">
{{ $t('campaigns.map.no-image') }}
@@ -983,27 +699,6 @@ onBeforeUnmount(() => {
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);
}
/* 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-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); }

View File

@@ -51,6 +51,7 @@ Worth knowing:
| The world's **item directory** (the items tab) | The campaign's item list, with category, rarity, quantity, weight, properties and description |
| The folders grouping that item directory | Item folders with the same names and nesting |
| A folder's colour | The campaign's folder colour — and the other way round, what you colour in Dragonroll lands on the world's folder |
| A journal called **Dragonroll** — one page per note | Your campaign's notes. They arrive **from** Dragonroll: what you write in the journal does not go back |
The item list is the world's item directory and nothing else. The gear a character carries is that
character's inventory: it travels with the character and stays on its sheet, so a sword a fighter owns
@@ -67,6 +68,12 @@ few seconds. A **full** snapshot — the one taken when the world links, or forc
directory — is the only thing that prunes: it is the only moment either side can see the whole list and
notice what is gone. Live edits never delete anything.
Notes are the exception that runs one way, because notes are written in Dragonroll: every note stands
as a page of a single journal called **Dragonroll**. A note you make or edit in the app appears on that
journal within a few seconds, and deleting one takes its page with it. Pages the campaign does not own
— one the GM made in that journal themselves — are left alone, and nothing written in the journal
travels back to the campaign.
## Auto-sync, and sending one actor on purpose
**Dragonroll Auto-sync** is what keeps the two in step: actors and world items you create, change or

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

@@ -111,16 +111,6 @@
"drop-hint": "Deixa anar per posar l'actor en aquest mapa",
"open": "Obre la fitxa de personatge", "remove": "Treu la fitxa",
"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": {

View File

@@ -4,7 +4,6 @@
"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.",
"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-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.",

View File

@@ -115,16 +115,6 @@
"drop-hint": "Drop to place the actor on this map",
"open": "Open character sheet", "remove": "Remove token",
"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": {

View File

@@ -4,7 +4,6 @@
"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.",
"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-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.",

View File

@@ -111,16 +111,6 @@
"drop-hint": "Suelta para colocar al actor en este mapa",
"open": "Abrir hoja de personaje", "remove": "Quitar la ficha",
"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": {

View File

@@ -4,7 +4,6 @@
"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.",
"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-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.",

View File

@@ -133,6 +133,7 @@ function loadFoundryWriters({ seed = {}, settings } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
};
const requireStub = (id) => {

View File

@@ -271,6 +271,7 @@ function loadFoundryWriters({ seed = {} } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
};
const requireStub = (id) => {

View File

@@ -0,0 +1,532 @@
// Tests for the campaign's notes reaching the Foundry world as journal pages
// (Syndria98/dragonroll#98): every Dragonroll note stands as a page of the one
// journal the world calls "Dragonroll", written by the module and kept in step with
// the campaign. The copy runs one way — notes are written in Dragonroll — so the
// backend answers with the notes and remembers each note's page; the module reads
// them, renders the markdown, and prunes the page of a note the campaign deleted.
//
// Both sides are loaded the way the other Foundry tests do it: the sync route runs
// against a stubbed `require` (models answer with plain objects and a small filter
// matcher), and the Foundry module is loaded into a `node:vm` context holding
// stubbed Foundry globals (`game.journals` and `JournalEntry` included) with fake
// timers, like tests/item-folder-sync.test.js.
//
// 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";
const read = (...parts) => fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
const repoRequire = (relative) => require(path.join(__dirname, "..", relative));
// --- The sync route against stubbed models -------------------------------------
// A mongoose query answers whatever `await query` and `query.lean()` answer with, and
// lets `select()`, `sort()` and `limit()` sit in between.
function mongooseQuery(value) {
const result = {
select: () => result,
sort: () => result,
limit: (count) => mongooseQuery(value.slice(0, count)),
lean: () => Promise.resolve(value),
then: (onFulfilled, onRejected) => Promise.resolve(value).then(onFulfilled, onRejected),
};
return result;
}
// Enough of the query language the note routes use: equality, $or, $in, $nin,
// $exists, $ne. Anything else is a filter this test did not expect and says so.
function matches(document, filter = {}) {
return Object.entries(filter).every(([key, expected]) => {
if (key === "$or") return expected.some((part) => matches(document, part));
const value = document?.[key];
if (expected && typeof expected === "object" && !Array.isArray(expected)) {
return Object.entries(expected).every(([operator, wanted]) => {
if (operator === "$exists") return (value !== undefined && value !== null) === wanted;
if (operator === "$in") return wanted.some((entry) => String(value) === String(entry));
if (operator === "$nin") return !wanted.some((entry) => String(value) === String(entry));
if (operator === "$ne") return String(value ?? "") !== String(wanted ?? "");
throw new Error(`filter operator "${key}.${operator}" is not stubbed`);
});
}
return String(value ?? "") === String(expected ?? "");
});
}
function fakeModel(table, seed = [], campaignId) {
const rows = [];
let counter = 0;
function Document(data = {}) {
counter += 1;
this._id = `${table}-${counter}`;
this.isNew = true;
this.foundryNames = [];
Object.assign(this, data);
}
Document.prototype.save = async function save() {
if (this.isNew) rows.push(this);
this.isNew = false;
return this;
};
Object.defineProperty(Document.prototype, "id", { get() { return this._id; } });
for (const data of seed) {
// A seeded row belongs to the campaign the requests are made against unless the
// seed says otherwise: the routes scope every lookup by campaign.
const row = new Document({ campaign: campaignId, ...data });
row.isNew = false;
rows.push(row);
}
const model = function Model(data) { return new Document(data); };
model.rows = rows;
model.findOne = async (filter) => rows.find((row) => matches(row, filter)) ?? null;
model.find = (filter) => mongooseQuery(rows.filter((row) => matches(row, filter)));
model.deleteOne = async (filter) => {
const hit = rows.filter((row) => matches(row, filter));
for (const row of hit) rows.splice(rows.indexOf(row), 1);
return { deletedCount: hit.length };
};
model.deleteMany = async (filter) => {
const hit = rows.filter((row) => matches(row, filter));
for (const row of hit) rows.splice(rows.indexOf(row), 1);
return { deletedCount: hit.length };
};
model.updateMany = async (filter, update) => {
const hit = rows.filter((row) => matches(row, filter));
for (const row of hit) Object.assign(row, update.$set ?? {});
return { modifiedCount: hit.length };
};
return model;
}
// The Foundry sync route with every model it requires stubbed. `seed` pre-fills the
// tables with documents the campaign already holds.
function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
const routes = new Map();
const router = {
get: (route, ...handlers) => routes.set(`GET ${route}`, handlers),
post: (route, ...handlers) => routes.set(`POST ${route}`, handlers),
};
const campaign = { _id: "campaign-1", id: "campaign-1", name: "Test Campaign", foundryWorldId: worldId };
const seeded = (rows = []) => rows.map((row) => ({ campaign: campaign._id, ...row }));
const models = {
"../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
};
const requireStub = (id) => {
if (id === "express") return { Router: () => router };
if (id.startsWith("node:")) return require(id); // crypto: the sync token is hashed, not stubbed
if (id === "mongoose") return { isValidObjectId: (value) => typeof value === "string" && value.length > 20 };
if (id === "../models/Campaign") return { findOne: async () => campaign };
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/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`);
};
const moduleStub = { exports: {} };
vm.compileFunction(read("backend", "src", "routes", "foundry-link.js"), ["require", "module", "exports"])(
requireStub, moduleStub, moduleStub.exports
);
async function call(route, body = {}) {
const handlers = routes.get(route);
assert.ok(handlers, `${route} is not mounted`);
const res = { payload: null, json(payload) { this.payload = payload; }, set: () => {} };
const req = { body, get: (name) => (String(name).toLowerCase() === "authorization" ? "Bearer sync-token" : "") };
await handlers[handlers.length - 1](req, res);
return res.payload;
}
return { call, models, campaign };
}
// --- The sync route: the notes it answers and the page ids it keeps ---------------
test("the world reads the campaign's notes with their content and page mapping", async () => {
const sync = loadSyncRoute({
seed: {
notes: [
{ _id: "note-1", title: "Session 1", content: "**The start**", foundryPageId: "page-9" },
{ _id: "note-2", title: "Tavern Brawl", content: "- rope" },
],
},
});
const response = await sync.call("GET /sync/notes");
assert.equal(response.status, "ok");
assert.deepEqual(response.notes.map((note) => note.title), ["Session 1", "Tavern Brawl"]);
assert.equal(response.notes[0].content, "**The start**", "the markdown source travels: the module renders it");
assert.equal(response.notes[0].foundryPageId, "page-9", "and the note says which page it already stands as");
});
test("mapping a note to the page the module made keeps them paired", async () => {
const sync = loadSyncRoute({ seed: { notes: [{ _id: "note-1", title: "Session 1", content: "hi" }] } });
const response = await sync.call("POST /sync/map-note", {
worldId: "world-1", noteId: "note-1", foundryPageId: "page-9",
});
assert.equal(response.status, "ok");
assert.equal(sync.models["../models/Note"].rows[0].foundryPageId, "page-9");
// Mapping the same pair again is the module checking, not a conflict.
const again = await sync.call("POST /sync/map-note", {
worldId: "world-1", noteId: "note-1", foundryPageId: "page-9",
});
assert.equal(again.status, "ok");
});
test("a page already mapped to another note is refused", async () => {
const sync = loadSyncRoute({
seed: {
notes: [
{ _id: "note-1", title: "Session 1", content: "hi", foundryPageId: "page-9" },
{ _id: "note-2", title: "Tavern Brawl", content: "ho" },
],
},
});
const response = await sync.call("POST /sync/map-note", {
worldId: "world-1", noteId: "note-2", foundryPageId: "page-9",
});
assert.equal(response.status, "error");
assert.equal(response.msg, "foundry.errors.note-already-synced");
assert.equal(sync.models["../models/Note"].rows.find((row) => row._id === "note-2").foundryPageId, undefined,
"the first note keeps its page");
});
test("map-note wants this world's note and a page for it", async () => {
const sync = loadSyncRoute({ seed: { notes: [{ _id: "note-1", title: "Session 1", content: "hi" }] } });
assert.equal((await sync.call("POST /sync/map-note", { worldId: "world-1" })).msg, "errors.missing-data");
assert.equal((await sync.call("POST /sync/map-note", { noteId: "note-1", foundryPageId: "page-9" })).msg, "errors.missing-data",
"another world cannot map this campaign's note");
const gone = await sync.call("POST /sync/map-note", {
worldId: "world-1", noteId: "note-gone", foundryPageId: "page-9",
});
assert.equal(gone.msg, "errors.notfound");
});
// --- The Foundry module writes the journal ---------------------------------------
// Foundry's `update` takes dotted paths ("flags.dragonroll-foundry.noteId"); an
// embedded document's own id is not a path to set.
function writeFoundryPaths(target, data) {
for (const [key, value] of Object.entries(data)) {
if (key === "_id") continue;
const parts = key.split(".");
const last = parts.pop();
let node = target;
for (const part of parts) node = node[part] ??= {};
node[last] = value;
}
return target;
}
function makeWorld({ markdown = true } = {}) {
const state = {
hooks: new Map(),
registered: new Map(),
requests: [],
timers: new Map(),
intervals: new Map(),
// What Dragonroll answers the notes reconcile with. Mapping a page answers
// like the real backend: the note keeps the page id, so later reads carry it.
remoteNotes: [],
nextId: 1,
};
const journals = [];
const makePage = (journal, data = {}) => {
const page = {
id: `page-${state.nextId++}`,
documentName: "JournalEntryPage",
title: data.title,
text: { content: data.text?.content ?? "" },
flags: data.flags ?? {},
writes: 0,
getFlag(module, key) { return this.flags?.[module]?.[key]; },
async update(update) {
page.writes += 1;
writeFoundryPaths(page, update);
return page;
},
async delete() {
const index = journal.pages.contents.indexOf(page);
if (index >= 0) journal.pages.contents.splice(index, 1);
},
};
return page;
};
const makeJournal = (data = {}) => {
const pages = [];
return {
id: `journal-${state.nextId++}`,
name: data.name,
documentName: "JournalEntry",
flags: data.flags ?? {},
getFlag(module, key) { return this.flags?.[module]?.[key]; },
pages: { contents: pages, get: (id) => pages.find((page) => page.id === id) },
async update(update) { return writeFoundryPaths(this, update); },
async createEmbeddedDocuments(documentName, docs) {
assert.equal(documentName, "JournalEntryPage", "the notes' pages are journal pages");
const created = docs.map((doc) => makePage(this, doc));
pages.push(...created);
return created;
},
};
};
const settingsStore = { autoSync: true, 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() {}, warn() {}, error() {} } },
Hooks: {
once(name, fn) { state.hooks.set(name, [fn]); },
on(name, fn) { state.hooks.set(name, [...(state.hooks.get(name) || []), fn]); },
},
setTimeout: (fn, delay = 0) => {
const id = state.nextId++;
state.timers.set(id, { fn, delay });
return id;
},
clearTimeout: (id) => state.timers.delete(id),
setInterval: (fn, delay = 0) => {
// Recorded, never run by itself: tests ask for a periodic reconcile with
// `runIntervals`, so the ones watching single pushes stay on their own.
const id = state.nextId++;
state.intervals.set(id, { fn, delay });
return id;
},
clearInterval: (id) => state.intervals.delete(id),
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/map-note")) {
const note = state.remoteNotes.find((entry) => String(entry._id) === String(body.noteId));
if (note) note.foundryPageId = body.foundryPageId;
return { ok: true, status: 200, json: async () => ({ status: "ok", note }) };
}
if (href.includes("foundry/sync/notes")) {
return { ok: true, status: 200, json: async () => ({ status: "ok", notes: state.remoteNotes }) };
}
return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [] }) };
},
Actor: { async create() { return null; } },
Item: { async create() { return null; } },
JournalEntry: {
async create(data) {
const journal = makeJournal(data);
journals.push(journal);
return [journal];
},
},
};
if (markdown) sandbox.TextEditor = { _getMarkdown: (md) => `<marked>${md}</marked>` };
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: [], get: () => null },
journals: { contents: journals, get: (id) => journals.find((journal) => journal.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(read("dragonroll-foundry", "scripts", "api.js"), sandbox);
state.game = sandbox.game;
state.journals = () => journals;
state.addJournal = (name, flags = {}) => {
const journal = makeJournal({ name, flags });
journals.push(journal);
return journal;
};
state.addPage = (journal, data) => {
const page = makePage(journal, data);
journal.pages.contents.push(page);
return page;
};
state.mapNoteRequests = () => state.requests.filter((request) => request.href.includes("foundry/sync/map-note"));
state.notesReads = () => state.requests.filter((request) => request.href.includes("foundry/sync/notes"));
const drain = async () => { await new Promise((resolve) => setImmediate(resolve)); };
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 < 6; 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();
}
};
// The reconciles `setInterval` registered: what runs every few seconds on a
// linked world, and so what carries each note into its journal page.
state.runIntervals = async () => {
for (const interval of [...state.intervals.values()]) await interval.fn();
await drain();
};
state.linkedSetup = async () => {
await state.fire("init");
await state.fire("ready");
await state.runTimers();
state.requests.length = 0;
return state;
};
return state;
}
// The fetch stub updates a note with the page it maps, like the real backend
// does, so every test works on notes of its own.
const sessionNote = (over = {}) => ({ _id: "note-1", title: "Session 1", content: "**The start**", ...over });
const tavernNote = (over = {}) => ({ _id: "note-2", title: "Tavern Brawl", content: "A rope, a chandelier.", ...over });
test("the campaign's notes become pages of one Dragonroll journal", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote(), tavernNote()];
await world.runIntervals();
assert.equal(world.journals().length, 1, "one journal carries the campaign's notes");
const journal = world.journals()[0];
assert.equal(journal.name, "Dragonroll");
assert.deepEqual(journal.pages.contents.map((page) => [page.title.text, page.text.content]), [
["Session 1", "<marked>**The start**</marked>"],
["Tavern Brawl", "<marked>A rope, a chandelier.</marked>"],
], "each note is a page, its markdown rendered by Foundry's own renderer");
assert.deepEqual(journal.pages.contents.map((page) => page.getFlag(MODULE_ID, "noteId")), ["note-1", "note-2"],
"each page keeps the note it stands for");
assert.deepEqual(world.mapNoteRequests().map((request) => [request.body.noteId, request.body.foundryPageId]), [
["note-1", journal.pages.contents[0].id],
["note-2", journal.pages.contents[1].id],
], "and the campaign remembers each note's page");
});
test("an existing journal named Dragonroll is used, not doubled", async () => {
const world = await makeWorld().linkedSetup();
const gmsOwn = world.addJournal("Dragonroll");
world.remoteNotes = [sessionNote()];
await world.runIntervals();
assert.equal(world.journals().length, 1, "the journal the world already had is the notes' one");
assert.deepEqual(gmsOwn.pages.contents.map((page) => page.title.text), ["Session 1"]);
assert.equal(gmsOwn.getFlag(MODULE_ID, "notesJournal"), true, "and it is marked, so renaming it keeps the notes' home findable");
});
test("a note edited in Dragonroll rewrites its page", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote()];
await world.runIntervals();
const first = world.remoteNotes[0];
world.remoteNotes = [{ ...first, title: "Session 1 — revisited", content: "**A different start**" }];
await world.runIntervals();
const journal = world.journals()[0];
assert.equal(journal.pages.contents.length, 1, "the note still stands as the same single page");
assert.deepEqual(journal.pages.contents[0].title.text, "Session 1 — revisited");
assert.equal(journal.pages.contents[0].text.content, "<marked>**A different start**</marked>");
assert.equal(world.mapNoteRequests().length, 1, "the pairing the world reads back needs no remapping");
});
test("a note deleted in Dragonroll takes its page with it", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote(), tavernNote()];
await world.runIntervals();
const journal = world.journals()[0];
const gmsPage = world.addPage(journal, { title: { text: "My own notes" }, text: { content: "not from Dragonroll" } });
world.remoteNotes = world.remoteNotes.filter((note) => note._id !== "note-2");
await world.runIntervals();
assert.deepEqual(journal.pages.contents.map((page) => page.title.text), ["Session 1", "My own notes"],
"the deleted note's page goes; the GM's own page stays");
assert.ok(journal.pages.contents.includes(gmsPage));
});
test("pages already in step with the campaign are not rewritten", async () => {
const world = await makeWorld().linkedSetup();
world.remoteNotes = [sessionNote()];
await world.runIntervals();
const [page] = world.journals()[0].pages.contents;
assert.equal(page.writes, 0, "the page was created whole, not patched");
await world.runIntervals();
assert.equal(page.writes, 0, "a reconcile that changes nothing leaves the page alone");
});
test("the campaign's page mapping claims a page whose flag was lost", async () => {
const world = await makeWorld().linkedSetup();
const journal = world.addJournal("Dragonroll");
const orphan = world.addPage(journal, { title: { text: "Old name" }, text: { content: "old" } });
world.remoteNotes = [{ _id: "note-1", title: "Session 1", content: "**The start**", foundryPageId: orphan.id }];
await world.runIntervals();
assert.equal(journal.pages.contents.length, 1, "no second page under the same title");
assert.equal(orphan.title.text, "Session 1");
assert.equal(orphan.getFlag(MODULE_ID, "noteId"), "note-1", "and the page is marked again");
});
test("without Foundry's markdown renderer the fallback keeps the text legible", async () => {
const world = await makeWorld({ markdown: false }).linkedSetup();
world.remoteNotes = [{ _id: "note-1", title: "Session 1", content: "a & b < c\nline two\n\nsecond para" }];
await world.runIntervals();
assert.equal(
world.journals()[0].pages.contents[0].text.content,
"<p>a &amp; b &lt; c<br />line two</p>\n<p>second para</p>",
"escaped paragraphs instead of nothing, until this Foundry offers a renderer",
);
});
test("autosync off: the campaign's notes are not written into the world", async () => {
const world = await makeWorld().linkedSetup();
await world.game.settings.set(MODULE_ID, "autoSync", false);
world.remoteNotes = [sessionNote()];
await world.runIntervals();
assert.deepEqual(world.journals(), [], "no journal is made");
assert.deepEqual(world.notesReads(), [], "and the campaign is not even asked");
});

View File

@@ -132,6 +132,7 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Note": fakeModel("note", seeded(seed.notes)),
};
const requireStub = (id) => {

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();