15 Commits

Author SHA1 Message Date
Gitea OpenCode Agent
437a11d23e Fix issue #99: Make maps sync
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 23:59:54 +00:00
c9ee16f2f2 Merge pull request 'Fix #95: Make documentation a resizable window' (#97) from ai/issue-95 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 54s
Reviewed-on: #97
2026-10-15 22:40:25 +00:00
Gitea OpenCode Agent
abcec4d2ff Fix issue #95: Make documentation a resizable window
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 22:33:31 +00:00
dcc6d7a14b kdsklkdsl
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m3s
2026-10-16 00:02:51 +02:00
227fff1351 Merge pull request 'Fix #90: Add a docs button' (#93) from ai/issue-90 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #93
2026-10-15 22:02:07 +00:00
a64fe499e9 Merge branch 'master' into ai/issue-90
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 22:02:01 +00:00
b75ee05276 Merge pull request 'Fix #91: Make character column always visible' (#94) from ai/issue-91 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #94
2026-10-15 22:01:54 +00:00
bc7231a1da Merge branch 'master' into ai/issue-91
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 22:01:49 +00:00
252ae2d6b2 Merge pull request 'Fix #89: Traits and items are mixed up' (#92) from ai/issue-89 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #92
2026-10-15 22:01:34 +00:00
Gitea OpenCode Agent
30e23b643c Fix issue #91: Make character column always visible
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 21:56:49 +00:00
Gitea OpenCode Agent
8376acfc6b Fix issue #90: Add a docs button
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 21:42:03 +00:00
Gitea OpenCode Agent
f8dae95563 Fix issue #89: Traits and items are mixed up
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 21:36:44 +00:00
98aa3be078 Merge pull request 'Fix #85: Style corrections on /docs' (#88) from ai/issue-85 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m5s
Reviewed-on: #88
2026-10-15 20:56:27 +00:00
80c6b1b62f Merge branch 'master' into ai/issue-85
All checks were successful
Test / test (push) Successful in 1s
2026-10-15 20:56:19 +00:00
Gitea OpenCode Agent
9aad484fe9 Fix issue #85: Style corrections on /docs
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 20:55:08 +00:00
27 changed files with 2421 additions and 244 deletions

View File

@@ -87,7 +87,8 @@ campaign, and handlers check ownership with a `userOwnsCampaign(campaignId, user
- `Folder` — `name*`, `campaign*`, `parentFolder` (null = root, self-ref), `color` - `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) - `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` - `Item` — `name*`, `campaign*`, `foundryItemId` (unique per campaign), `foundryNames`, `category`, `rarity`, `quantity`, `weight`, `properties`, `description`
- `Map` — `name*`, `campaign*`, `image` (filename in `src/uploads`), `gridSize`/`offsetX`/`offsetY`/`scale` (image px), `pins[{note→Note, x, y}]` (addressed by the pin's own `_id`), `tokens[{actor→Actor, x, y}]` (the centre of the grid cell the token stands in, also addressed by its own `_id`) - `Map` — `name*`, `campaign*`, `image` (filename in `src/uploads`, or a full URL a synced scene's
picture arrives as), `gridSize`/`offsetX`/`offsetY`/`scale` (image px), `pins[{note→Note, x, y}]` (addressed by the pin's own `_id`), `tokens[{actor→Actor, x, y}]` (the centre of the grid cell the token stands in, also addressed by its own `_id`), `foundrySceneId` (the Foundry scene this map mirrors, unique per campaign)
- `ServiceLinkRequest` — the pending/completed service pairings of §4; `DiscordGuildLink` maps a Discord guild to the Dragonroll user who claimed it - `ServiceLinkRequest` — the pending/completed service pairings of §4; `DiscordGuildLink` maps a Discord guild to the Dragonroll user who claimed it
**API surface** (all under `/api`, all `{status,msg}`): **API surface** (all under `/api`, all `{status,msg}`):
@@ -114,11 +115,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 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), 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`, `scenes` (the world's scenes as the campaign's maps, `fullSync` also
prunes), `scene-delete`, `characters`, `items`, `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. - **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. - **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. - **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.
- **A world's scenes arrive as its campaign's maps** (Syndria98/dragonroll#99): `POST /foundry/sync/scenes` writes one `Map` per scene through `saveFoundryScene`, and only the scene's background picture and grid cross over (`services/map-foundry.js`: `gridSize` from `grid`/`grid.size`, the offsets from `flags.core.shiftX`/`.shiftY`) — `scale`, the folder, the pins and the tokens stay with the campaign and nothing of a map goes back to the world. Identity is `Map.foundrySceneId` (unique per campaign), a `dragonroll-foundry.mapId` flag or a hand-made unmapped map of the same name; a scene with no picture makes no map. `POST /foundry/sync/scene-delete` drops the map of a deleted scene, and only the full list the module sends when the world links or loads prunes.
- **`fullSync` preserves Dragonroll edits** (only new rows are overwritten); live Foundry events overwrite. Only a full snapshot can prune. - **`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`). - **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. - `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.
@@ -142,7 +145,10 @@ name is the slug, and the first heading is the title. `services/Docs.js` reads t
(`import.meta.glob(..., {query:'?raw'})`), builds the sidebar and renders a page with marked; (`import.meta.glob(..., {query:'?raw'})`), builds the sidebar and renders a page with marked;
`services/DocsMarkdown.js` holds the heading/slug helpers the sidebar and the anchors share and imports `services/DocsMarkdown.js` holds the heading/slug helpers the sidebar and the anchors share and imports
nothing so `tests/docs.test.js` can load it. A new group's label goes in `docs.json` under nothing so `tests/docs.test.js` can load it. A new group's label goes in `docs.json` under
`groups.<folder>` **in all three locales**. The first page is served at `/docs` itself. `groups.<folder>` **in all three locales**. The first page is served at `/docs` itself, and inside a
campaign the top bar opens the same pages in the `documentation` window
(`components/windows/DocumentationWindow.vue`), which holds the page it shows as its own state instead
of a route so the campaign stays behind it.
Two kinds of screens: **windows** (floating draggable/resizable overlays) and **content** — the Two kinds of screens: **windows** (floating draggable/resizable overlays) and **content** — the
campaign workspace (`TopBar` + `ContentSidebar` + note column + `StatusBar`), turned on when campaign workspace (`TopBar` + `ContentSidebar` + note column + `StatusBar`), turned on when

View File

@@ -39,7 +39,15 @@ const MapSchema = new Schema({
ref: 'Folder', ref: 'Folder',
default: null default: null
}, },
// The Foundry scene this map mirrors, set by the scene sync only
// (see routes/foundry-link.js). Only the picture and the grid follow the world.
foundrySceneId: { type: String },
date: { type: Date, default: Date.now } date: { type: Date, default: Date.now }
}); });
MapSchema.index(
{ campaign: 1, foundrySceneId: 1 },
{ unique: true, partialFilterExpression: { foundrySceneId: { $type: 'string' } } }
);
module.exports = mongoose.model('Map', MapSchema); module.exports = mongoose.model('Map', MapSchema);

View File

@@ -6,9 +6,13 @@ const router = express.Router();
const Campaign = require('../models/Campaign'); const Campaign = require('../models/Campaign');
const Actor = require('../models/Actor'); const Actor = require('../models/Actor');
const Item = require('../models/Item'); const Item = require('../models/Item');
// Not `Map`: this route builds plain `Map`s of its own to mirror the world's folder tree.
const MapModel = require('../models/Map');
const Folder = require('../models/Folder'); const Folder = require('../models/Folder');
const { foundryActorToCharacter } = require('../services/actor-foundry'); const { foundryActorToCharacter } = require('../services/actor-foundry');
const { foundryItemToItemData } = require('../services/item-foundry'); const { foundryItemToItemData } = require('../services/item-foundry');
const { foundrySceneToMapData } = require('../services/map-foundry');
const { joinFoundryAssetUrl } = require('../services/foundry-icons');
// Upper bound for the Foundry names remembered per synced item (see Item model). // Upper bound for the Foundry names remembered per synced item (see Item model).
const MAX_FOUNDRY_NAMES = 20; const MAX_FOUNDRY_NAMES = 20;
@@ -41,10 +45,33 @@ function requestMatchesWorld(campaign, worldId) {
return typeof worldId === 'string' && worldId === campaign.foundryWorldId; return typeof worldId === 'string' && worldId === campaign.foundryWorldId;
} }
// Foundry serves its data directory from the world's own address, which is the one the
// campaign keeps under `settings.integrations.foundryUrl` — the icon window already loads
// the world's icons through it. The module sends the images it publishes as absolute URLs;
// the bridge's snapshot and older modules carry Foundry's relative paths, and a sheet
// reading one of those against Dragonroll's upload folder finds nothing, which is how the
// icons stopped loading (Syndria98/dragonroll#89). An absolute URL travels as it is, and so
// does a path when the campaign has no world address to read it against.
function worldAssetUrl(image, worldUrl) {
const value = String(image ?? '').trim();
if (!value || /^(https?:|data:|\/\/)/i.test(value)) return value;
return joinFoundryAssetUrl(worldUrl, value) || value;
}
// The images a world document arrives with, read against its world before they land.
function resolveWorldAssets(fields, campaign) {
const worldUrl = campaign?.settings?.integrations?.foundryUrl;
if (typeof fields.image === 'string') fields.image = worldAssetUrl(fields.image, worldUrl);
if (Array.isArray(fields.inventory)) {
for (const entry of fields.inventory) entry.icon = worldAssetUrl(entry.icon, worldUrl);
}
}
async function saveFoundryActor(campaign, source, fullSync = false) { async function saveFoundryActor(campaign, source, fullSync = false) {
const foundryActorId = String(source?._id || source?.id || '').trim().slice(0, 120); const foundryActorId = String(source?._id || source?.id || '').trim().slice(0, 120);
const fields = foundryActorToCharacter(source || {}); const fields = foundryActorToCharacter(source || {});
if (!foundryActorId || !fields.name) return null; if (!foundryActorId || !fields.name) return null;
resolveWorldAssets(fields, campaign);
let actor = await Actor.findOne({ campaign: campaign._id, foundryActorId }); let actor = await Actor.findOne({ campaign: campaign._id, foundryActorId });
const dragonrollActorId = source?.flags?.['dragonroll-foundry']?.actorId; const dragonrollActorId = source?.flags?.['dragonroll-foundry']?.actorId;
@@ -85,6 +112,7 @@ async function saveFoundryItem(campaign, source, fullSync = false, folders = nul
const foundryItemId = String(source?._id || source?.id || '').trim().slice(0, 120); const foundryItemId = String(source?._id || source?.id || '').trim().slice(0, 120);
const fields = foundryItemToItemData(source || {}); const fields = foundryItemToItemData(source || {});
if (!foundryItemId || !fields) return null; if (!foundryItemId || !fields) return null;
resolveWorldAssets(fields, campaign);
let item = await Item.findOne({ campaign: campaign._id, foundryItemId }); let item = await Item.findOne({ campaign: campaign._id, foundryItemId });
const dragonrollItemId = source?.flags?.['dragonroll-foundry']?.itemId; const dragonrollItemId = source?.flags?.['dragonroll-foundry']?.itemId;
@@ -243,6 +271,47 @@ function resolveFoundryItemFolder(source, folders) {
return folders.get(foundryFolderId.trim())?._id || null; return folders.get(foundryFolderId.trim())?._id || null;
} }
// --- Maps -------------------------------------------------------------------
// A scene of the world becomes one of the campaign's maps (Syndria98/dragonroll#99):
// services/map-foundry.js says what of a scene travels — its background picture and the
// grid laid over it, and nothing else, so the map's pins, its tokens, the folder it
// stands in and what one of its cells means stay the campaign's own.
async function saveFoundryScene(campaign, source, fullSync = false) {
const foundrySceneId = String(source?._id || source?.id || '').trim().slice(0, 120);
const fields = foundrySceneToMapData(source || {});
if (!foundrySceneId || !fields) return null;
resolveWorldAssets(fields, campaign);
let map = await MapModel.findOne({ campaign: campaign._id, foundrySceneId });
const dragonrollMapId = source?.flags?.['dragonroll-foundry']?.mapId;
if (!map && mongoose.isValidObjectId(dragonrollMapId)) {
const flagged = await MapModel.findOne({ _id: dragonrollMapId, campaign: campaign._id });
// Only adopt a flagged map while no other scene owns its mapping.
if (flagged && (!flagged.foundrySceneId || flagged.foundrySceneId === foundrySceneId)) map = flagged;
}
if (!map) {
// The campaign drew this place by hand before the scene of it ever arrived: a scene
// naming the one unmapped map the campaign holds folds into that row instead of
// adding a second copy of the same room.
const sameName = await MapModel.find({
campaign: campaign._id,
name: fields.name,
foundrySceneId: { $exists: false }
}).limit(2);
map = sameName.length === 1 ? sameName[0] : new MapModel({ campaign: campaign._id });
}
map.foundrySceneId = foundrySceneId;
// `created` says whether this row is new, like the actor and item writers answer it.
const created = map.isNew;
// A full snapshot runs when a GM reconnects: the grid the campaign lined up for a map
// it already has survives that. Live scene edits continue to overwrite normally.
if (!fullSync || map.isNew) Object.assign(map, fields);
await map.save();
return { foundrySceneId, mapId: map.id, created };
}
// Linking a world to a campaign happens through the sign-up link every service // Linking a world to a campaign happens through the sign-up link every service
// uses (routes/service-link.js); what stays here is the sync that world keeps up // uses (routes/service-link.js); what stays here is the sync that world keeps up
@@ -409,6 +478,59 @@ router.post('/sync/item-delete', async (req, res) => {
} }
}); });
// The world's scenes, upserted as the campaign's maps (Syndria98/dragonroll#99). Like a
// world item push, this one prunes only when it is told it carries every scene: that push
// alone sees the whole scene list, so it alone knows which synced maps the world has let go
// of. A map the campaign made by hand has no scene of its own and is never pruned.
router.post('/sync/scenes', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
if (!requestMatchesWorld(campaign, req.body.worldId) || !Array.isArray(req.body.scenes)) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const fullSync = req.body.fullSync === true;
const maps = [];
for (const source of req.body.scenes) {
const mapping = await saveFoundryScene(campaign, source, fullSync);
if (mapping) maps.push(mapping);
}
if (fullSync) {
const currentIds = req.body.scenes
.map((source) => String(source?._id || source?.id || '').trim())
.filter(Boolean);
await MapModel.deleteMany({
campaign: campaign._id,
foundrySceneId: { $exists: true, $nin: currentIds }
});
}
res.json({ status: 'ok', maps });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// A scene the world deleted takes its map with it. Only the world says so; deleting a map
// in the campaign leaves the world's scene alone, which is the campaign's own to do.
router.post('/sync/scene-delete', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const foundrySceneId = String(req.body.foundrySceneId || '').trim();
if (!requestMatchesWorld(campaign, req.body.worldId) || !foundrySceneId) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
await MapModel.deleteOne({ campaign: campaign._id, foundrySceneId });
res.json({ status: 'ok' });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// The item list the world reconciles against, together with the folders its rows are // The item list the world reconciles against, together with the folders its rows are
// grouped into — the same shape the campaign's own `/item/list` answers with. The folders // grouped into — the same shape the campaign's own `/item/list` answers with. The folders
// travel back for their colour: the world owns the tree's name and nesting, while whoever // travel back for their colour: the world owns the tree's name and nesting, while whoever

View File

@@ -1,4 +1,5 @@
const { numberOr, asText, plainText, stringList } = require('./foundry-fields'); const { numberOr, asText, plainText, stringList } = require('./foundry-fields');
const { isFoundryGearType } = require('./item-foundry');
// D&D 5e keeps an actor's background, species, class and subclass as a reference to an // D&D 5e keeps an actor's background, species, class and subclass as a reference to an
// embedded item: `system.details.background` and friends hold that item's id, and the // embedded item: `system.details.background` and friends hold that item's id, and the
@@ -169,8 +170,11 @@ function foundryActorToCharacter(foundryActor) {
armorClass: numberOr(attributes.ac?.value ?? attributes.ac, 10), armorClass: numberOr(attributes.ac?.value ?? attributes.ac, 10),
speed: numberOr(movement.walk ?? movement.value, 30), speed: numberOr(movement.walk ?? movement.value, 30),
proficiencies: foundryProficiencies || asText(savedDragonrollFields.proficiencies), proficiencies: foundryProficiencies || asText(savedDragonrollFields.proficiencies),
// What the character carries: gear, and gear only (Syndria98/dragonroll#89). A feat
// is a trait — its tab shows it — and a race is the species; standing them in the
// inventory next to the longswords is how traits and items got mixed up.
inventory: items inventory: items
.filter((item) => !['class', 'subclass', 'background', 'spell'].includes(item.type)) .filter((item) => isFoundryGearType(item.type))
.map((item) => ({ .map((item) => ({
name: asText(item.name).trim(), name: asText(item.name).trim(),
quantity: numberOr(item.system?.quantity, 1), quantity: numberOr(item.system?.quantity, 1),

View File

@@ -23,6 +23,14 @@ const NON_GEAR_FOUNDRY_TYPES = new Set([
'spell', 'class', 'subclass', 'background', 'feat', 'race', 'species', 'status', 'spellbook', 'language' 'spell', 'class', 'subclass', 'background', 'feat', 'race', 'species', 'status', 'spellbook', 'language'
]); ]);
// Whether a Foundry document of this type is gear: something a character carries. Traits,
// species, spells and the rest are documents of the world that mean something else on a
// Dragonroll sheet — a feat is a trait and a race is a species — so they stand in the
// character's own fields, never in its inventory (Syndria98/dragonroll#89).
function isFoundryGearType(type) {
return !NON_GEAR_FOUNDRY_TYPES.has(asText(type).toLowerCase().trim());
}
// Item categories the Dragonroll Item model accepts. // Item categories the Dragonroll Item model accepts.
const CATEGORIES = ['weapon', 'armor', 'shield', 'adventuring-gear', 'magic-item', 'consumable', 'tool', 'treasure', 'other']; const CATEGORIES = ['weapon', 'armor', 'shield', 'adventuring-gear', 'magic-item', 'consumable', 'tool', 'treasure', 'other'];
@@ -107,4 +115,4 @@ function foundryItemToItemData(foundryItem) {
}; };
} }
module.exports = { foundryItemToItemData }; module.exports = { foundryItemToItemData, isFoundryGearType };

View File

@@ -0,0 +1,49 @@
const { numberOr, asText } = require('./foundry-fields');
// A Foundry scene is one of the campaign's maps (Syndria98/dragonroll#99): its background
// picture and the grid laid over it travel to Dragonroll. Everything else a scene holds —
// its padding, its lighting, the tokens standing on it — belongs to the world's table, and
// so does what one of its cells stands for (`gridDistance` with its units): the campaign
// sets its own scale and keeps it.
// The scene's background picture: `background.src` since Foundry V13, plain `img` before.
function sceneImage(scene) {
return asText(scene?.background?.src).trim() || asText(scene?.img).trim();
}
// How many pixels of the picture one grid cell covers. Foundry keeps it under `grid.size`
// since V13 and under plain `grid` before; 50 px is its own default cell size, and
// Dragonroll's is the same, so a scene that says nothing gets the grid it draws.
function sceneGridSize(scene) {
const size = numberOr(scene?.grid?.size ?? scene?.grid, 0);
return size >= 1 ? Math.round(size) : 50;
}
// Where that grid starts on the picture. A world shifts it with the core flags of its own
// (`flags.core.shiftX` / `.shiftY`, what it uses to line a hexagonal grid up); one that says
// nothing has its grid at the corner of the picture. The scene's padding is blank canvas
// *outside* the picture, so it is no part of the grid the campaign lays on the picture itself.
function sceneGridOffset(scene, axis) {
return Math.round(numberOr(scene?.flags?.core?.[`shift${axis}`], 0));
}
// Returns null for a scene that is not a map: one with no name, or with no background
// picture. A Dragonroll map without a picture is an empty viewer, so those scenes stay in
// the world — their id is still listed by the snapshot that carries them, so nothing of the
// campaign is pruned because of one.
function foundrySceneToMapData(scene) {
const name = asText(scene?.name).trim();
const image = sceneImage(scene);
if (!name || !image) return null;
return {
name,
// The module sends Foundry's picture as an absolute URL, like actors do.
image,
gridSize: sceneGridSize(scene),
offsetX: sceneGridOffset(scene, 'X'),
offsetY: sceneGridOffset(scene, 'Y')
};
}
module.exports = { foundrySceneToMapData };

View File

@@ -3,7 +3,7 @@
Foundry modules run in the game client, so the module cannot bind an HTTP port on the Foundry host. Foundry modules run in the game client, so the module cannot bind an HTTP port on the Foundry host.
This integration uses a small companion bridge process on that host: This integration uses a small companion bridge process on that host:
1. A linked GM client syncs character Actors and world Items directly with the Dragonroll campaign. 1. A linked GM client syncs character Actors, world Items and Scenes directly with the Dragonroll campaign.
2. The module publishes the active world's actor and item snapshot to the optional bridge. 2. The module publishes the active world's actor and item snapshot to the optional bridge.
3. The bridge serves authenticated HTTP read endpoints that Dragonroll proxies under `/api/foundry/*`. 3. The bridge serves authenticated HTTP read endpoints that Dragonroll proxies under `/api/foundry/*`.
@@ -105,6 +105,30 @@ else (Syndria98/dragonroll#67):
the whole world directory and can tell which synced rows it has let go of. Deleting a synced item in 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. Dragonroll removes its Foundry world copy on the next reconcile.
### Maps
A scene of the world is one of the campaign's maps (Syndria98/dragonroll#99), and only two things
about it cross over: the scene's **background picture** and the **grid** laid over it.
- The picture is sent as an absolute URL of this world, the way an actor's portrait is, so the
campaign draws the same battle map the table is looking at. Its cell size is the scene's own
(`grid`, and `grid.size` since Foundry V13), and the grid starts where the world shifts it
(`flags.core.shiftX` / `.shiftY`). A scene with no background picture makes no map.
- Everything else a scene holds stays in the world, and everything else a map holds stays in the
campaign: what one of its cells stands for, the folder it stands in, the notes pinned onto it and
the actors standing on it as tokens are the campaign's own. Nothing of a map is written back into
the world — scene sync runs one way, so a map deleted in the campaign comes back with its scene on
the next full list, and taking the scene off is what ends the map.
- A scene is matched to a map by its Foundry id, kept on the map as `foundrySceneId` (unique within
the campaign). A campaign that drew the same place by hand before its scene arrived is adopted
instead of doubled: the scene takes over the unmapped map holding its name.
- Live scene edits overwrite the map, including a picture and grid the campaign had set itself; a
full snapshot (the world linking or loading) leaves a map it already has alone. The maps of scenes
the world let go of are pruned by a full snapshot only, and a scene deleted in the world is
reported on `foundry/sync/scene-delete`.
- Autosync covers maps like everything else: turned off, no scene crosses over at all, and the ones
queued while it was off go over when it is turned back on.
The module calls these Dragonroll routes with the campaign sync token (no Dragonroll login): The module calls these Dragonroll routes with the campaign sync token (no Dragonroll login):
| Route | Use | | Route | Use |
@@ -112,6 +136,8 @@ The module calls these Dragonroll routes with the campaign sync token (no Dragon
| `POST /api/foundry/sync/snapshot` | Actors and world items upsert; `fullSync` also prunes | | `POST /api/foundry/sync/snapshot` | Actors and world items upsert; `fullSync` also prunes |
| `POST /api/foundry/sync/item-snapshot` | Live world item edits, upsert only | | `POST /api/foundry/sync/item-snapshot` | Live world item edits, upsert only |
| `POST /api/foundry/sync/item-delete` | A world item was deleted | | `POST /api/foundry/sync/item-delete` | A world item was deleted |
| `POST /api/foundry/sync/scenes` | The world's scenes upsert as the campaign's maps; `fullSync` also prunes |
| `POST /api/foundry/sync/scene-delete` | A scene was deleted |
| `GET /api/foundry/sync/characters` | Characters to apply back in Foundry | | `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/items` | Items, and the item folders with their Dragonroll colours, to apply back in Foundry |
| `GET /api/foundry/sync/status` | The campaign this world's token belongs to, for the module's pairing status | | `GET /api/foundry/sync/status` | The campaign this world's token belongs to, for the module's pairing status |

View File

@@ -33,9 +33,13 @@ let itemSyncRunning = false;
let itemSyncErrorLogged = false; let itemSyncErrorLogged = false;
let folderSyncTimeout; let folderSyncTimeout;
let folderSyncRunning = false; let folderSyncRunning = false;
let sceneSyncTimeout;
let sceneSyncRetryTimeout;
let sceneSyncErrorLogged = false;
const syncingItemIds = new Set(); const syncingItemIds = new Set();
const syncingFolderIds = new Set(); const syncingFolderIds = new Set();
const queuedItemChanges = new Map(); const queuedItemChanges = new Map();
const queuedSceneChanges = new Map();
function getCollectionContents(collection, collectionName) { function getCollectionContents(collection, collectionName) {
if (!collection) { if (!collection) {
@@ -300,6 +304,7 @@ async function applyDragonrollLink(result) {
scheduleSnapshotSync(0); scheduleSnapshotSync(0);
setTimeout(initializeCharacterSync, 0); setTimeout(initializeCharacterSync, 0);
setTimeout(reconcileDragonrollItems, 2000); setTimeout(reconcileDragonrollItems, 2000);
setTimeout(initializeSceneSync, 1000);
} else { } else {
// Without a token this client cannot sync, and only a fresh link gives one. // Without a token this client cannot sync, and only a fresh link gives one.
linkProblem = "this client could not save the token it was given"; linkProblem = "this client could not save the token it was given";
@@ -441,6 +446,8 @@ function handleAutoSyncChange(value) {
clearTimeout(actorSyncTimeout); clearTimeout(actorSyncTimeout);
clearTimeout(itemSyncTimeout); clearTimeout(itemSyncTimeout);
clearTimeout(folderSyncTimeout); clearTimeout(folderSyncTimeout);
clearTimeout(sceneSyncTimeout);
clearTimeout(sceneSyncRetryTimeout);
return; return;
} }
if (!game.user?.isGM || !getSyncToken()) return; if (!game.user?.isGM || !getSyncToken()) return;
@@ -450,6 +457,7 @@ function handleAutoSyncChange(value) {
initializeCharacterSync(); initializeCharacterSync();
reconcileDragonrollItems(); reconcileDragonrollItems();
queueFoundryItemFolders(400); queueFoundryItemFolders(400);
initializeSceneSync();
if (queuedActorChanges.size) { if (queuedActorChanges.size) {
clearTimeout(actorSyncTimeout); clearTimeout(actorSyncTimeout);
actorSyncTimeout = setTimeout(flushActorChanges, 400); actorSyncTimeout = setTimeout(flushActorChanges, 400);
@@ -458,6 +466,10 @@ function handleAutoSyncChange(value) {
clearTimeout(itemSyncTimeout); clearTimeout(itemSyncTimeout);
itemSyncTimeout = setTimeout(flushItemChanges, 400); itemSyncTimeout = setTimeout(flushItemChanges, 400);
} }
if (queuedSceneChanges.size) {
clearTimeout(sceneSyncTimeout);
sceneSyncTimeout = setTimeout(flushSceneChanges, 400);
}
} }
function dragonrollActorId(actor) { function dragonrollActorId(actor) {
@@ -523,9 +535,16 @@ function isSupportedCharacterActor(actor) {
return ["character", "npc", "creature"].includes(savedType || actor.type); return ["character", "npc", "creature"].includes(savedType || actor.type);
} }
// Embedded documents the world owns outright (Syndria98/dragonroll#89): a feat is a trait
// and a race is a species — they reach the campaign through its traits and species fields,
// never through its inventory. Dragonroll must neither mark them as its own nor delete one
// when it writes the character, and an older campaign still holding such a row in its
// inventory must be let to write it out of the campaign without the document going with it.
const WORLD_OWNED_EMBEDDED_TYPES = new Set(["feat", "race", "species", "status", "spellbook", "language"]);
async function markActorItemsAsSynced(actor) { async function markActorItemsAsSynced(actor) {
const updates = actor.items.contents const updates = actor.items.contents
.filter((item) => !item.getFlag?.(MODULE_ID, "syncedItem")) .filter((item) => !item.getFlag?.(MODULE_ID, "syncedItem") && !WORLD_OWNED_EMBEDDED_TYPES.has(item.type))
.map((item) => ({ .map((item) => ({
_id: item.id, _id: item.id,
[`flags.${MODULE_ID}.syncedItem`]: true, [`flags.${MODULE_ID}.syncedItem`]: true,
@@ -1194,7 +1213,19 @@ async function reconcileEmbeddedItems(actor, entry) {
const existing = actor.items.contents.find((item) => item.name === wanted.name const existing = actor.items.contents.find((item) => item.name === wanted.name
&& item.type === wanted.type && item.getFlag?.(MODULE_ID, "syncedItem")) && item.type === wanted.type && item.getFlag?.(MODULE_ID, "syncedItem"))
|| actor.items.contents.find((item) => item.name === wanted.name || actor.items.contents.find((item) => item.name === wanted.name
&& item.getFlag?.(MODULE_ID, "syncedItem")); && item.getFlag?.(MODULE_ID, "syncedItem") && !WORLD_OWNED_EMBEDDED_TYPES.has(item.type));
// A carried row holding the name of one of the world's own trait or species documents
// — a trait a campaign that synced before #89 still has in its inventory — stands in
// the world as that document: no loot is made after its name, and the document itself
// is let be. Writing it out of the campaign is the campaign's to do, keeping it is the world's.
if (!existing && wanted.type === "loot") {
const worldOwned = actor.items.contents.find((item) => item.name === wanted.name
&& WORLD_OWNED_EMBEDDED_TYPES.has(item.type));
if (worldOwned) {
retainedIds.add(worldOwned.id);
continue;
}
}
if (existing) { if (existing) {
retainedIds.add(existing.id); retainedIds.add(existing.id);
const update = { _id: existing.id }; const update = { _id: existing.id };
@@ -1220,7 +1251,8 @@ async function reconcileEmbeddedItems(actor, entry) {
} }
const staleItemIds = actor.items.contents const staleItemIds = actor.items.contents
.filter((item) => item.getFlag?.(MODULE_ID, "syncedItem") && !retainedIds.has(item.id)) .filter((item) => item.getFlag?.(MODULE_ID, "syncedItem") && !retainedIds.has(item.id)
&& !WORLD_OWNED_EMBEDDED_TYPES.has(item.type))
.map((item) => item.id); .map((item) => item.id);
if (staleItemIds.length) await actor.deleteEmbeddedDocuments("Item", staleItemIds); if (staleItemIds.length) await actor.deleteEmbeddedDocuments("Item", staleItemIds);
} }
@@ -1336,6 +1368,102 @@ function queueFoundryActorChange(kind, actor) {
queueActorChange(kind, actor); queueActorChange(kind, actor);
} }
// --- Scene sync ---------------------------------------------------------------
// A scene of this world is one of the campaign's maps (Syndria98/dragonroll#99): its
// background picture and the grid laid over it travel to Dragonroll, which keeps a map per
// scene. That is all of a scene that crosses over — pinning notes on a map, standing tokens
// on it and saying how far one of its cells goes are the campaign's own business, so none
// of it comes back to the world.
// A scene travels as plain document data with its picture read from this world: Dragonroll
// draws it outside Foundry, so the path becomes an absolute URL the way a portrait does.
// Since V13 the picture sits under `background.src`, and under plain `img` before that.
function serializeFoundryScene(scene) {
const data = toPlainData(scene);
if (!data) return null;
const absolute = (path) => new URL(path, window.location.origin).toString();
if (data.background?.src && !/^(https?:|data:|\/\/)/i.test(data.background.src)) {
data.background = { ...data.background, src: absolute(data.background.src) };
} else if (data.img && !/^(https?:|data:|\/\/)/i.test(data.img)) {
data.img = absolute(data.img);
}
return data;
}
// The scenes the campaign mirrors as its maps. Every scene goes, including one with no
// picture: Dragonroll decides what of a scene is a map and, since such a scene's id is
// still listed, no map of the campaign is pruned because of it.
async function pushFoundryScenes(scenes, fullSync = false) {
const token = getSyncToken();
// A full push travels even with no scenes left: it is the one that tells the campaign
// which of the maps it mirrors from this world the world has let go of.
if (!token || !game.user?.isGM || !game.world || (!scenes.length && !fullSync)) return;
await postDragonroll("foundry/sync/scenes", {
worldId: game.world.id,
scenes: scenes.map(serializeFoundryScene).filter(Boolean),
fullSync,
}, token);
sceneSyncErrorLogged = false;
}
async function deleteDragonrollScene(foundrySceneId) {
const token = getSyncToken();
if (!token || !game.world || !foundrySceneId) return;
await postDragonroll("foundry/sync/scene-delete", {
worldId: game.world.id,
foundrySceneId,
}, token);
}
function reportSceneSyncError(error) {
if (sceneSyncErrorLogged) return;
sceneSyncErrorLogged = true;
console.warn(`${MODULE_ID} | Map sync failed and will retry.`, error);
}
function queueFoundrySceneChange(kind, scene) {
if (!scene || !game.user?.isGM || !getSyncToken()) return;
queuedSceneChanges.set(scene.id, { kind, scene });
clearTimeout(sceneSyncTimeout);
sceneSyncTimeout = setTimeout(flushSceneChanges, 400);
}
async function flushSceneChanges() {
// Autosync off: the scene edits wait here, like the actor and item changes do.
if (!isAutoSyncEnabled()) return;
const changes = [...queuedSceneChanges.values()];
queuedSceneChanges.clear();
const deleted = changes.filter((change) => change.kind === "delete");
const changed = changes.filter((change) => change.kind !== "delete");
try {
for (const change of deleted) await deleteDragonrollScene(change.scene.id);
if (changed.length) await pushFoundryScenes(changed.map((change) => change.scene));
} catch (error) {
reportSceneSyncError(error);
for (const change of changes) queuedSceneChanges.set(change.scene.id, change);
clearTimeout(sceneSyncTimeout);
sceneSyncTimeout = setTimeout(flushSceneChanges, 5000);
}
}
// The whole scene list travels when the world links and when it loads: the campaign's map
// list mirrors this world's scenes, and only a push holding every scene can say which of
// those maps the world has let go of.
async function initializeSceneSync() {
if (!getSyncToken() || !game.user?.isGM || !game.world || !isAutoSyncEnabled()) return;
try {
await pushFoundryScenes(game.scenes?.contents || [], true);
} catch (error) {
reportSceneSyncError(error);
clearTimeout(sceneSyncRetryTimeout);
sceneSyncRetryTimeout = setTimeout(initializeSceneSync, 15000);
}
}
async function publishSnapshot() { async function publishSnapshot() {
if (!game.user?.isGM || !game.world) return; if (!game.user?.isGM || !game.world) return;
if (syncInProgress) { if (syncInProgress) {
@@ -1428,6 +1556,10 @@ Hooks.once("ready", () => {
// already seen the world directory when it starts sending its own items back. // already seen the world directory when it starts sending its own items back.
setTimeout(reconcileDragonrollItems, 2000); setTimeout(reconcileDragonrollItems, 2000);
setInterval(reconcileDragonrollItems, 5000); setInterval(reconcileDragonrollItems, 5000);
// The campaign's maps mirror this world's scenes: the whole list goes once the world is
// loaded, and that push alone tells the campaign which of its synced maps this world has
// let go of.
setTimeout(initializeSceneSync, 3000);
for (const event of [ for (const event of [
"createActor", "updateActor", "deleteActor", "createActor", "updateActor", "deleteActor",
@@ -1461,6 +1593,13 @@ Hooks.once("ready", () => {
queueFoundryItemChange(isDelete ? "delete" : "upsert", document); queueFoundryItemChange(isDelete ? "delete" : "upsert", document);
}); });
} }
// A scene the GM makes, renames or throws away is one of the campaign's maps being drawn
// or let go of (Syndria98/dragonroll#99). Only its picture and grid cross over, so this
// goes one way and needs no snapshot of the world behind it.
for (const event of ["createScene", "updateScene", "deleteScene"]) {
Hooks.on(event, (document) => queueFoundrySceneChange(event.startsWith("delete") ? "delete" : "upsert", document));
}
}); });
// A GM sends selected actors to Dragonroll from the actor directory's context // A GM sends selected actors to Dragonroll from the actor directory's context

View File

@@ -417,4 +417,89 @@ span.artifact {
.fold.is-collapsed > .fold-body { .fold.is-collapsed > .fold-body {
display: none; display: none;
}
/* El markdown renderitzat de la documentació: tot dins de .docs-markdown, que ve de v-html.
Va aquí perquè la pàgina de /docs (views/DocsView.vue) i la finestra de documentació
(windows/DocumentationWindow.vue) se'l serveixen plegades. */
.docs-markdown h1 {
margin: 0 0 14px 0;
font-family: 'MrEavesRemake', serif;
font-size: 2rem;
font-weight: normal;
line-height: 1.2;
}
.docs-markdown h2 {
margin: 30px 0 10px 0;
padding-bottom: 4px;
border-bottom: 1px solid var(--color-border);
font-family: 'MrEavesRemake', serif;
font-size: 1.35rem;
font-weight: normal;
scroll-margin-top: 20px;
}
.docs-markdown h3 {
margin: 22px 0 8px 0;
font-family: 'MrEavesRemake', serif;
font-size: 1.1rem;
font-weight: normal;
scroll-margin-top: 20px;
}
.docs-markdown p,
.docs-markdown li {
line-height: 1.65;
}
.docs-markdown ul,
.docs-markdown ol {
margin: 10px 0;
padding-left: 1.5em;
}
.docs-markdown a {
color: var(--color-link);
}
.docs-markdown code {
padding: 1px 5px;
border-radius: 4px;
background-color: var(--color-background-light);
font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
font-size: 0.9em;
}
.docs-markdown pre {
margin: 14px 0;
padding: 12px 14px;
border: 1px solid var(--color-border);
border-radius: 8px;
background-color: var(--color-background-light);
overflow-x: auto;
}
.docs-markdown pre code {
padding: 0;
background-color: transparent;
}
.docs-markdown table {
margin: 14px 0;
border-collapse: collapse;
width: 100%;
}
.docs-markdown th,
.docs-markdown td {
padding: 7px 10px;
border: 1px solid var(--color-border);
text-align: left;
vertical-align: top;
line-height: 1.5;
}
.docs-markdown th {
background-color: var(--color-background-light);
} }

View File

@@ -13,6 +13,13 @@ function OpenCampaignSettings() {
CreateWindow('campaign_settings', { campaign: Campaign.value }); CreateWindow('campaign_settings', { campaign: Campaign.value });
} }
function OpenDocumentation() {
// La documentació és una finestra que va davant de l'espai de treball, així que les notes
// obertes no es perden. CreateWindow deixa sola una finestra que ja és oberta: tornar a
// prémer el botó no la torna a la primera pàgina.
CreateWindow('documentation');
}
function ExitCampaign() { function ExitCampaign() {
// Torn al menú principal: neteja la campanya (i el localStorage), amaga // Torn al menú principal: neteja la campanya (i el localStorage), amaga
// l'espai de treball i reobre el menú // l'espai de treball i reobre el menú
@@ -35,6 +42,11 @@ function ExitCampaign() {
<TopSearchBar></TopSearchBar> <TopSearchBar></TopSearchBar>
</div> </div>
<div class="right"> <div class="right">
<!-- La documentació s'obre en una finestra seva, davant de la campanya: les notes
obertes no es perden i no cal obrir una pestanya nova. -->
<button class="btn-primary settings-button docs-button sound-click" type="button" @click="OpenDocumentation">
{{ $t('main-menu.documentation') }}
</button>
<button class="btn-primary settings-button sound-click" type="button" @click="OpenCampaignSettings"> <button class="btn-primary settings-button sound-click" type="button" @click="OpenCampaignSettings">
{{ $t('main-menu.settings') }} {{ $t('main-menu.settings') }}
</button> </button>

View File

@@ -108,11 +108,13 @@ useHead({
color: var(--color-text); color: var(--color-text);
} }
/* Els dos aside fan la pàgina sencera avall: amb alçada d'una pantalla i enganxats a
dalt, el fons i la vora arriben sempre fins a baix, per molt llarg que sigui el text. */
.docs-sidebar, .docs-sidebar,
.docs-sections { .docs-sections {
position: sticky; position: sticky;
top: 0; top: 0;
max-height: 100vh; height: 100vh;
overflow-y: auto; overflow-y: auto;
box-sizing: border-box; box-sizing: border-box;
padding: 18px 14px; padding: 18px 14px;
@@ -122,7 +124,6 @@ useHead({
flex: 0 0 268px; flex: 0 0 268px;
width: 268px; width: 268px;
border-right: 1px solid var(--color-border); border-right: 1px solid var(--color-border);
background-color: var(--color-background-light);
display: flex; display: flex;
flex-direction: column; flex-direction: column;
gap: 14px; gap: 14px;
@@ -208,8 +209,13 @@ useHead({
box-sizing: border-box; box-sizing: border-box;
} }
.docs-article { /* La columna de lectura, centrada dins l'espai que deixa la barra lateral: en una finestra
ampla el text queda al mig, no enganxat a l'esquerra. */
.docs-article,
.docs-pager {
width: 100%;
max-width: 760px; max-width: 760px;
margin-inline: auto;
} }
.docs-kicker { .docs-kicker {
@@ -221,7 +227,6 @@ useHead({
} }
.docs-pager { .docs-pager {
max-width: 760px;
margin-top: 34px; margin-top: 34px;
padding-top: 18px; padding-top: 18px;
border-top: 1px solid var(--color-border); border-top: 1px solid var(--color-border);
@@ -256,8 +261,10 @@ useHead({
} }
.docs-sections { .docs-sections {
flex: 0 0 220px; flex: 0 0 240px;
width: 220px; width: 240px;
/* Més aire al voltant dels apartats, que ara mateix van clavats a la vora. */
padding: 26px 22px 26px 18px;
border-left: 1px solid var(--color-border); border-left: 1px solid var(--color-border);
} }
@@ -294,87 +301,19 @@ useHead({
color: var(--color-link); color: var(--color-link);
} }
/* El markdown renderitzat: tot dins de .docs-markdown, perquè ve de v-html. */ /* El markdown renderitzat ve estilat a assets/css/main.scss, sota .docs-markdown, perquè la
.docs-markdown :deep(h1) { finestra de documentació (windows/DocumentationWindow.vue) se'l serveix igualment. */
margin: 0 0 14px 0;
font-family: 'MrEavesRemake', serif;
font-size: 2rem;
font-weight: normal;
line-height: 1.2;
}
.docs-markdown :deep(h2) { /* Finestra molt ampla: tot el conjunt va al mig, així els apartats queden a prop del
margin: 30px 0 10px 0; text en lloc d'estirats cap al cantó dret de la pantalla. */
padding-bottom: 4px; @media (min-width: 1440px) {
border-bottom: 1px solid var(--color-border); .docs {
font-family: 'MrEavesRemake', serif; justify-content: center;
font-size: 1.35rem; }
font-weight: normal;
scroll-margin-top: 20px;
}
.docs-markdown :deep(h3) { .docs-main {
margin: 22px 0 8px 0; flex: 0 1 860px;
font-family: 'MrEavesRemake', serif; }
font-size: 1.1rem;
font-weight: normal;
scroll-margin-top: 20px;
}
.docs-markdown :deep(p),
.docs-markdown :deep(li) {
line-height: 1.65;
}
.docs-markdown :deep(ul),
.docs-markdown :deep(ol) {
margin: 10px 0;
padding-left: 1.5em;
}
.docs-markdown :deep(a) {
color: var(--color-link);
}
.docs-markdown :deep(code) {
padding: 1px 5px;
border-radius: 4px;
background-color: var(--color-background-light);
font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
font-size: 0.9em;
}
.docs-markdown :deep(pre) {
margin: 14px 0;
padding: 12px 14px;
border: 1px solid var(--color-border);
border-radius: 8px;
background-color: var(--color-background-light);
overflow-x: auto;
}
.docs-markdown :deep(pre code) {
padding: 0;
background-color: transparent;
}
.docs-markdown :deep(table) {
margin: 14px 0;
border-collapse: collapse;
width: 100%;
}
.docs-markdown :deep(th),
.docs-markdown :deep(td) {
padding: 7px 10px;
border: 1px solid var(--color-border);
text-align: left;
vertical-align: top;
line-height: 1.5;
}
.docs-markdown :deep(th) {
background-color: var(--color-background-light);
} }
@media (max-width: 1200px) { @media (max-width: 1200px) {
@@ -391,7 +330,7 @@ useHead({
.docs-sidebar, .docs-sidebar,
.docs-sections { .docs-sections {
position: static; position: static;
max-height: none; height: auto;
width: 100%; width: 100%;
border-left: none; border-left: none;
border-right: none; border-right: none;

View File

@@ -319,7 +319,10 @@ async function saveSheet() {
<div v-if="error" class="sheet-error">{{ error }}</div> <div v-if="error" class="sheet-error">{{ error }}</div>
<main v-show="activeTab === 'abilities'" class="sheet-grid"> <!-- La columna del personatge no penja de cap pestanya: la imatge i el que es mira
d'anada i tornada — classe d'armadura, velocitat, bonificadors i les barres de
cops — es queden a la vista des de qualsevol pestanya de la fitxa. -->
<div class="sheet-layout">
<div class="character-column"> <div class="character-column">
<div v-if="form.image || editing" class="sheet-portrait" :class="{ empty: !form.image }"> <div v-if="form.image || editing" class="sheet-portrait" :class="{ empty: !form.image }">
<img v-if="form.image" :src="imageUrl" :alt="$t('campaigns.character-sheet.photo')"> <img v-if="form.image" :src="imageUrl" :alt="$t('campaigns.character-sheet.photo')">
@@ -387,146 +390,148 @@ async function saveSheet() {
</section> </section>
</div> </div>
<section class="sheet-panel abilities-panel"> <main v-show="activeTab === 'abilities'" class="sheet-tab-body">
<h2>{{ $t('campaigns.character-sheet.ability-scores') }}</h2> <section class="sheet-panel abilities-panel">
<div class="ability-grid"> <h2>{{ $t('campaigns.character-sheet.ability-scores') }}</h2>
<div v-for="stat in abilityStats" :key="stat.key" class="ability-card"> <div class="ability-grid">
<span class="ability-label">{{ stat.label }}</span> <div v-for="stat in abilityStats" :key="stat.key" class="ability-card">
<input v-if="editing" v-model.number="form.abilityScores[stat.key]" type="number" min="1" max="30" :aria-label="stat.label"> <span class="ability-label">{{ stat.label }}</span>
<strong v-else class="ability-score">{{ form.abilityScores[stat.key] }}</strong> <input v-if="editing" v-model.number="form.abilityScores[stat.key]" type="number" min="1" max="30" :aria-label="stat.label">
<span class="ability-modifier">{{ abilityModifier(form.abilityScores[stat.key]) }}</span> <strong v-else class="ability-score">{{ form.abilityScores[stat.key] }}</strong>
<span class="ability-modifier">{{ abilityModifier(form.abilityScores[stat.key]) }}</span>
</div>
</div> </div>
</div>
<!-- Les tirades de salvació van just a sota de les característiques, que <!-- Les tirades de salvació van just a sota de les característiques, que
són les que les manen: el cercle diu si el personatge hi està entrenat. --> són les que les manen: el cercle diu si el personatge hi està entrenat. -->
<h3>{{ $t('campaigns.character-sheet.saving-throws') }}</h3> <h3>{{ $t('campaigns.character-sheet.saving-throws') }}</h3>
<div class="saving-throw-grid"> <div class="saving-throw-grid">
<button <button
v-for="stat in abilityStats" v-for="stat in abilityStats"
:key="stat.key" :key="stat.key"
class="proficiency-row" class="proficiency-row"
type="button" type="button"
role="switch" role="switch"
:aria-checked="form.savingThrows[stat.key]" :aria-checked="form.savingThrows[stat.key]"
:disabled="!editing" :disabled="!editing"
@click="toggleProficiency('savingThrows', stat.key)" @click="toggleProficiency('savingThrows', stat.key)"
> >
<span class="proficiency-dot" :class="{ proficient: form.savingThrows[stat.key] }" aria-hidden="true" /> <span class="proficiency-dot" :class="{ proficient: form.savingThrows[stat.key] }" aria-hidden="true" />
<span class="proficiency-name">{{ $t(`campaigns.character-sheet.abilities.${stat.key}`) }}</span> <span class="proficiency-name">{{ $t(`campaigns.character-sheet.abilities.${stat.key}`) }}</span>
<span class="proficiency-modifier">{{ savingThrowModifier(stat) }}</span> <span class="proficiency-modifier">{{ savingThrowModifier(stat) }}</span>
</button> </button>
</div>
</section>
<section class="sheet-panel skills-panel">
<h2>{{ $t('campaigns.character-sheet.skills') }}</h2>
<div class="skill-grid">
<button
v-for="skill in skillList"
:key="skill.key"
class="proficiency-row"
type="button"
role="switch"
:aria-checked="form.skills[skill.key]"
:disabled="!editing"
@click="toggleProficiency('skills', skill.key)"
>
<span class="proficiency-dot" :class="{ proficient: form.skills[skill.key] }" aria-hidden="true" />
<span class="proficiency-name">{{ $t(`campaigns.character-sheet.skill-names.${skill.key}`) }}</span>
<span class="proficiency-ability">{{ skill.ability.toUpperCase() }}</span>
<span class="proficiency-modifier">{{ skillModifier(skill) }}</span>
</button>
</div>
</section>
<section class="sheet-panel proficiencies-panel">
<h2>{{ $t('campaigns.character-sheet.proficiencies') }}</h2>
<textarea v-if="editing" v-model="form.proficiencies" rows="7" :placeholder="$t('campaigns.character-sheet.proficiencies-placeholder')" />
<p v-else class="sheet-copy">{{ form.proficiencies || $t('campaigns.character-sheet.empty-proficiencies') }}</p>
<!-- Les eines i els idiomes tenen llista pròpia; el text de dalt guarda
el que no en té, com les armadures i les armes. -->
<div class="proficiency-lists">
<div class="proficiency-list">
<h3>{{ $t('campaigns.character-sheet.tools') }}</h3>
<textarea v-if="editing" v-model="form.tools" rows="4" :placeholder="$t('campaigns.character-sheet.tools-placeholder')" />
<p v-else class="sheet-copy">{{ form.tools || $t('campaigns.character-sheet.empty-tools') }}</p>
</div> </div>
<div class="proficiency-list"> </section>
<h3>{{ $t('campaigns.character-sheet.languages') }}</h3>
<textarea v-if="editing" v-model="form.languages" rows="4" :placeholder="$t('campaigns.character-sheet.languages-placeholder')" /> <section class="sheet-panel skills-panel">
<p v-else class="sheet-copy">{{ form.languages || $t('campaigns.character-sheet.empty-languages') }}</p> <h2>{{ $t('campaigns.character-sheet.skills') }}</h2>
<div class="skill-grid">
<button
v-for="skill in skillList"
:key="skill.key"
class="proficiency-row"
type="button"
role="switch"
:aria-checked="form.skills[skill.key]"
:disabled="!editing"
@click="toggleProficiency('skills', skill.key)"
>
<span class="proficiency-dot" :class="{ proficient: form.skills[skill.key] }" aria-hidden="true" />
<span class="proficiency-name">{{ $t(`campaigns.character-sheet.skill-names.${skill.key}`) }}</span>
<span class="proficiency-ability">{{ skill.ability.toUpperCase() }}</span>
<span class="proficiency-modifier">{{ skillModifier(skill) }}</span>
</button>
</div> </div>
</div> </section>
</section>
</main>
<main v-show="activeTab === 'inventory'" class="sheet-tab-body"> <section class="sheet-panel proficiencies-panel">
<section class="sheet-panel inventory-panel"> <h2>{{ $t('campaigns.character-sheet.proficiencies') }}</h2>
<div class="panel-title-row"> <textarea v-if="editing" v-model="form.proficiencies" rows="7" :placeholder="$t('campaigns.character-sheet.proficiencies-placeholder')" />
<h2>{{ $t('campaigns.character-sheet.inventory') }}</h2> <p v-else class="sheet-copy">{{ form.proficiencies || $t('campaigns.character-sheet.empty-proficiencies') }}</p>
<button v-if="editing" class="sheet-button secondary compact" type="button" @click="addInventoryItem">{{ $t('campaigns.character-sheet.add-item') }}</button>
</div>
<div class="weight-summary">
<span>{{ $t('campaigns.character-sheet.carried-weight') }}</span>
<strong>{{ carriedWeight.toFixed(1) }} / {{ carryingCapacity }} lb</strong>
</div>
<div class="weight-track"><div class="weight-fill" :style="{ width: `${carryPercent}%` }" /></div>
<!-- La moneda que el personatge porta a sobre, en les cinc monedes del joc. --> <!-- Les eines i els idiomes tenen llista pròpia; el text de dalt guarda
<h3>{{ $t('campaigns.character-sheet.currency') }}</h3> el que no en té, com les armadures i les armes. -->
<div class="currency-row"> <div class="proficiency-lists">
<label v-for="unit in currencyUnits" :key="unit" class="currency-field"> <div class="proficiency-list">
<span>{{ $t(`campaigns.character-sheet.currency-units.${unit}`) }}</span> <h3>{{ $t('campaigns.character-sheet.tools') }}</h3>
<input v-if="editing" v-model.number="form.currency[unit]" type="number" min="0" :aria-label="$t(`campaigns.character-sheet.currency-units.${unit}`)"> <textarea v-if="editing" v-model="form.tools" rows="4" :placeholder="$t('campaigns.character-sheet.tools-placeholder')" />
<strong v-else>{{ form.currency[unit] }}</strong> <p v-else class="sheet-copy">{{ form.tools || $t('campaigns.character-sheet.empty-tools') }}</p>
</label> </div>
</div> <div class="proficiency-list">
<div class="inventory-table-wrap"> <h3>{{ $t('campaigns.character-sheet.languages') }}</h3>
<table class="inventory-table"> <textarea v-if="editing" v-model="form.languages" rows="4" :placeholder="$t('campaigns.character-sheet.languages-placeholder')" />
<thead><tr> <p v-else class="sheet-copy">{{ form.languages || $t('campaigns.character-sheet.empty-languages') }}</p>
<th><span class="sr-only">{{ $t('campaigns.character-sheet.item-icon') }}</span></th> </div>
<th class="item-name-cell">{{ $t('campaigns.character-sheet.item-name') }}</th> </div>
<th>{{ $t('campaigns.character-sheet.quantity') }}</th> </section>
<th>{{ $t('campaigns.character-sheet.weight-each') }}</th> </main>
<th>{{ $t('campaigns.character-sheet.total-weight') }}</th>
<th v-if="editing"><span class="sr-only">{{ $t('campaigns.character-sheet.actions') }}</span></th>
</tr></thead>
<tbody>
<tr v-for="(item, index) in form.inventory" :key="index">
<td class="item-icon-cell">
<img v-if="item.icon" :src="resolveImage(item.icon)" :alt="$t('campaigns.character-sheet.item-icon')">
<span v-else class="item-icon-blank" aria-hidden="true" />
</td>
<td class="item-name-cell"><input v-if="editing" v-model="item.name" :aria-label="$t('campaigns.character-sheet.item-name')"><span v-else>{{ item.name }}</span></td>
<td><input v-if="editing" v-model.number="item.quantity" type="number" min="1" :aria-label="$t('campaigns.character-sheet.quantity')"><span v-else>{{ item.quantity }}</span></td>
<td><input v-if="editing" v-model.number="item.weight" type="number" min="0" step="0.1" :aria-label="$t('campaigns.character-sheet.weight-each')"><span v-else>{{ Number(item.weight).toFixed(1) }} lb</span></td>
<td>{{ ((Number(item.quantity) || 0) * (Number(item.weight) || 0)).toFixed(1) }} lb</td>
<td v-if="editing"><button class="remove-item" type="button" @click="removeInventoryItem(index)">×</button></td>
</tr>
<tr v-if="form.inventory.length === 0"><td :colspan="editing ? 6 : 5" class="empty-inventory">{{ $t('campaigns.character-sheet.empty-inventory') }}</td></tr>
</tbody>
</table>
</div>
</section>
</main>
<main v-show="activeTab === 'traits'" class="sheet-tab-body"> <main v-show="activeTab === 'inventory'" class="sheet-tab-body">
<section class="sheet-panel traits-panel"> <section class="sheet-panel inventory-panel">
<h2>{{ $t('campaigns.character-sheet.traits') }}</h2> <div class="panel-title-row">
<textarea v-if="editing" v-model="form.traits" rows="12" :placeholder="$t('campaigns.character-sheet.traits-placeholder')" /> <h2>{{ $t('campaigns.character-sheet.inventory') }}</h2>
<p v-else class="sheet-copy">{{ form.traits || $t('campaigns.character-sheet.empty-traits') }}</p> <button v-if="editing" class="sheet-button secondary compact" type="button" @click="addInventoryItem">{{ $t('campaigns.character-sheet.add-item') }}</button>
</section> </div>
</main> <div class="weight-summary">
<span>{{ $t('campaigns.character-sheet.carried-weight') }}</span>
<strong>{{ carriedWeight.toFixed(1) }} / {{ carryingCapacity }} lb</strong>
</div>
<div class="weight-track"><div class="weight-fill" :style="{ width: `${carryPercent}%` }" /></div>
<main v-show="activeTab === 'spells'" class="sheet-tab-body"> <!-- La moneda que el personatge porta a sobre, en les cinc monedes del joc. -->
<section class="sheet-panel spells-panel"> <h3>{{ $t('campaigns.character-sheet.currency') }}</h3>
<h2>{{ $t('campaigns.character-sheet.spells') }}</h2> <div class="currency-row">
<textarea v-if="editing" v-model="form.spells" rows="12" :placeholder="$t('campaigns.character-sheet.spells-placeholder')" /> <label v-for="unit in currencyUnits" :key="unit" class="currency-field">
<p v-else class="sheet-copy">{{ form.spells || $t('campaigns.character-sheet.empty-spells') }}</p> <span>{{ $t(`campaigns.character-sheet.currency-units.${unit}`) }}</span>
</section> <input v-if="editing" v-model.number="form.currency[unit]" type="number" min="0" :aria-label="$t(`campaigns.character-sheet.currency-units.${unit}`)">
</main> <strong v-else>{{ form.currency[unit] }}</strong>
</label>
</div>
<div class="inventory-table-wrap">
<table class="inventory-table">
<thead><tr>
<th><span class="sr-only">{{ $t('campaigns.character-sheet.item-icon') }}</span></th>
<th class="item-name-cell">{{ $t('campaigns.character-sheet.item-name') }}</th>
<th>{{ $t('campaigns.character-sheet.quantity') }}</th>
<th>{{ $t('campaigns.character-sheet.weight-each') }}</th>
<th>{{ $t('campaigns.character-sheet.total-weight') }}</th>
<th v-if="editing"><span class="sr-only">{{ $t('campaigns.character-sheet.actions') }}</span></th>
</tr></thead>
<tbody>
<tr v-for="(item, index) in form.inventory" :key="index">
<td class="item-icon-cell">
<img v-if="item.icon" :src="resolveImage(item.icon)" :alt="$t('campaigns.character-sheet.item-icon')">
<span v-else class="item-icon-blank" aria-hidden="true" />
</td>
<td class="item-name-cell"><input v-if="editing" v-model="item.name" :aria-label="$t('campaigns.character-sheet.item-name')"><span v-else>{{ item.name }}</span></td>
<td><input v-if="editing" v-model.number="item.quantity" type="number" min="1" :aria-label="$t('campaigns.character-sheet.quantity')"><span v-else>{{ item.quantity }}</span></td>
<td><input v-if="editing" v-model.number="item.weight" type="number" min="0" step="0.1" :aria-label="$t('campaigns.character-sheet.weight-each')"><span v-else>{{ Number(item.weight).toFixed(1) }} lb</span></td>
<td>{{ ((Number(item.quantity) || 0) * (Number(item.weight) || 0)).toFixed(1) }} lb</td>
<td v-if="editing"><button class="remove-item" type="button" @click="removeInventoryItem(index)">×</button></td>
</tr>
<tr v-if="form.inventory.length === 0"><td :colspan="editing ? 6 : 5" class="empty-inventory">{{ $t('campaigns.character-sheet.empty-inventory') }}</td></tr>
</tbody>
</table>
</div>
</section>
</main>
<main v-show="activeTab === 'traits'" class="sheet-tab-body">
<section class="sheet-panel traits-panel">
<h2>{{ $t('campaigns.character-sheet.traits') }}</h2>
<textarea v-if="editing" v-model="form.traits" rows="12" :placeholder="$t('campaigns.character-sheet.traits-placeholder')" />
<p v-else class="sheet-copy">{{ form.traits || $t('campaigns.character-sheet.empty-traits') }}</p>
</section>
</main>
<main v-show="activeTab === 'spells'" class="sheet-tab-body">
<section class="sheet-panel spells-panel">
<h2>{{ $t('campaigns.character-sheet.spells') }}</h2>
<textarea v-if="editing" v-model="form.spells" rows="12" :placeholder="$t('campaigns.character-sheet.spells-placeholder')" />
<p v-else class="sheet-copy">{{ form.spells || $t('campaigns.character-sheet.empty-spells') }}</p>
</section>
</main>
</div>
</div> </div>
</div> </div>
</template> </template>
@@ -550,8 +555,10 @@ async function saveSheet() {
.sheet-button.primary { background: var(--color-link); color: var(--color-background); border-color: var(--color-link); } .sheet-button.primary { background: var(--color-link); color: var(--color-background); border-color: var(--color-link); }
.sheet-button:disabled { opacity: .55; cursor: wait; } .sheet-button:disabled { opacity: .55; cursor: wait; }
.sheet-button.compact { padding: 5px 9px; font-size: 12px; } .sheet-button.compact { padding: 5px 9px; font-size: 12px; }
.sheet-grid { display: grid; grid-template-columns: minmax(200px, 34%) minmax(0, 1fr) minmax(0, 1fr); grid-template-rows: auto auto auto; gap: 11px; align-items: start; } /* El marc de la fitxa: la columna del personatge, sempre a la vista, i al seu costat el contingent
.sheet-tab-body { display: block; } de la pestanya oberta. */
.sheet-layout { display: grid; grid-template-columns: minmax(200px, 34%) minmax(0, 1fr); gap: 11px; align-items: start; }
.sheet-tab-body { grid-column: 2; grid-row: 1; display: flex; flex-direction: column; gap: 11px; min-width: 0; }
/* Pestilletes del marc: arrencen del cantó dret de la finestra, per fora del cos, i queden /* Pestilletes del marc: arrencen del cantó dret de la finestra, per fora del cos, i queden
fora del contingent que desfila. Per sota de 760px no hi ha lloc fora (vegeu a sota). */ fora del contingent que desfila. Per sota de 760px no hi ha lloc fora (vegeu a sota). */
.sheet-tabs { position: absolute; left: 100%; top: 34px; display: flex; flex-direction: column; align-items: flex-start; gap: 5px; padding-top: 6px; } .sheet-tabs { position: absolute; left: 100%; top: 34px; display: flex; flex-direction: column; align-items: flex-start; gap: 5px; padding-top: 6px; }
@@ -585,11 +592,9 @@ async function saveSheet() {
.portrait-controls button:disabled { opacity: .55; cursor: wait; } .portrait-controls button:disabled { opacity: .55; cursor: wait; }
.photo-input { display: none; } .photo-input { display: none; }
/* La columna de la fitxa: la imatge dalt i, just a sota, el que es consulta d'anada i /* La columna de la fitxa: la imatge dalt i, just a sota, el que es consulta d'anada i
tornada — classe d'armadura, velocitat, bonificadors i les barres de cops. */ tornada — classe d'armadura, velocitat, bonificadors i les barres de cops. No penja de
.character-column { grid-column: 1; grid-row: 1 / -1; display: flex; flex-direction: column; gap: 11px; min-width: 0; } cap pestanya: es queda al seu lloc mentre se'n canvia. */
.abilities-panel { grid-column: 2 / -1; grid-row: 1; } .character-column { grid-column: 1; grid-row: 1; display: flex; flex-direction: column; gap: 11px; min-width: 0; }
.skills-panel { grid-column: 2 / -1; grid-row: 2; }
.proficiencies-panel { grid-column: 2 / -1; grid-row: 3; }
.ability-grid { display: grid; grid-template-columns: repeat(6, minmax(0, 1fr)); gap: 7px; } .ability-grid { display: grid; grid-template-columns: repeat(6, minmax(0, 1fr)); gap: 7px; }
.ability-card { min-height: 83px; padding: 8px 5px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 3px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); } .ability-card { min-height: 83px; padding: 8px 5px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 3px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); }
.ability-label { font-size: 11px; font-weight: 700; letter-spacing: .08em; opacity: .75; } .ability-label { font-size: 11px; font-weight: 700; letter-spacing: .08em; opacity: .75; }
@@ -663,8 +668,8 @@ textarea { resize: vertical; width: 100%; min-height: 88px; font-size: 12px; }
.sheet-error { padding: 7px 10px; margin-bottom: 10px; border-radius: 6px; color: var(--color-red); background: var(--color-background-soft); font-size: 12px; } .sheet-error { padding: 7px 10px; margin-bottom: 10px; border-radius: 6px; color: var(--color-red); background: var(--color-background-soft); font-size: 12px; }
.sr-only { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0; } .sr-only { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0; }
@media (max-width: 760px) { @media (max-width: 760px) {
.sheet-grid { grid-template-columns: 1fr; grid-template-rows: none; } .sheet-layout { grid-template-columns: 1fr; }
.character-column, .abilities-panel, .skills-panel, .proficiencies-panel { grid-column: 1 / -1; grid-row: auto; } .character-column, .sheet-tab-body { grid-column: 1 / -1; grid-row: auto; }
/* El cantó dret no dona prou per penjar-hi les pestanyes: llavors es queden al marc, per /* El cantó dret no dona prou per penjar-hi les pestanyes: llavors es queden al marc, per
dins, en una filera sota la barra de la finestra. */ dins, en una filera sota la barra de la finestra. */
.sheet-tabs { position: static; align-self: stretch; flex-direction: row; flex-wrap: wrap; gap: 4px; padding: 6px 8px 0; } .sheet-tabs { position: static; align-self: stretch; flex-direction: row; flex-wrap: wrap; gap: 4px; padding: 6px 8px 0; }

View File

@@ -0,0 +1,261 @@
<script setup>
import { computed, nextTick, onMounted, ref } from 'vue';
import { SetupHandle, SetSize, ResetPosition, Top, SetResizable, SetMinSize } from '@/services/Windows';
import WindowHandle from './partials/WindowHandle.vue';
import { GetDocsFirstSlug, GetDocsNav, GetDocsPage } from '~/services/Docs';
// La documentació dins d'una finestra: el sumari a l'esquerra i la pàgina al centre, amb el
// mateix contingut de app/content/docs que la pàgina pública de /docs (mira ~/services/Docs.js).
// El sumari no porta enlloc amb rutes sinó amb estat propi, així obrir la documentació dins
// d'una campanya no deixa les notes obertes enrere.
const props = defineProps(['data']);
const id = props.data.id;
const handle = ref(null);
const wrapper = ref(null);
const reading = ref(null);
const nav = GetDocsNav();
const slug = ref(GetDocsFirstSlug());
const page = computed(() => GetDocsPage(slug.value));
function GoTo(target) {
if (!GetDocsPage(target)) return;
slug.value = target;
// Cada pàgina es comença a dalt, com faria el navegador.
nextTick(() => { if (reading.value) reading.value.scrollTop = 0; });
}
// Els enllaços que el markdown porta a dins (`[Foundry](/docs/foundry)`) i els seus apartats
// s'han de seguir dins la finestra: sortir-ne per via d'una ruta deixaria la campanya enrere.
function OnContentClick(event) {
const link = event.target?.closest?.('a');
if (!link) return;
const href = link.getAttribute('href') || '';
// Un apartat de la pàgina: el que fila és la columna de lectura, no la pantalla.
if (href.startsWith('#')) {
if (href.length < 2) return;
const heading = reading.value?.querySelector('#' + CSS.escape(href.slice(1)));
if (!heading) return;
event.preventDefault();
heading.scrollIntoView({ block: 'start' });
return;
}
const inside = /^\/docs\/?([a-z0-9-]*)$/.exec(href);
if (inside) {
event.preventDefault();
GoTo(inside[1] || GetDocsFirstSlug());
return;
}
// Fora de la documentació: una pestanya nova, que la campanya no es mou d'aquí.
if (href && !href.startsWith('/')) {
event.preventDefault();
window.open(href, '_blank', 'noopener');
}
}
onMounted(() => {
Top(wrapper);
SetupHandle(id, handle);
SetSize(id, {
width: Math.max(620, Math.min(1000, window.innerWidth - 24)),
height: Math.max(420, Math.min(780, window.innerHeight - 32))
});
ResetPosition(id, 'center');
SetResizable(id, true);
SetMinSize(id, { width: 620, height: 420 });
});
</script>
<template>
<div class="window-wrapper" :id="'window-wrapper-' + id" ref="wrapper">
<WindowHandle :window="id" ref="handle"></WindowHandle>
<!-- Body -->
<div class="docs-body">
<aside class="docs-contents" :aria-label="$t('docs.contents')">
<section v-for="group in nav" :key="group.key" class="docs-group">
<h2 class="docs-group-title">{{ $t(`docs.groups.${group.key}`) }}</h2>
<ul>
<li v-for="entry in group.pages" :key="entry.slug">
<button
type="button"
class="docs-nav-link sound-click"
:class="{ active: entry.slug === slug }"
v-on:click="GoTo(entry.slug)"
>{{ entry.title }}</button>
</li>
</ul>
</section>
</aside>
<div class="docs-reading" ref="reading">
<template v-if="page">
<article class="docs-article" v-on:click="OnContentClick">
<p class="docs-kicker">{{ $t(`docs.groups.${page.group}`) }}</p>
<!-- El contingut és markdown nostre, de app/content/docs -->
<div class="docs-markdown" v-html="page.html"></div>
</article>
<nav class="docs-pager">
<button
v-if="page.previous"
type="button"
class="docs-pager-link sound-click"
v-on:click="GoTo(page.previous.slug)"
>
<span class="docs-pager-label">{{ $t('docs.previous') }}</span>
<strong>{{ page.previous.title }}</strong>
</button>
<button
v-if="page.next"
type="button"
class="docs-pager-link next sound-click"
v-on:click="GoTo(page.next.slug)"
>
<span class="docs-pager-label">{{ $t('docs.next') }}</span>
<strong>{{ page.next.title }}</strong>
</button>
</nav>
</template>
<article v-else class="docs-article">
<h1>{{ $t('docs.title') }}</h1>
<p>{{ $t('docs.not-found', { page: slug }) }}</p>
</article>
</div>
</div>
</div>
</template>
<style scoped lang="scss">
/* El sumari i la lectura són les dues columnes d'una finestra: cada una fila per la seva,
res d'una pantalla d'alçada ni de sticky, que la finestra ja és el que es mou. */
.docs-body {
display: flex;
flex: 1;
width: 100%;
min-height: 0;
}
.docs-contents {
flex: 0 0 212px;
min-width: 0;
box-sizing: border-box;
padding: 14px 10px;
border-right: 1px solid var(--color-border);
overflow-y: auto;
display: flex;
flex-direction: column;
gap: 16px;
}
.docs-group-title {
margin: 0 0 6px 0;
font-family: 'MrEavesRemake', serif;
font-size: 0.78rem;
font-weight: normal;
letter-spacing: 0.08em;
text-transform: uppercase;
color: var(--color-gray);
}
.docs-contents ul {
margin: 0;
padding: 0;
list-style: none;
display: flex;
flex-direction: column;
gap: 2px;
}
/* Les pàgines del sumari són botons: una finestra no té rutes a seguir. */
.docs-nav-link {
width: 100%;
margin: 0;
padding: 6px 9px;
border: none;
border-radius: 6px;
box-shadow: none;
background-color: transparent;
font-size: 0.95rem;
line-height: 1.35;
text-align: left;
color: var(--color-text);
}
.docs-nav-link:hover {
background-color: var(--color-hover);
}
.docs-nav-link.active {
background-color: var(--color-background-soft);
color: var(--color-link);
}
.docs-reading {
flex: 1;
min-width: 0;
box-sizing: border-box;
padding: 20px 26px 40px 26px;
overflow-y: auto;
/* El que es llegeix es pot seleccionar, encara que una finestra no ho permeti per defecte. */
user-select: text;
}
/* La columna de lectura, centrada dins l'espai que deixa el sumari. */
.docs-article,
.docs-pager {
width: 100%;
max-width: 720px;
margin-inline: auto;
}
.docs-kicker {
margin: 0 0 4px 0;
font-size: 0.8rem;
letter-spacing: 0.08em;
text-transform: uppercase;
color: var(--color-gray);
}
.docs-pager {
margin-top: 30px;
padding-top: 16px;
border-top: 1px solid var(--color-border);
display: flex;
gap: 14px;
}
/* Són els botons d'abans i després, no botons d'un formulari: van plans, com a /docs. */
.docs-pager-link {
flex: 1 1 0;
min-width: 0;
margin: 0;
padding: 10px 12px;
border: 1px solid var(--color-border);
border-radius: 8px;
box-shadow: none;
text-align: left;
color: var(--color-text);
}
.docs-pager-link.next {
text-align: right;
}
.docs-pager-label {
display: block;
font-size: 0.78rem;
letter-spacing: 0.06em;
text-transform: uppercase;
color: var(--color-gray);
}
</style>

View File

@@ -49,3 +49,18 @@ the actor it stands for, and **Enter** does the same on a token focused with the
Tokens belong to the map, not to the actor: the same character can stand on several maps, and taking a Tokens belong to the map, not to the actor: the same character can stand on several maps, and taking a
token off does not remove the character from the campaign. token off does not remove the character from the campaign.
## Maps from a linked Foundry world
With a Foundry world linked to the campaign, its scenes arrive as maps of their own: each one with the
scene's background picture and the grid laid over it, in the scene's own cell size and where the world
shifts that grid onto the picture. That is all a scene lends a map — what one of your cells stands
for, the folder a map stands in, and whatever you pin or stand on it stay yours, and nothing about a
map goes back to the world.
A scene renamed in Foundry, or its grid moved, updates its map. Take the background picture off a
scene and its map keeps the one it has; delete the scene and its map goes with it the next time the
world sends its whole scene list, which is when the world loads. For the same reason a map you delete
in the campaign comes back on the next world load while its scene is still there — take the scene off
in Foundry to be rid of the map. A map you made yourself is never doubled by the scene of it: a scene
arriving with the name of an unmapped map adopts that one. See [Foundry VTT](/docs/foundry).

View File

@@ -1,8 +1,8 @@
# Foundry VTT # Foundry VTT
The Foundry integration keeps a Dragonroll campaign and a Foundry world in step: the world's The Foundry integration keeps a Dragonroll campaign and a Foundry world in step: the world's
characters and item directory arrive in the campaign, and what you change in Dragonroll goes back to characters, item directory and scenes arrive in the campaign, and what you change in Dragonroll of
the world. those characters and items goes back to the world.
There are two separate parts, and you only need the first of them: There are two separate parts, and you only need the first of them:
@@ -51,12 +51,22 @@ Worth knowing:
| The world's **item directory** (the items tab) | The campaign's item list, with category, rarity, quantity, weight, properties and description | | 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 | | 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 folder's colour | The campaign's folder colour — and the other way round, what you colour in Dragonroll lands on the world's folder |
| The world's **scenes** | The campaign's maps: the scene's background picture and the grid laid over it, in the scene's own cell size |
The item list is the world's item directory and nothing else. The gear a character carries is that 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 character's inventory: it travels with the character and stays on its sheet, so a sword a fighter owns
does not turn up in the campaign's item list. Spells, classes, subclasses, backgrounds, feats and does not turn up in the campaign's item list. Spells, classes, subclasses, backgrounds, feats and
species are not gear and are not imported. species are not gear and are not imported.
The world's scenes are the campaign's maps, and only their **background picture** and their **grid**
cross over: a map arrives with the scene's picture and its cell size, and with the grid where the
world shifts it. That is where the two stop — what one of your cells stands for, the folder a map
stands in, the notes pinned onto it and the characters standing on it as tokens stay in the campaign,
and nothing about a map is written back into the world. The scene list goes over when the world links
and when it loads, which is also when the map of a scene the GM deleted goes with it; scenes changed
afterwards arrive as they happen. A scene with no background picture makes no map, and the full list
leaves a map the campaign already had alone, so a grid you lined up yourself survives a reload.
An actor or item keeps the Dragonroll id it was given in a `dragonroll-foundry.actorId` / An actor or item keeps the Dragonroll id it was given in a `dragonroll-foundry.actorId` /
`dragonroll-foundry.itemId` flag, and that is what makes the two sides recognise each other. A world `dragonroll-foundry.itemId` flag, and that is what makes the two sides recognise each other. A world
item that carries no flag is matched by name, so a hand-written item in Dragonroll is adopted instead of item that carries no flag is matched by name, so a hand-written item in Dragonroll is adopted instead of

View File

@@ -120,6 +120,12 @@ const defWindows = {
component: () => import('~/components/windows/PinnedNoteWindow.vue'), component: () => import('~/components/windows/PinnedNoteWindow.vue'),
close: () => ClearWindow({type: 'pinned_note'}), close: () => ClearWindow({type: 'pinned_note'}),
movable: true movable: true
},
documentation: {
title: 'windows.documentation',
component: () => import('~/components/windows/DocumentationWindow.vue'),
close: () => ClearWindow({type: 'documentation'}),
movable: true
} }
} }

View File

@@ -10,6 +10,7 @@
"create-map": "Crear mapa", "create-map": "Crear mapa",
"map-viewer": "Mapa", "map-viewer": "Mapa",
"pinned-note": "Nota fixada", "pinned-note": "Nota fixada",
"documentation": "Documentació",
"item-sheet": "Objecte", "item-sheet": "Objecte",
"icon-source": "Tria una icona", "icon-source": "Tria una icona",
"foundry-icons": "Icones del Foundry" "foundry-icons": "Icones del Foundry"

View File

@@ -10,6 +10,7 @@
"create-map": "Create Map", "create-map": "Create Map",
"map-viewer": "Map", "map-viewer": "Map",
"pinned-note": "Pinned note", "pinned-note": "Pinned note",
"documentation": "Documentation",
"item-sheet": "Item", "item-sheet": "Item",
"icon-source": "Choose an icon", "icon-source": "Choose an icon",
"foundry-icons": "Foundry icons" "foundry-icons": "Foundry icons"

View File

@@ -10,6 +10,7 @@
"create-map": "Crear mapa", "create-map": "Crear mapa",
"map-viewer": "Mapa", "map-viewer": "Mapa",
"pinned-note": "Nota fijada", "pinned-note": "Nota fijada",
"documentation": "Documentación",
"item-sheet": "Objeto", "item-sheet": "Objeto",
"icon-source": "Elegir icono", "icon-source": "Elegir icono",
"foundry-icons": "Iconos de Foundry" "foundry-icons": "Iconos de Foundry"

View File

@@ -0,0 +1,111 @@
// Tests for Syndria98/dragonroll#91: the column that opens the character sheet — the portrait with
// the armor class, the speed, the bonuses and both pools under it — stays on screen whoever's tab is
// open, instead of being the ability scores tab's own content and disappearing when the sheet moves
// to the inventory, the traits or the spells.
//
// The window is a `.vue` file and the repository root installs no dependencies for the frontend, so
// the template and the styles are read out of the source the way tests/character-sheet-tabs.test.js
// and tests/character-sheet-portrait-column.test.js read them.
//
// 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 read = (...parts) => fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
const sheetSource = read("frontend", "app", "components", "windows", "CharacterSheetWindow.vue");
const template = /<template>([\s\S]*)<\/template>/.exec(sheetSource)?.[1] ?? "";
const TAB_KEYS = ["abilities", "inventory", "traits", "spells"];
const COLUMN = '<div class="character-column">';
function tabBody(key) {
const block = new RegExp(`<main v-show="activeTab === '${key}'"[\\s\\S]*?</main>`).exec(template)?.[0];
assert.ok(block, `expected a body for the ${key} tab`);
return block;
}
// The column, taken whole: it stands ahead of the tab bodies, which are its siblings.
function characterColumn() {
const start = template.indexOf(COLUMN);
const end = template.indexOf('<main v-show="activeTab');
assert.ok(start !== -1 && end > start, "expected the character column ahead of the tab bodies");
return template.slice(start, end);
}
// The classes wrapping a tag, worked out by walking the blocks of the template in order the way a
// browser nests them, so a tab cannot hide the column by wrapping it.
function ancestorsOf(needle) {
const at = template.indexOf(needle);
assert.ok(at !== -1, `expected ${needle} in the template`);
const stack = [];
for (const match of template.matchAll(/<(\/?)(div|main|section|header|nav)\b([^>]*)>/g)) {
if (match.index > at) break;
const [, closed, , attrs] = match;
if (closed) stack.pop();
else if (!attrs.trimEnd().endsWith("/")) {
const classes = /\bclass="([^"]*)"/.exec(attrs);
stack.push(classes ? classes[1].trim().split(/\s+/) : []);
}
}
return stack.slice(0, -1).map((classes) => classes.join(" "));
}
test("the character column belongs to no tab", () => {
const column = characterColumn();
assert.ok(column.includes('class="sheet-portrait"'), "the portrait is part of the column");
assert.ok(column.includes('class="sheet-panel vitals-panel"'), "and so is the panel of readouts and bars");
// Nothing toggles the column: no tab decides whether it shows.
assert.doesNotMatch(column, /v-show=/, "the column never hides behind a tab");
for (const key of TAB_KEYS) {
const body = tabBody(key);
assert.doesNotMatch(body, /class="character-column"/, `the ${key} tab does not own the column`);
assert.doesNotMatch(body, /sheet-portrait|vitals-panel/, `the ${key} tab does not hold the column's contents`);
}
});
test("the column and the tab that is open stand beside each other", () => {
const columnWrappers = ancestorsOf(COLUMN);
assert.equal(columnWrappers.at(-1), "sheet-layout", "the column stands in the sheet's own layout");
for (const key of TAB_KEYS) {
assert.deepEqual(
ancestorsOf(`<main v-show="activeTab === '${key}'"`),
columnWrappers,
`the ${key} tab is a sibling of the column, so it is never wrapped around it`
);
}
const layout = /\.sheet-layout\s*\{[^}]*\}/.exec(sheetSource)?.[0] ?? "";
assert.match(layout, /display:\s*grid/, "the layout puts the column and the open tab side by side");
assert.match(
layout,
/grid-template-columns:\s*minmax\(200px,\s*34%\)\s+minmax\(0,\s*1fr\)/,
"the character keeps its own column and the tab has all the room left"
);
const columnRule = /\.character-column\s*\{[^}]*\}/.exec(sheetSource)?.[0] ?? "";
assert.match(columnRule, /grid-column:\s*1/, "the character stands in the first column");
const bodyRule = /\.sheet-tab-body\s*\{[^}]*\}/.exec(sheetSource)?.[0] ?? "";
assert.match(bodyRule, /grid-column:\s*2/, "the open tab takes the space beside it");
assert.match(bodyRule, /grid-row:\s*1/, "and on the same row, so switching a tab leaves the column where it was");
});
test("a narrow window stacks the column over the tab instead of hiding it", () => {
const narrow = /@media \(max-width: 760px\)\s*\{([\s\S]*?)\n\}/.exec(sheetSource)?.[1] ?? "";
assert.match(narrow, /\.sheet-layout\s*\{[^}]*grid-template-columns:\s*1fr/, "the two columns become one");
assert.match(
narrow,
/\.character-column,\s*\.sheet-tab-body\s*\{[^}]*grid-column:\s*1 \/ -1;[^}]*grid-row:\s*auto/,
"the column goes over the tab, it does not go away with it"
);
});
test("what stays on screen is what the sheet is read for", () => {
const column = characterColumn();
for (const key of ["armor-class", "speed", "proficiency-bonus", "initiative", "hit-points", "hit-dice"]) {
assert.ok(column.includes(`campaigns.character-sheet.${key}`), `the ${key} stays visible from any tab`);
}
});

View File

@@ -43,7 +43,7 @@ const normalizeActor = fromSource(script, /function normalizeActor\(actor\) \{[\
const barPercent = fromSource(script, /function barPercent\(current, max\) \{[\s\S]*?\n\}/); const barPercent = fromSource(script, /function barPercent\(current, max\) \{[\s\S]*?\n\}/);
const barPool = fromSource(actorRouteSource, /function barPool\(existing, value\) \{[\s\S]*?\n\}/); const barPool = fromSource(actorRouteSource, /function barPool\(existing, value\) \{[\s\S]*?\n\}/);
// The column that opens the abilities tab: the portrait with everything under it. // The column that stands beside every tab: the portrait with everything under it.
function portraitColumn() { function portraitColumn() {
const start = template.indexOf('<div class="character-column">'); const start = template.indexOf('<div class="character-column">');
const end = template.indexOf('<section class="sheet-panel abilities-panel">'); const end = template.indexOf('<section class="sheet-panel abilities-panel">');

View File

@@ -53,7 +53,6 @@ function tabBody(key) {
test("every tab shows only its own content and hides the others", () => { test("every tab shows only its own content and hides the others", () => {
const abilities = tabBody("abilities"); const abilities = tabBody("abilities");
assert.match(abilities, /class="sheet-portrait"/, "the portrait stays with ability scores");
assert.match(abilities, /class="sheet-panel abilities-panel"/); assert.match(abilities, /class="sheet-panel abilities-panel"/);
assert.match(abilities, /class="sheet-panel proficiencies-panel"/, "the proficiencies ride with the ability scores"); assert.match(abilities, /class="sheet-panel proficiencies-panel"/, "the proficiencies ride with the ability scores");
for (const other of ["inventory-panel", "traits-panel", "spells-panel"]) { for (const other of ["inventory-panel", "traits-panel", "spells-panel"]) {
@@ -63,7 +62,12 @@ test("every tab shows only its own content and hides the others", () => {
for (const [key, panel] of [["inventory", "inventory-panel"], ["traits", "traits-panel"], ["spells", "spells-panel"]]) { for (const [key, panel] of [["inventory", "inventory-panel"], ["traits", "traits-panel"], ["spells", "spells-panel"]]) {
const body = tabBody(key); const body = tabBody(key);
assert.ok(body.includes(panel), `the ${key} tab shows the ${panel}`); assert.ok(body.includes(panel), `the ${key} tab shows the ${panel}`);
assert.doesNotMatch(body, /class="sheet-portrait"/); }
// #91 took the character column out of the tabs: it stands beside every one of them, so no tab
// body holds the portrait (see tests/character-sheet-persistent-column.test.js).
for (const key of ["abilities", "inventory", "traits", "spells"]) {
assert.doesNotMatch(tabBody(key), /class="sheet-portrait"/, `the portrait is not the ${key} tab's to hide`);
} }
// the panels are toggled, not unmounted, so editing on one tab and flipping away keeps the draft // the panels are toggled, not unmounted, so editing on one tab and flipping away keeps the draft

View File

@@ -0,0 +1,524 @@
// Tests for Syndria98/dragonroll#89: on the character sheet traits and items were all
// displayed together and the icons did not load. The world's mapper put every embedded
// document that was not a class, subclass, background or spell into the character's
// inventory — so its traits (feat items) and its species (the race item) stood in the
// inventory list beside the gear, while the sheet already shows both in fields of their
// own. And a world image that arrives as a Foundry path — the bridge's snapshot and older
// modules send those, where the module sends absolute URLs — was read against Dragonroll's
// uploads folder, where nothing of that name is, so nothing loaded.
//
// The mapper is plain CommonJS and is required for real. The writers run in a stubbed
// `require` against fake models, like tests/foundry-force-import.test.js runs them. And
// since the campaign's inventory no longer claims trait and species documents, the module
// must stop deleting ones earlier syncs marked as its own: the Foundry module goes into a
// `node:vm` context holding stubbed Foundry globals with fake timers, like
// tests/foundry-actor-details.test.js, so what writing a character leaves behind is observable.
//
// 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 read = (...parts) => fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
const repoRequire = (relative) => require(path.join(__dirname, "..", relative));
const MODULE_ID = "dragonroll-foundry";
// --- What the world's mapper keeps where -------------------------------------------------
const { foundryActorToCharacter } = require(path.join(__dirname, "..", "backend", "src", "services", "actor-foundry.js"));
test("traits and species stand in their own fields, not among the carried items", () => {
const character = foundryActorToCharacter({
name: "Thalia",
system: { details: {} },
items: [
{ name: "Longsword", type: "weapon", img: "http://vtt.test/icons/sword.svg", system: { quantity: 1, weight: { value: 3 } } },
{ name: "Rope", type: "equipment", system: { quantity: 2 } },
{ name: "Darkvision", type: "feat", system: { featType: "trs", description: { value: "<p>See in the dark.</p>" } } },
{ name: "Human", type: "race" },
{ name: "Spellbook", type: "spellbook" },
{ name: "Magic Missile", type: "spell" },
{ name: "Fighter", type: "class" },
{ name: "Oracle", type: "subclass" },
{ name: "Soldier", type: "background" },
],
});
assert.deepEqual(character.inventory.map((item) => item.name), ["Longsword", "Rope"],
"the inventory holds what the character carries, and nothing else");
assert.deepEqual(character.inventory[0],
{ name: "Longsword", quantity: 1, weight: 3, icon: "http://vtt.test/icons/sword.svg" });
assert.equal(character.traits, "Darkvision\nSee in the dark.", "the feat is read as a trait, where the sheet shows it");
assert.equal(character.spells, "Magic Missile", "and the spell where its tab shows it");
});
test("gear of a type the mapper has never seen is still carried", () => {
const character = foundryActorToCharacter({
name: "Thalia",
items: [{ name: "Strange Relic", type: "loot", system: { quantity: 1 } }],
});
assert.deepEqual(character.inventory.map((item) => item.name), ["Strange Relic"],
"only the listed non-gear types are let out of the inventory");
});
// --- The writers read a world's paths off the world's address ----------------------------
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 writers use: equality and $or.
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;
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) {
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)));
return model;
}
// The sync writers against fake models. `settings` is what the campaign keeps — the world
// address the icons are loaded from stands in it, as it does in the real one.
function loadFoundryWriters({ seed = {}, settings } = {}) {
const campaign = { _id: "campaign-1", id: "campaign-1", foundryWorldId: "world-1", ...(settings ? { settings } : {}) };
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/Map": fakeModel("map", seeded(seed.maps)),
};
const requireStub = (id) => {
if (id === "express") return { Router: () => ({ get: () => {}, post: () => {} }) };
if (id.startsWith("node:")) return require(id);
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 repoRequire(path.join("backend", "src", "services", "actor-foundry.js"));
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (id === "../services/map-foundry") return repoRequire(path.join("backend", "src", "services", "map-foundry.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
);
return { campaign, models, writers: moduleStub.exports };
}
test("a world image that arrives as a path is stored as the address the sheet can load", async () => {
const sync = loadFoundryWriters({ settings: { integrations: { foundryUrl: "http://vtt.test:30000/" } } });
await sync.writers.saveFoundryActor(sync.campaign, {
_id: "actor-1",
name: "Thalia",
type: "character",
img: "icons/actors/thalia.svg",
items: [
{ name: "Torch", type: "loot", img: "icons/tools/torch torch.svg", system: { quantity: 2 } },
{ name: "Darkvision", type: "feat", img: "icons/svg/eye.svg" },
],
});
const actor = sync.models["../models/Actor"].rows[0];
assert.equal(actor.image, "http://vtt.test:30000/icons/actors/thalia.svg", "the portrait is read off the world's address");
assert.deepEqual(actor.inventory.map((item) => item.name), ["Torch"], "the feat is not carried into the inventory");
assert.equal(actor.inventory[0].icon, "http://vtt.test:30000/icons/tools/torch%20torch.svg", "and the gear's icon is");
});
test("the absolute addresses the module sends travel as they are", async () => {
const sync = loadFoundryWriters({ settings: { integrations: { foundryUrl: "http://vtt.test:30000" } } });
await sync.writers.saveFoundryActor(sync.campaign, {
_id: "actor-1",
name: "Thalia",
img: "http://elsewhere.test/portraits/thalia.png",
items: [{ name: "Torch", type: "loot", img: "data:image/png;base64,TgA=" }],
});
const actor = sync.models["../models/Actor"].rows[0];
assert.equal(actor.image, "http://elsewhere.test/portraits/thalia.png");
assert.equal(actor.inventory[0].icon, "data:image/png;base64,TgA=");
});
test("a campaign with no world address keeps the path as it came", async () => {
const sync = loadFoundryWriters();
await sync.writers.saveFoundryActor(sync.campaign, {
_id: "actor-1", name: "Thalia", img: "icons/actors/thalia.svg",
});
assert.equal(sync.models["../models/Actor"].rows[0].image, "icons/actors/thalia.svg",
"with no world to read it against, nothing is invented for it");
});
test("a world item's icon is read off the world's address the same way", async () => {
const sync = loadFoundryWriters({ settings: { integrations: { foundryUrl: "http://vtt.test:30000" } } });
await sync.writers.saveFoundryItem(sync.campaign, {
_id: "item-1", name: "Longsword", type: "weapon", img: "icons/equipment/sword.svg",
});
const item = sync.models["../models/Item"].rows[0];
assert.equal(item.image, "http://vtt.test:30000/icons/equipment/sword.svg");
assert.equal(item.foundryImage, "http://vtt.test:30000/icons/equipment/sword.svg",
"the icon the item window offers back is the loadable one too");
});
// --- The module leaves the world's own documents alone ------------------------------------
function makeStubItem(id, { name, type, system = {}, flags = {} }) {
return {
_id: id,
id,
name,
type,
system,
flags,
parent: { documentName: "Actor" },
getFlag(module, key) { return this.flags?.[module]?.[key]; },
toObject() {
return { _id: this.id, name: this.name, type: this.type, system: this.system, flags: this.flags };
},
};
}
function writeDotted(target, data) {
for (const [key, value] of Object.entries(data)) {
const parts = key.split(".");
const last = parts.pop();
let node = target;
for (const part of parts) node = node[part] ??= {};
node[last] = value;
}
}
let stubCounter = 0;
function makeStubActor(name, { type = "character", system = {}, flags = {}, items = [] } = {}) {
stubCounter += 1;
const id = `actor-${stubCounter}`;
const contents = items.map((item, index) => makeStubItem(item._id || `embedded-${stubCounter}-${index}`, item));
const actor = {
id,
name,
type,
documentName: "Actor",
img: "icons/svg/mystery-man.svg",
system,
flags,
items: { contents },
getFlag(module, key) { return this.flags?.[module]?.[key]; },
async update(data) {
writeDotted(this, data);
return this;
},
async updateEmbeddedDocuments(documentName, updates) {
for (const update of updates) {
const item = contents.find((candidate) => candidate.id === update._id);
if (item) writeDotted(item, update);
}
return updates.map((update) => contents.find((candidate) => candidate.id === update._id));
},
async createEmbeddedDocuments(documentName, datas) {
const created = datas.map((data) => {
const item = makeStubItem(`embedded-${stubCounter}-${contents.length}`, data);
contents.push(item);
return item;
});
return created;
},
async deleteEmbeddedDocuments(documentName, ids) {
for (const id of ids) {
const index = contents.findIndex((item) => item.id === id);
if (index >= 0) contents.splice(index, 1);
}
return ids;
},
toObject() {
return {
_id: this.id,
name: this.name,
type: this.type,
img: this.img,
flags: this.flags,
system: this.system,
};
},
};
return actor;
}
function makeWorld({ actors = [], remoteActors = [] } = {}) {
const state = {
hooks: new Map(),
registered: new Map(),
requests: [],
timers: new Map(),
nextTimerId: 1,
logs: [],
};
const settingsStore = { autoSync: true, syncToken: "sync-token-1", dragonrollApiUrl: "http://backend.test:5000" };
const sandbox = {
console: {
log() {},
info() {},
warn: (...args) => state.logs.push(args.map(String).join(" ")),
error: (...args) => state.logs.push(args.map(String).join(" ")),
},
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 timerId = state.nextTimerId++;
state.timers.set(timerId, { fn, delay });
return timerId;
},
clearTimeout: (timerId) => state.timers.delete(timerId),
setInterval: () => 0,
clearInterval: () => {},
fetch: async (url, options = {}) => {
const href = String(url);
state.requests.push({ href, method: options.method, body: options.body ? JSON.parse(options.body) : null });
if (href.includes("foundry/sync/characters")) return { ok: true, status: 200, json: async () => ({ status: "ok", actors: remoteActors }) };
if (href.includes("foundry/sync/items")) return { ok: true, status: 200, json: async () => ({ status: "ok", items: [] }) };
return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [] }) };
},
Item: { async create() { return null; } },
Actor: {
async create(data) {
const actor = makeStubActor(data.name, {
type: data.type,
system: structuredClone(data.system || {}),
flags: structuredClone(data.flags || {}),
items: (data.items || []).map((item) => ({ name: item.name, type: item.type, system: item.system })),
});
actors.push(actor);
return actor;
},
},
};
sandbox.game = {
user: { isGM: true },
world: { id: "world-1", title: "Test World" },
system: { id: "dnd5e" },
modules: { get: () => ({}) },
actors: { contents: actors, get: (actorId) => actors.find((actor) => actor.id === actorId) },
items: { contents: [], get: () => null },
folders: { contents: [], get: () => null },
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;
const drain = async () => { await new Promise((resolve) => setImmediate(resolve)); };
// World start: the actors are pushed, then the campaign's characters are applied.
state.start = async () => {
await state.fire("init");
await state.fire("ready");
await state.runTimers();
return state;
};
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();
}
};
state.itemNames = (actor) => actor.items.contents.map((item) => [item.type, item.name]);
state.actorPushes = () => state.requests
.filter((request) => request.href.includes("foundry/sync/snapshot"))
.map((request) => request.body.actors[0]);
return state;
}
// The campaign's character for `actor`, holding what Dragonroll keeps for it.
function campaignCharacter(actor, over = {}) {
return {
_id: "dr-actor-1",
name: "Thalia",
type: "character",
species: "",
className: "",
subclass: "",
level: 1,
background: "",
challengeRating: "",
description: "",
image: "",
abilityScores: {},
armorClass: 10,
speed: 30,
traits: "",
proficiencies: "",
spells: "",
inventory: [],
foundryActorId: actor?.id ?? null,
...over,
};
}
test("a trait row an older campaign left in the inventory does not become a loot duplicate", async () => {
// A campaign that synced before #89 still carries its world's traits as inventory
// rows. Writing the character must neither make a piece of loot after a trait's name
// nor touch the world's feat it holds that name — the row is the campaign's to write
// off, and the document is the world's to keep.
const actor = makeStubActor("Thalia", {
system: { details: {} },
flags: { [MODULE_ID]: { actorId: "dr-actor-1" } },
items: [{ _id: "feat-1", name: "Darkvision", type: "feat", system: { featType: "trs" } }],
});
const world = await makeWorld({
actors: [actor],
remoteActors: [campaignCharacter(actor, {
traits: "Darkvision\nSee in the dark.",
inventory: [{ name: "Darkvision", quantity: 1, weight: 0 }],
})],
}).start();
assert.deepEqual(world.itemNames(actor), [["feat", "Darkvision"]],
"no gear made after the trait's name, and the feat stands where it was");
assert.equal(actor.items.contents[0].system.quantity, undefined, "the world's feat is not written as gear");
assert.deepEqual(world.logs, [], "applying the character did not warn");
});
test("writing the character leaves the world's trait and species documents where they stand", async () => {
// An earlier sync marked everything in the actor as its own. The campaign no longer
// carries traits and species in the inventory, so those marks must not cost the world
// its documents — while loot the campaign truly dropped still goes.
const actor = makeStubActor("Thalia", {
system: { details: {} },
flags: { [MODULE_ID]: { actorId: "dr-actor-1" } },
items: [
{ _id: "feat-1", name: "Darkvision", type: "feat", flags: { [MODULE_ID]: { syncedItem: true } } },
{ _id: "race-1", name: "Human", type: "race", flags: { [MODULE_ID]: { syncedItem: true } } },
{ _id: "loot-old", name: "Torch", type: "loot", flags: { [MODULE_ID]: { syncedItem: true } } },
],
});
const world = await makeWorld({
actors: [actor],
remoteActors: [campaignCharacter(actor, {
species: "Human",
traits: "Darkvision\nSee in the dark.",
inventory: [{ name: "Rations", quantity: 1, weight: 0.5 }],
})],
}).start();
assert.deepEqual(world.itemNames(actor), [
["feat", "Darkvision"],
["race", "Human"],
["loot", "Rations"],
], "the trait and the species survive, the carried gear follows the campaign");
assert.equal(actor.system.details.race, "race-1", "the species reference still resolves to the surviving item");
assert.deepEqual(world.logs, [], "applying the character did not warn");
});
test("the snapshot marks the carried gear and no longer the world's own documents", async () => {
const actor = makeStubActor("Grimnir", {
system: { details: {} },
items: [
{ name: "Longsword", type: "weapon" },
{ name: "Darkvision", type: "feat" },
{ name: "Giant", type: "race" },
],
});
await makeWorld({ actors: [actor], remoteActors: [] }).start();
const [sword, feat, race] = actor.items.contents;
assert.equal(sword.getFlag(MODULE_ID, "syncedItem"), true, "the gear the campaign carries is marked as its own");
assert.equal(feat.getFlag(MODULE_ID, "syncedItem"), undefined, "a trait is not");
assert.equal(race.getFlag(MODULE_ID, "syncedItem"), undefined, "neither is a species");
});
test("an actor snapshot still sends the feats its traits are made of", async () => {
// Leaving feats out of the inventory must not leave them out of the snapshot: they are
// what the campaign's traits tab reads.
const actor = makeStubActor("Thalia", {
system: { details: {} },
items: [{ name: "Darkvision", type: "feat", system: { featType: "trs" } }],
});
const world = await makeWorld({ actors: [actor], remoteActors: [] }).start();
const sent = world.actorPushes().at(-1);
assert.deepEqual(sent.items.map((item) => [item.type, item.name]), [["feat", "Darkvision"]],
"the feat still travels with its actor, as the traits text is read off it");
});

View File

@@ -3,8 +3,10 @@
// numbered group, translations for the group's label, and no link pointing at a page that does not // numbered group, translations for the group's label, and no link pointing at a page that does not
// exist, (2) the page about an integration really documents what that integration offers, which is // exist, (2) the page about an integration really documents what that integration offers, which is
// checked against the sources that define it: the slash commands of discord-bot/src/commands.js and // checked against the sources that define it: the slash commands of discord-bot/src/commands.js and
// the commands the Obsidian plugin registers, and (3) the routes: /docs and /docs/<slug> render the // the commands the Obsidian plugin registers, (3) the routes: /docs and /docs/<slug> render the
// documentation and every other address still opens the window app. // documentation and every other address still opens the window app, and (4) inside a campaign the
// same documentation opens as a window of its own instead of a trip to /docs
// (Syndria98/dragonroll#95).
// //
// `frontend/app/services/DocsMarkdown.js` is the pure part of the docs (headings, slugs, titles) and // `frontend/app/services/DocsMarkdown.js` is the pure part of the docs (headings, slugs, titles) and
// is loaded straight from source, the way the other tests load the frontend services; it imports // is loaded straight from source, the way the other tests load the frontend services; it imports
@@ -326,3 +328,237 @@ test("the main menu points at the documentation", () => {
assert.ok(strings.documentation, `${locale} has no label for the documentation link`); assert.ok(strings.documentation, `${locale} has no label for the documentation link`);
} }
}); });
// Inside a campaign the documentation is reached from the top bar, on the left of the campaign
// settings button (Syndria98/dragonroll#90), and it opens as a window of its own in front of the
// workspace rather than as a trip to /docs (Syndria98/dragonroll#95).
test("the campaign top bar opens the documentation as a window", () => {
const topBar = readRepoFile("frontend", "app", "components", "viewer", "TopBar.vue");
const right = /<div class="right">([\s\S]*?)<\/div>/.exec(topBar)?.[1];
assert.ok(right, "expected the top bar to have its buttons in a right-hand group");
assert.match(right, /OpenDocumentation/, "the top bar has a button for the documentation");
assert.match(right, /main-menu\.documentation/, "under the same label the main menu uses");
assert.match(topBar, /CreateWindow\('documentation'\)/, "the button opens the documentation window");
// To the left of the settings button: the group is read left to right, so the button has to
// come first in it.
const docsAt = right.indexOf("OpenDocumentation");
const settingsAt = right.indexOf("OpenCampaignSettings");
assert.ok(
docsAt !== -1 && settingsAt !== -1 && docsAt < settingsAt,
"the documentation button sits on the left of the settings button"
);
// The open notes of the campaign live only in memory, so nothing the top bar does may leave
// the app: a window comes to the front, an address would take the campaign away with it.
assert.doesNotMatch(topBar, /href="\/docs"/, "the top bar does not send the campaign to /docs");
assert.doesNotMatch(topBar, /target="_blank"/, "…nor opens a tab out of it");
});
// The window the button opens (Syndria98/dragonroll#95): registered like every other window, and
// reading its pages without ever leaving the window it is drawn in.
test("the documentation is registered as a window", () => {
const definitions = readRepoFile("frontend", "app", "services", "WindowDefinitions.js");
const definition = /\n\s*documentation:\s*\{([\s\S]*?)\n\s{2}\}/.exec(definitions);
assert.ok(definition, "the documentation is not registered as a window");
assert.match(definition[1], /title:\s*'windows\.documentation'/, "its title is an i18n key");
assert.match(definition[1], /movable:\s*true/);
assert.match(definition[1], /close:\s*\(\)\s*=>\s*ClearWindow\(\{\s*type:\s*'documentation'\s*\}\)/);
const component = /component:\s*\(\)\s*=>\s*import\(['"]~\/components\/windows\/([^'"]+)['"]\)/.exec(definition[1]);
assert.ok(component, "the documentation window names no component of its own");
assert.ok(
fs.existsSync(path.join(__dirname, "..", "frontend", "app", "components", "windows", component[1])),
`the documentation window points at a component that does not exist: ${component[1]}`
);
});
test("the documentation window reads the published pages without leaving itself", () => {
const source = readRepoFile("frontend", "app", "components", "windows", "DocumentationWindow.vue");
// The pages are the ones of app/content/docs, read through the same service the /docs page uses.
assert.match(source, /from '~\/services\/Docs'/, "the window reads the documentation through the docs service");
for (const lookup of ["GetDocsNav", "GetDocsPage", "GetDocsFirstSlug"]) {
assert.match(source, new RegExp(lookup), `the window does not use ${lookup}`);
}
// Resizable, with a floor low enough to read the two columns on a small screen.
assert.match(source, /SetResizable\(id,\s*true\)/, "the window is resizable");
assert.match(source, /SetMinSize\(id,\s*\{\s*width:\s*\d+,\s*height:\s*\d+\s*\}\)/, "…and it says how small it goes");
// Nothing in it is a route: the window holds the page it shows, so following the sidebar
// leaves the campaign behind it exactly as it was.
assert.doesNotMatch(source, /NuxtLink|useRoute|navigateTo/, "the documentation window does not navigate the app");
// Which means the links the markdown carries (`[Foundry](/docs/foundry)`) and the sections of
// a page have to be answered inside the window.
assert.match(source, /\\\/docs/, "the markdown's links to the other pages are followed in the window");
assert.match(source, /scrollIntoView/, "so are the sections of the page it is showing");
assert.match(source, /preventDefault/, "…and none of them reaches the app's address");
// A window is not a page: the reading column is what scrolls, nothing is as tall as the viewport.
const reading = /\.docs-reading\s*\{[^}]*\}/.exec(source)?.[0];
assert.ok(reading, "the window has a reading column of its own");
assert.match(reading, /overflow-y:\s*auto/, "…and that is what scrolls");
assert.doesNotMatch(source, /100vh/, "a window fills itself, not the viewport");
});
test("the documentation window is titled in every locale", () => {
for (const locale of ["en", "es", "ca"]) {
const strings = JSON.parse(readRepoFile("frontend", "i18n", "locales", locale, "windows.json"));
const title = strings.documentation;
assert.ok(title, `${locale} has no title for the documentation window`);
if (locale !== "en") {
assert.notEqual(title.toLowerCase(), "documentation", `the ${locale} window title is untranslated`);
}
}
});
// --- How the documentation is laid out (Syndria98/dragonroll#85) ---
// The `<style>` of DocsView.vue read as `{ selector, media, declarations }` rules: the block is
// flat — every rule is a top level selector and the only nesting is the media queries — so pairing
// braces is enough, and the test does not need a stylesheet parser the repository root lacks.
function DocsStyleRules() {
const source = readRepoFile("frontend", "app", "components", "views", "DocsView.vue");
const css = source
.slice(source.indexOf(">", source.indexOf("<style")) + 1, source.indexOf("</style>"))
.replace(/\/\*[\s\S]*?\*\//g, "");
const rules = [];
function scan(text, media) {
let index = 0;
for (;;) {
const brace = text.indexOf("{", index);
if (brace === -1) return rules;
const selector = text.slice(index, brace).trim();
let depth = 1;
let cursor = brace + 1;
while (cursor < text.length && depth > 0) {
if (text[cursor] === "{") depth += 1;
else if (text[cursor] === "}") depth -= 1;
cursor += 1;
}
const body = text.slice(brace + 1, cursor - 1);
if (selector.startsWith("@")) scan(body, selector);
else rules.push({ selector, media, declarations: body });
index = cursor;
}
}
return scan(css, null);
}
const styleRules = DocsStyleRules();
// The rules that name a class, with `media` null for the plain ones and "min-width" / "max-width"
// for the ones a media query switches on. The last one wins where they overlap, as in a stylesheet.
function RulesFor(className, media = null) {
return styleRules.filter((rule) =>
rule.selector.split(",").some((name) => name.trim() === className) &&
(media === null ? rule.media === null : Boolean(rule.media) && rule.media.includes(media))
);
}
// A `padding:` shorthand spread over its four sides, the way the browser reads it.
function PaddingOf(rule) {
const shorthand = rule.declarations.match(/(?:^|[;\s])padding:\s*([^;]+)/);
assert.ok(shorthand, `the ${rule.selector} rule sets no padding to compare`);
const values = shorthand[1].trim().split(/\s+/).map((value) => parseFloat(value));
assert.ok(
values.length <= 4 && values.every((value) => Number.isFinite(value)),
`only px padding is compared here, ${rule.selector} has "${shorthand[1].trim()}"`
);
return {
top: values[0],
right: values[1] ?? values[0],
bottom: values[2] ?? values[0],
left: values[3] ?? values[1] ?? values[0],
};
}
test("the two asides are as tall as the page they stand beside", () => {
for (const className of [".docs-sidebar", ".docs-sections"]) {
const aside = RulesFor(className).find((rule) => /position:\s*sticky/.test(rule.declarations));
assert.ok(aside, `${className} has to stay beside the text while the page scrolls`);
assert.match(aside.declarations, /height:\s*100vh/, `${className} has to fill the page, not just its own contents`);
assert.doesNotMatch(aside.declarations, /max-height/, `${className} is capped at a screen height by 'height'`);
}
});
test("a narrow window stacks the columns and lets each one be its own height", () => {
const stacked = RulesFor(".docs-sidebar", "max-width");
assert.equal(stacked.length, 1, "the stacked layout is set by one rule");
assert.match(stacked[0].declarations, /position:\s*static/, "a stacked sidebar does not follow the scroll");
assert.match(stacked[0].declarations, /height:\s*auto/, "…and it is not held at a screen height either");
});
test("the reading column is centred in the space left beside the sidebar", () => {
const reading = RulesFor(".docs-article").find((rule) => /max-width:/.test(rule.declarations));
assert.ok(reading, "the text has to be capped in width to be readable");
assert.match(reading.declarations, /margin-inline:\s*auto/, "…and centred in the space left beside the sidebar");
assert.match(reading.selector, /\.docs-pager/, "the pager under the text follows the same column");
});
test("a very wide window keeps the sections next to the text, not at the edge of the screen", () => {
const centred = RulesFor(".docs", "min-width");
assert.equal(centred.length, 1, "one wide window rule centres the documentation");
assert.match(centred[0].declarations, /justify-content:\s*center/);
const wider = Number(centred[0].media.match(/min-width:\s*(\d+)/)[1]);
assert.ok(wider >= 1400, `${wider}px is not a wide window: the layout breaks before that`);
const main = RulesFor(".docs-main", "min-width");
assert.equal(main.length, 1, "the main column is capped once the window is wide");
assert.match(main[0].declarations, /flex:\s*0 1 \d+px/, "…so it stops growing and the sections sit next to it");
});
test("the sections aside has more room around its links than the sidebar has", () => {
const shared = RulesFor(".docs-sidebar").find((rule) => /padding:/.test(rule.declarations));
const sections = RulesFor(".docs-sections").filter((rule) => /padding:/.test(rule.declarations)).pop();
assert.ok(sections && sections !== shared, "the sections aside sets its own padding");
const room = PaddingOf(sections);
const sidebar = PaddingOf(shared);
for (const side of ["top", "right", "bottom", "left"]) {
assert.ok(room[side] >= sidebar[side], `the sections aside is tighter than the sidebar on the ${side}`);
}
assert.ok(
["top", "right", "bottom", "left"].some((side) => room[side] > sidebar[side]),
"the sections aside asks for more padding than the two asides share"
);
});
// The /docs page and the documentation window render the very same HTML, so the markdown it renders
// is styled once, in the stylesheet both of them load, rather than in whichever one asked for it
// first (Syndria98/dragonroll#95).
test("the rendered markdown is styled once, where both readers reach it", () => {
const styles = readRepoFile("frontend", "app", "assets", "css", "main.scss");
const markdown = styles.slice(styles.indexOf(".docs-markdown h1"));
for (const selector of [
".docs-markdown h1",
".docs-markdown h2",
".docs-markdown h3",
".docs-markdown p",
".docs-markdown a",
".docs-markdown code",
".docs-markdown pre",
".docs-markdown table",
]) {
assert.ok(markdown.includes(selector), `${selector} has to be styled for both readers of the docs`);
}
// Theme colours, as everywhere: the window and the page are read on either theme.
for (const colour of ["var\\(--color-border\\)", "var\\(--color-link\\)", "var\\(--color-background-light\\)"]) {
assert.match(markdown, new RegExp(colour), "the markdown's look uses the theme's colours");
}
});

View File

@@ -271,6 +271,7 @@ function loadFoundryWriters({ seed = {} } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)), "../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)), "../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)), "../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Map": fakeModel("map", seeded(seed.maps)),
}; };
const requireStub = (id) => { const requireStub = (id) => {
@@ -280,6 +281,8 @@ function loadFoundryWriters({ seed = {} } = {}) {
if (id === "../models/Campaign") return { findOne: async () => campaign }; if (id === "../models/Campaign") return { findOne: async () => campaign };
if (id === "../services/actor-foundry") return repoRequire(path.join("backend", "src", "services", "actor-foundry.js")); if (id === "../services/actor-foundry") return repoRequire(path.join("backend", "src", "services", "actor-foundry.js"));
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js")); if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (id === "../services/map-foundry") return repoRequire(path.join("backend", "src", "services", "map-foundry.js"));
if (models[id]) return models[id]; if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`); throw new Error(`require("${id}") is not stubbed`);
}; };

View File

@@ -132,6 +132,7 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
"../models/Actor": fakeModel("actor", seeded(seed.actors)), "../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seeded(seed.items)), "../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seeded(seed.folders)), "../models/Folder": fakeModel("folder", seeded(seed.folders)),
"../models/Map": fakeModel("map", seeded(seed.maps)),
}; };
const requireStub = (id) => { const requireStub = (id) => {
@@ -141,6 +142,8 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
if (id === "../models/Campaign") return { findOne: async () => campaign }; if (id === "../models/Campaign") return { findOne: async () => campaign };
if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) }; if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) };
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js")); if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (id === "../services/map-foundry") return repoRequire(path.join("backend", "src", "services", "map-foundry.js"));
if (models[id]) return models[id]; if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`); throw new Error(`require("${id}") is not stubbed`);
}; };

View File

@@ -0,0 +1,598 @@
// Tests for the world's scenes arriving as the campaign's maps (Syndria98/dragonroll#99).
// Only a scene's background picture and the grid laid over it travel: the campaign keeps its
// own scale, its folders, its pinned notes and the tokens standing on the map, and none of it
// goes back to the world.
//
// Same set-up as tests/item-folder-sync.test.js, which the repository root runs without
// installing anything: the sync route is loaded into `node:vm` with express, mongoose and its
// models stubbed (plain rows and a small filter matcher), so creating, adopting and pruning
// maps is observable without a database. The Foundry module is loaded into a `node:vm` context
// holding stubbed Foundry globals (`game.scenes` included) with fake timers, like
// tests/foundry-sync-toggle.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 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 scene sync uses: equality, $in, $nin, $exists.
// Anything else is a filter this test did not expect and says so.
function matches(document, filter = {}) {
return Object.entries(filter).every(([key, expected]) => {
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));
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;
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 sync scopes every lookup by campaign.
const row = new Document({ campaign: campaignId, name: undefined, ...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 };
};
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", settings } = {}) {
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,
...(settings ? { settings } : {}),
};
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/Map": fakeModel("map", seeded(seed.maps)),
};
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 { foundryItemToItemData: () => null };
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (id === "../services/map-foundry") return repoRequire(path.join("backend", "src", "services", "map-foundry.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 };
}
// A scene of the world, as the module sends it: plain document data with its picture read
// from the world. This one is 70 px cells and the picture of the ruined keep.
function worldScene(over = {}) {
return {
_id: "scene-1",
name: "The Ruined Keep",
img: "http://vtt.test/images/keep.webp",
grid: 70,
flags: {},
...over,
};
}
const maps = (sync) => sync.models["../models/Map"].rows;
// --- A scene arrives as a map -------------------------------------------------------
test("a world scene arrives as a map of the campaign", async () => {
const sync = loadSyncRoute();
const response = await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()] });
assert.equal(response.status, "ok");
const [map] = maps(sync);
assert.equal(map.name, "The Ruined Keep");
assert.equal(map.image, "http://vtt.test/images/keep.webp", "the scene's background picture is the map's");
assert.equal(map.gridSize, 70, "the scene's own cell size is the grid the campaign draws");
assert.equal(map.offsetX, 0);
assert.equal(map.offsetY, 0, "a scene that shifts nothing has its grid at the corner of the picture");
assert.equal(map.foundrySceneId, "scene-1");
assert.equal(map.campaign, sync.campaign._id, "the map belongs to the campaign the world is linked to");
assert.deepEqual(response.maps, [{ foundrySceneId: "scene-1", mapId: map._id, created: true }]);
});
test("a scene keeps the grid its world shifted onto the picture", async () => {
const sync = loadSyncRoute();
await sync.call("POST /sync/scenes", {
worldId: "world-1",
scenes: [worldScene({ grid: 64, flags: { core: { shiftX: 12, shiftY: -8 } } })],
});
const [map] = maps(sync);
assert.equal(map.gridSize, 64);
assert.equal(map.offsetX, 12);
assert.equal(map.offsetY, -8, "a grid that starts off the corner of the picture arrives where the world puts it");
});
test("a scene of a newer Foundry still arrives", async () => {
const sync = loadSyncRoute();
// Since Foundry V13 the picture sits under `background.src` and the cell size under
// `grid.size`.
await sync.call("POST /sync/scenes", {
worldId: "world-1",
scenes: [worldScene({ img: undefined, background: { src: "http://vtt.test/images/keep.webp" }, grid: { size: 128 } })],
});
const [map] = maps(sync);
assert.equal(map.image, "http://vtt.test/images/keep.webp");
assert.equal(map.gridSize, 128);
});
test("a scene's picture is read against the world the campaign knows", async () => {
// An older module sends Foundry's own relative path; it is read against the world's
// address, the way an actor's portrait is (Syndria98/dragonroll#89).
const sync = loadSyncRoute({ settings: { integrations: { foundryUrl: "http://vtt.test:30000" } } });
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene({ img: "images/keep.webp" })] });
assert.equal(maps(sync)[0].image, "http://vtt.test:30000/images/keep.webp");
});
test("a scene with no picture is not a map", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-1", name: "The Ruined Keep", foundrySceneId: "scene-1", image: "http://vtt.test/images/keep.webp" }] },
});
// The GM took the picture off the scene: its id still travels with the snapshot, so its
// map is neither made blank nor dropped, and no new row is made for it either.
const response = await sync.call("POST /sync/scenes", {
worldId: "world-1",
scenes: [worldScene({ img: "" })],
fullSync: true,
});
assert.deepEqual(response.maps, []);
assert.equal(maps(sync).length, 1);
assert.equal(maps(sync)[0].image, "http://vtt.test/images/keep.webp");
});
test("what one of the map's cells stands for stays the campaign's", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-1", name: "The Ruined Keep", foundrySceneId: "scene-1", gridSize: 50, scale: 1.5 }] },
});
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene({ gridDistance: 1500, gridUnits: "m" })] });
assert.equal(maps(sync)[0].gridSize, 70, "the world's cell size arrives");
assert.equal(maps(sync)[0].scale, 1.5, "and the distance the campaign says a cell covers is left alone");
});
// --- One map per scene ---------------------------------------------------------------
test("the same scene is never made into two maps", async () => {
const sync = loadSyncRoute();
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()] });
const response = await sync.call("POST /sync/scenes", {
worldId: "world-1",
scenes: [worldScene({ name: "The Ruined Keep, II", grid: 80 })],
});
assert.equal(maps(sync).length, 1, "the scene was written over, not doubled");
assert.equal(maps(sync)[0].name, "The Ruined Keep, II");
assert.equal(maps(sync)[0].gridSize, 80);
assert.equal(response.maps[0].created, false, "the push says it wrote a map it already had");
});
test("a live scene edit lands on the map, however the campaign had it", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-1", name: "Old name", foundrySceneId: "scene-1", image: "old.png", gridSize: 40 }] },
});
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()] });
const [map] = maps(sync);
assert.equal(map.image, "http://vtt.test/images/keep.webp");
assert.equal(map.gridSize, 70);
assert.equal(map.name, "The Ruined Keep");
});
test("a full snapshot leaves the picture and grid the campaign lined up alone", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-1", name: "My keep", foundrySceneId: "scene-1", image: "my-keep.png", gridSize: 40 }] },
});
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()], fullSync: true });
const [map] = maps(sync);
assert.equal(map.image, "my-keep.png", "a GM reconnecting does not write over a map the campaign already had");
assert.equal(map.gridSize, 40);
assert.equal(map.name, "My keep");
});
test("a scene takes over the map the campaign drew by hand", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-1", name: "The Ruined Keep", image: "hand-made.png", gridSize: 50 }] },
});
const response = await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()] });
assert.equal(maps(sync).length, 1, "the room the campaign drew first is not doubled by its scene");
assert.equal(maps(sync)[0]._id, "map-1");
assert.equal(maps(sync)[0].foundrySceneId, "scene-1", "and it is the scene's map from then on");
assert.equal(response.maps[0].mapId, "map-1");
});
test("a scene carrying the campaign's map id adopts that row", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-0123456789abcdef0123456789", name: "Keep under way", image: "hand-made.png" }] },
});
const response = await sync.call("POST /sync/scenes", {
worldId: "world-1",
scenes: [worldScene({ name: "Somewhere else", flags: { "dragonroll-foundry": { mapId: "map-0123456789abcdef0123456789" } } })],
});
assert.equal(maps(sync).length, 1);
assert.equal(response.maps[0].mapId, "map-0123456789abcdef0123456789", "the flag says which map the scene is");
});
// --- Pruning --------------------------------------------------------------------------
test("a full snapshot prunes the maps whose scene this world let go of", async () => {
const sync = loadSyncRoute({
seed: {
maps: [
{ _id: "map-1", name: "Cellar", foundrySceneId: "scene-gone" },
{ _id: "map-2", name: "Homebrew ford" },
{ _id: "map-3", name: "The Ruined Keep", foundrySceneId: "scene-1" },
],
},
});
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()], fullSync: true });
assert.deepEqual(maps(sync).map((map) => map._id).sort(), ["map-2", "map-3"],
"the scene that is gone takes its map with it, and the campaign's own maps stay");
});
test("a live scene push never prunes", async () => {
const sync = loadSyncRoute({
seed: { maps: [{ _id: "map-1", name: "Cellar", foundrySceneId: "scene-gone" }] },
});
await sync.call("POST /sync/scenes", { worldId: "world-1", scenes: [worldScene()] });
assert.equal(maps(sync).length, 2, "a push of one scene says nothing about the world's other scenes");
});
test("a scene the world deleted takes its map with it", async () => {
const sync = loadSyncRoute({
seed: {
maps: [
{ _id: "map-1", name: "The Ruined Keep", foundrySceneId: "scene-1" },
{ _id: "map-2", name: "Homebrew ford" },
],
},
});
const response = await sync.call("POST /sync/scene-delete", { worldId: "world-1", foundrySceneId: "scene-1" });
assert.equal(response.status, "ok");
assert.deepEqual(maps(sync).map((map) => map._id), ["map-2"], "only the map of that scene goes");
});
// --- What the route refuses -----------------------------------------------------------
test("a push that is not the campaign's world, or names no scenes, is refused", async () => {
const sync = loadSyncRoute();
assert.equal((await sync.call("POST /sync/scenes", { worldId: "another-world", scenes: [worldScene()] })).msg, "errors.missing-data");
assert.equal((await sync.call("POST /sync/scenes", { worldId: "world-1" })).msg, "errors.missing-data");
assert.deepEqual(maps(sync), [], "nothing was written");
});
test("a delete from another world, or naming no scene, is refused", async () => {
const sync = loadSyncRoute({ seed: { maps: [{ _id: "map-1", name: "Keep", foundrySceneId: "scene-1" }] } });
assert.equal((await sync.call("POST /sync/scene-delete", { worldId: "another-world", foundrySceneId: "scene-1" })).msg, "errors.missing-data");
assert.equal((await sync.call("POST /sync/scene-delete", { worldId: "world-1" })).msg, "errors.missing-data");
assert.equal(maps(sync).length, 1, "and the map is still there");
});
test("a map remembers which scene of the world it mirrors", () => {
const model = read("backend", "src", "models", "Map.js");
assert.match(model, /foundrySceneId:\s*{\s*type:\s*String\s*}/, "the scene a map mirrors is kept on the map");
assert.match(model, /\{\s*campaign:\s*1,\s*foundrySceneId:\s*1\s*\}/, "and is unique within the campaign");
});
// --- The Foundry module sends its scenes ---------------------------------------------
const MODULE_ID = "dragonroll-foundry";
function makeWorld({ autoSync = true } = {}) {
const state = {
hooks: new Map(),
registered: new Map(),
requests: [],
timers: new Map(),
intervals: new Map(),
nextTimerId: 1,
};
// A Scene document: the plain data `toObject()` answers with, which since V13 carries
// the picture under `background` rather than `img`.
const makeScene = (id, name, over = {}) => ({
id, name, documentName: "Scene", img: "", grid: 50, flags: {},
toObject() {
return {
_id: this.id, name: this.name, img: this.img, grid: this.grid, flags: this.flags,
...(this.background ? { background: this.background } : {}),
};
},
...over,
});
const scenes = [
makeScene("scene-keep", "The Ruined Keep", { img: "images/keep.webp", grid: 70 }),
// A newer Foundry keeps its picture under `background`, and this one is already an
// absolute URL, which travels as it is.
makeScene("scene-tavern", "Tavern", { img: undefined, background: { src: "http://other.test/tavern.jpg" }, grid: 50 }),
];
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() {}, 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.nextTimerId++;
state.timers.set(id, { fn, delay });
return id;
},
clearTimeout: (id) => state.timers.delete(id),
setInterval: (fn, delay = 0) => {
const id = state.nextTimerId++;
state.intervals.set(id, { fn, delay });
return id;
},
clearInterval: (id) => state.intervals.delete(id),
fetch: async (url, options = {}) => {
state.requests.push({
href: String(url),
method: options.method,
body: options.body ? JSON.parse(options.body) : null,
});
return { ok: true, status: 200, json: async () => ({ status: "ok" }) };
},
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 },
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(read("dragonroll-foundry", "scripts", "api.js"), sandbox);
state.game = sandbox.game;
state.scene = (id) => scenes.find((scene) => scene.id === id);
// The two routes the maps travel on: the campaign's reads live under the same prefix and
// tell nothing about what the world sent.
state.sceneRequests = () => state.requests.filter((request) => request.href.includes("foundry/sync/scenes")
|| request.href.includes("foundry/sync/scene-delete"));
state.pushes = (route) => state.requests.filter((request) => request.href.includes(route));
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();
}
};
// A world that is already linked: init, ready, and the pushes the world makes as it loads.
state.setup = async () => {
await state.fire("init");
await state.fire("ready");
await state.runTimers();
return state;
};
// The same, with the world's own pushes out of the way, so a test only sees what it causes.
state.linkedSetup = async () => {
await state.setup();
state.requests.length = 0;
return state;
};
return state;
}
test("the world sends its whole scene list as the campaign's maps when it loads", async () => {
const world = await makeWorld().setup();
const [push] = world.pushes("foundry/sync/scenes");
assert.ok(push, "a linked world pushes its scenes as it loads");
assert.equal(push.body.fullSync, true, "the whole list travels, which is the push that lets the campaign prune");
assert.deepEqual(push.body.worldId, "world-1");
assert.deepEqual(push.body.scenes.map((scene) => [scene._id, scene.name]), [
["scene-keep", "The Ruined Keep"],
["scene-tavern", "Tavern"],
]);
assert.equal(push.body.scenes[0].img, "http://vtt.test/images/keep.webp",
"the picture is read from this world, so it travels as an absolute URL");
assert.equal(push.body.scenes[0].grid, 70, "the scene's own cell size travels with it");
assert.equal(push.body.scenes[1].background.src, "http://other.test/tavern.jpg",
"a picture that is already absolute is left as it is");
});
test("a scene the GM changes reaches the campaign as that map", async () => {
const world = await makeWorld().linkedSetup();
const keep = world.scene("scene-keep");
keep.name = "The Sunken Keep";
keep.grid = 100;
await world.fire("updateScene", keep);
await world.runTimers();
const [push] = world.pushes("foundry/sync/scenes");
assert.equal(push.body.fullSync, false, "a live scene edit never prunes the campaign's other maps");
assert.deepEqual(push.body.scenes.map((scene) => [scene._id, scene.name, scene.grid]), [
["scene-keep", "The Sunken Keep", 100],
]);
});
test("a scene the GM deletes takes its map off the campaign", async () => {
const world = await makeWorld().linkedSetup();
await world.fire("deleteScene", world.scene("scene-tavern"));
await world.runTimers();
const [push] = world.pushes("foundry/sync/scene-delete");
assert.equal(push.body.foundrySceneId, "scene-tavern");
assert.deepEqual(world.pushes("foundry/sync/scenes"), [], "a deleted scene is not sent as a map to keep");
});
test("autosync off: the world's scenes stop syncing, at world start and afterwards", async () => {
const world = makeWorld({ autoSync: false });
await world.fire("init");
await world.fire("ready");
await world.runTimers();
assert.deepEqual(world.sceneRequests(), [], "a world with autosync off sends no scene list");
await world.fire("updateScene", world.scene("scene-keep"));
await world.fire("deleteScene", world.scene("scene-tavern"));
await world.runTimers();
assert.deepEqual(world.sceneRequests(), []);
});
test("the scene edits queued while autosync was off are sent when it is turned back on", async () => {
const world = await makeWorld({ autoSync: false });
await world.fire("init");
await world.fire("ready");
await world.runTimers();
await world.fire("updateScene", world.scene("scene-keep"));
await world.runTimers();
assert.deepEqual(world.sceneRequests(), []);
await world.game.settings.set(MODULE_ID, "autoSync", true);
await world.runTimers();
assert.ok(world.pushes("foundry/sync/scenes").some((push) => push.body.fullSync === true
&& push.body.scenes.length === 2),
"turning autosync back on sends this world's whole scene list again");
assert.ok(world.pushes("foundry/sync/scenes").some((push) => push.body.fullSync === false
&& push.body.scenes.map((scene) => scene._id).includes("scene-keep")),
"and the scene edit queued while it was off is sent");
});