11 Commits

Author SHA1 Message Date
Gitea OpenCode Agent
8510a93027 Fix issue #101: Add lights to maps
All checks were successful
Test / test (push) Successful in 2s
2026-10-16 01:59:57 +00:00
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
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
29 changed files with 2874 additions and 296 deletions

View File

@@ -142,7 +142,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

@@ -27,6 +27,32 @@ const MapSchema = new Schema({
x: { type: Number, default: 0 }, x: { type: Number, default: 0 },
y: { type: Number, default: 0 } y: { type: Number, default: 0 }
}], }],
// Lights placed on the map. x/y are image pixels like a pin — a light is not tied to a cell — and
// `radius` is how far it reaches in image pixels, of which `bright` is the part that is bright
// light and the rest dim light. The walls below are what stops one, see the viewer's
// services/MapLighting.js.
lights: [{
x: { type: Number, default: 0 },
y: { type: Number, default: 0 },
radius: { type: Number, min: 1, default: 150 },
bright: { type: Number, min: 0, default: 75 },
// Tint of the light, like '#ffc46b'; empty for a plain white light.
color: { type: String, default: '' },
// The Foundry AmbientLight document this light mirrors, when the world sent it (see
// routes/foundry-link.js). Empty for a light the campaign placed itself.
foundryLightId: { type: String, default: '' }
}],
// The line segments that block the lights above. Endpoints are image pixels, and the app draws
// them from corner to corner of the grid so a wall follows its lines.
walls: [{
x1: { type: Number, default: 0 },
y1: { type: Number, default: 0 },
x2: { type: Number, default: 0 },
y2: { type: Number, default: 0 },
// The Foundry Wall document this segment came from, when the world sent it. The world owns its
// walls, so a synced one is drawn back over by the next push of that scene.
foundryWallId: { type: String, default: '' }
}],
campaign: { campaign: {
type: Schema.Types.ObjectId, type: Schema.Types.ObjectId,
ref: 'Campaign', ref: 'Campaign',
@@ -39,6 +65,9 @@ const MapSchema = new Schema({
ref: 'Folder', ref: 'Folder',
default: null default: null
}, },
// The Foundry scene whose lights and walls this map mirrors (see routes/foundry-link.js). Empty for
// a map the campaign made for itself, which is the one kind of light a world never hears about.
foundrySceneId: { type: String, default: '' },
date: { type: Date, default: Date.now } date: { type: Date, default: Date.now }
}); });

View File

@@ -7,8 +7,12 @@ const Campaign = require('../models/Campaign');
const Actor = require('../models/Actor'); const Actor = require('../models/Actor');
const Item = require('../models/Item'); const Item = require('../models/Item');
const Folder = require('../models/Folder'); const Folder = require('../models/Folder');
// Named for what it is: the plain `Map` of this module's own scope would hide the built-in `Map` the
// item folder sync below builds its trees out of.
const MapModel = require('../models/Map');
const { foundryActorToCharacter } = require('../services/actor-foundry'); const { foundryActorToCharacter } = require('../services/actor-foundry');
const { foundryItemToItemData } = require('../services/item-foundry'); const { foundryItemToItemData } = require('../services/item-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,187 @@ function resolveFoundryItemFolder(source, folders) {
return folders.get(foundryFolderId.trim())?._id || null; return folders.get(foundryFolderId.trim())?._id || null;
} }
// --- Scene lighting ------------------------------------------------------------
// A Foundry scene lights its own ground, and the campaign mirrors that onto the map standing for that
// scene: the world's ambient lights and the walls that stop them arrive there, so a torch lit in the
// world is a torch on the map the campaign reads, and the dark behind its walls is the same dark.
//
// The module sends its coordinates as pixels of the scene's background image at the size that image
// has on disk, and its reaches likewise. The campaign keeps everything as pixels of its own map image,
// so the grid cell is the unit the two agree on: one scene pixel is worth as many map pixels as that
// map's cell is wider or narrower than the scene's.
function sceneNumber(value, fallback = 0) {
const number = Number(value);
return Number.isFinite(number) ? number : fallback;
}
// The scene a push describes: enough of it to mirror a map after it, and to scale its lighting onto
// the grid of whichever map that turns out to be.
function readSceneSource(source) {
const id = String(source?.id || '').trim().slice(0, 120);
if (!id) return null;
return {
id,
title: String(source?.title || '').trim().slice(0, 200),
// How wide one of the scene's cells is in its image pixels, and how much distance it stands
// for: the map the scene is mirrored onto keeps both of these under the same names.
grid: Math.max(1, Math.round(sceneNumber(source?.grid, 50))),
gridDistance: Math.max(0.01, sceneNumber(source?.gridDistance, 5)),
image: typeof source?.image === 'string' ? source.image.trim() : ''
};
}
// The map a scene's lighting belongs to: the one already mirroring that scene, or the campaign's own
// map of the same name — the same courtesy the item sync extends a hand-written row, so whoever drew
// the map by hand is not made to start over — and, when the scene has lighting of its own and the
// campaign has no map for it yet, a new map mirroring the scene. A scene with nothing to send never
// invents a map nobody asked for.
async function sceneMap(campaign, scene, create) {
const mapped = await MapModel.findOne({ campaign: campaign._id, foundrySceneId: scene.id });
if (mapped) return mapped;
if (scene.title) {
const namesakes = await MapModel.find({ campaign: campaign._id, name: scene.title }).limit(4);
const claiming = namesakes.filter((map) => !map.foundrySceneId);
// Only a name the campaign uses once claims the scene; two maps of that name would make it a
// guess which of them the world is talking about.
if (claiming.length === 1) {
const map = claiming[0];
map.foundrySceneId = scene.id;
return map;
}
}
if (!create) return null;
return new MapModel({
campaign: campaign._id,
name: scene.title || 'Foundry scene',
// The scene's own artwork, read against its world like every other Foundry image (see
// worldAssetUrl), so the campaign is looking at the same picture the players are.
image: worldAssetUrl(scene.image, campaign?.settings?.integrations?.foundryUrl),
gridSize: scene.grid,
scale: scene.gridDistance,
foundrySceneId: scene.id
});
}
// A scene pixel as a coordinate of the campaign's map: whole pixels, never negative, and scaled by the
// two grids' difference in cell width.
function scenePixelToMap(value, ratio) {
const number = sceneNumber(value, 0) * ratio;
return Math.max(0, Math.round(number));
}
// The tint of a light, or none: the viewer paints with it, so anything that is not a hex colour is
// dropped rather than trusted.
function sceneLightColor(value) {
const color = typeof value === 'string' ? value.trim().toLowerCase() : '';
return /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/.test(color) ? color : '';
}
// A wall of the map is kept at its corners of the grid, the way a wall drawn in Dragonroll is, so the
// lines a scene sends and the lines a campaign draws follow the same grid.
function toMapGridVertex(value, offset, size) {
const steps = Math.round((Math.max(0, Math.round(value)) - offset) / size);
return Math.max(0, Math.round(offset + steps * size));
}
// The lights of a scene written onto its map. A light the world sent before is written over — the
// world owns its own lighting, so unlike an actor's fields a move lands on every push — one it never
// sent is added, and one it has let go of goes. A light the campaign placed itself (no foundryLightId)
// is none of the world's business and stays.
function writeSceneLights(map, scene, sources) {
const ratio = map.gridSize / scene.grid;
const kept = new Set();
let changed = false;
for (const source of sources) {
const id = String(source?.id || '').trim().slice(0, 120);
if (!id || kept.has(id)) continue;
kept.add(id);
const radius = Math.max(1, scenePixelToMap(source?.radius, ratio));
const spot = {
x: scenePixelToMap(source?.x, ratio),
y: scenePixelToMap(source?.y, ratio),
radius,
bright: Math.max(0, Math.min(radius, scenePixelToMap(source?.bright, ratio))),
color: sceneLightColor(source?.color)
};
const light = map.lights.find((entry) => entry.foundryLightId && String(entry.foundryLightId) === id);
if (light) {
Object.assign(light, spot);
} else {
map.lights.push({ ...spot, foundryLightId: id });
}
changed = true;
}
// Only the world's own lights are pruned, and only by a push that speaks of lights at all.
const remaining = map.lights.filter((entry) => !entry.foundryLightId || kept.has(String(entry.foundryLightId)));
if (remaining.length !== map.lights.length) changed = true;
map.lights = remaining;
return changed;
}
// The walls of a scene, likewise: the world drew them, so its own walls arrive whole with every push.
function writeSceneWalls(map, scene, sources) {
const ratio = map.gridSize / scene.grid;
const kept = new Set();
let changed = false;
for (const source of sources) {
const id = String(source?.id || '').trim().slice(0, 120);
if (!id || kept.has(id)) continue;
kept.add(id);
const corner = {
x1: toMapGridVertex(scenePixelToMap(source?.x1, ratio), map.offsetX, map.gridSize),
y1: toMapGridVertex(scenePixelToMap(source?.y1, ratio), map.offsetY, map.gridSize),
x2: toMapGridVertex(scenePixelToMap(source?.x2, ratio), map.offsetX, map.gridSize),
y2: toMapGridVertex(scenePixelToMap(source?.y2, ratio), map.offsetY, map.gridSize)
};
// A wall from a corner to itself blocks nothing, and neither does its twin drawn backwards.
if (corner.x1 === corner.x2 && corner.y1 === corner.y2) continue;
const wall = map.walls.find((entry) => entry.foundryWallId && String(entry.foundryWallId) === id);
if (wall) Object.assign(wall, corner);
else map.walls.push({ ...corner, foundryWallId: id });
changed = true;
}
const remaining = map.walls.filter((entry) => !entry.foundryWallId || kept.has(String(entry.foundryWallId)));
if (remaining.length !== map.walls.length) changed = true;
map.walls = remaining;
return changed;
}
// The maps the module reconciles its scenes against: which campaign lights belong in which world
// scene, and how far a pixel of that map is worth. Only the maps that speak of lighting are sent, and
// a map mirroring a scene is sent even empty of lights, because that is what tells the world its
// campaign has put every one of its lights out.
function sceneLightingList(maps) {
return maps
.filter((map) => (map.lights?.length ?? 0) > 0 || map.foundrySceneId)
.map((map) => ({
_id: map._id,
name: map.name,
foundrySceneId: map.foundrySceneId || '',
gridSize: map.gridSize,
scale: map.scale,
lights: (map.lights ?? []).map((light) => ({
_id: light._id,
x: light.x,
y: light.y,
radius: light.radius,
bright: light.bright,
color: light.color || '',
foundryLightId: light.foundryLightId || ''
}))
}));
}
// Linking a world to a campaign happens through the sign-up link every service // Linking a world to a campaign happens through the sign-up link every service
// uses (routes/service-link.js); what stays here is the sync that world keeps up // uses (routes/service-link.js); what stays here is the sync that world keeps up
@@ -452,6 +661,82 @@ router.post('/sync/map-item', async (req, res) => {
} }
}); });
// The lighting of one of the world's scenes: its ambient lights and the walls that stop them, sent
// whole so the campaign's map of that scene reads like the ground the players are standing on.
router.post('/sync/scene', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const scene = readSceneSource(req.body.scene);
const lights = Array.isArray(req.body.lights) ? req.body.lights : null;
const walls = Array.isArray(req.body.walls) ? req.body.walls : null;
if (!requestMatchesWorld(campaign, req.body.worldId) || !scene || (!lights && !walls)) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const map = await sceneMap(campaign, scene, (lights?.length ?? 0) + (walls?.length ?? 0) > 0);
// A world pushing a scene empty of lighting onto a campaign that has no map for it: there is
// nothing here to remember, so nothing is remembered.
if (!map) return res.json({ status: 'ok', map: null, lights: 0, walls: 0 });
// A push owns the lighting it carries and nothing else: not the map's name, not its picture,
// not the grid whoever lined it up by hand settled on.
if (lights) writeSceneLights(map, scene, lights);
if (walls) writeSceneWalls(map, scene, walls);
await map.save();
res.json({
status: 'ok',
map: { _id: map.id, name: map.name, gridSize: map.gridSize, scale: map.scale, foundrySceneId: map.foundrySceneId },
lights: map.lights.filter((entry) => entry.foundryLightId).length,
walls: map.walls.filter((entry) => entry.foundryWallId).length
});
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// The campaign's lighting as the world reads it: which of its lights stand in which scene, at the map
// pixels the module scales back onto the world's own grid.
router.get('/sync/scenes', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const maps = await MapModel.find({ campaign: campaign._id }).sort({ name: 1 }).lean();
res.json({ status: 'ok', scenes: sceneLightingList(maps) });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// A light the campaign placed and the world has taken on: the AmbientLight document standing for it, so
// the next write of that light knows which document to move instead of adding a second one.
router.post('/sync/map-scene-light', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const { map, light, foundryLightId, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !map || !light || !foundryLightId) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const mapDoc = await MapModel.findOne({ _id: map, campaign: campaign._id });
if (!mapDoc) return res.json({ status: 'error', msg: 'errors.notfound' });
const entry = mapDoc.lights.find((current) => String(current._id) === String(light));
if (!entry) return res.json({ status: 'error', msg: 'errors.notfound' });
entry.foundryLightId = String(foundryLightId).trim().slice(0, 120);
await mapDoc.save();
res.json({ status: 'ok', light: { _id: entry._id, foundryLightId: entry.foundryLightId } });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router; module.exports = router;
// The writers every Foundry document goes through: the sync pushes above, and the // The writers every Foundry document goes through: the sync pushes above, and the
// force import a campaign asks for from its sidebar (routes/foundry.js). One set of // force import a campaign asks for from its sidebar (routes/foundry.js). One set of

View File

@@ -238,4 +238,205 @@ router.post('/remove-token', async (req, res) => {
} }
}); });
// --- Lights ---
// A light shines from one spot of the image and is as free as a pin: it is not tied to a cell, so it
// lands wherever it is placed. Its reach is measured in image pixels too, so it covers the same ground
// whatever the zoom is, and it is that reach the viewer cuts its shadow against the walls below with.
// How far a light of the map reaches when nothing is asked for: about three cells of the default grid.
const DEFAULT_LIGHT_RADIUS = 150;
function toReach(value, fallback) {
const number = Number(value);
if (!Number.isFinite(number) || number <= 0) return fallback;
return Math.max(1, Math.round(number));
}
// The bright core of a light: never wider than the light itself, and never negative. A light with no
// core is still a light, so 0 is a value of its own here and not a missing one.
function toBright(value, radius, fallback) {
if (value === undefined || value === null || value === '') return Math.min(radius, Math.round(fallback));
const number = Number(value);
if (!Number.isFinite(number)) return Math.min(radius, Math.round(fallback));
return Math.max(0, Math.min(radius, Math.round(number)));
}
// A tint is a hex colour and nothing else: the viewer paints the light with it, so a value carrying
// more than colour codes is dropped instead of trusted.
function toColor(value) {
const color = String(value ?? '').trim().toLowerCase();
return /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/.test(color) ? color : '';
}
router.post('/place-light', async (req, res) => {
try {
const { id, x, y, radius, bright, color } = req.body;
if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' });
const map = await Map.findById(id);
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' });
const reach = toReach(radius, DEFAULT_LIGHT_RADIUS);
map.lights.push({
x: toCoordinate(x),
y: toCoordinate(y),
radius: reach,
bright: toBright(bright, reach, reach / 2),
color: toColor(color)
});
await map.save();
res.json({ status: 'ok', map });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/update-light', async (req, res) => {
try {
const { id, light, x, y, radius, bright, color } = req.body;
if (!id || !light) return res.json({ status: 'error', msg: 'errors.missing-data' });
const map = await Map.findById(id);
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' });
const current = map.lights.find((entry) => String(entry._id) === String(light));
if (!current) return res.json({ status: 'error', msg: 'errors.notfound' });
if (x !== undefined) current.x = toCoordinate(x);
if (y !== undefined) current.y = toCoordinate(y);
if (color !== undefined) current.color = toColor(color);
if (radius !== undefined) {
current.radius = toReach(radius, current.radius);
// A light shrunk below its own core takes the core with it, unless this request is
// setting the core as well, which is clamped to the new reach below.
current.bright = Math.min(current.bright, current.radius);
}
if (bright !== undefined) current.bright = toBright(bright, current.radius, current.bright);
await map.save();
res.json({ status: 'ok', map });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/remove-light', async (req, res) => {
try {
const { id, light } = req.body;
if (!id || !light) return res.json({ status: 'error', msg: 'errors.missing-data' });
const map = await Map.findById(id);
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' });
// `_id` stays with the lights that remain, the same way the tokens are removed.
map.lights = map.lights
.filter((entry) => String(entry._id) !== String(light))
.map((entry) => ({
_id: entry._id,
x: entry.x,
y: entry.y,
radius: entry.radius,
bright: entry.bright,
color: entry.color,
foundryLightId: entry.foundryLightId
}));
await map.save();
res.json({ status: 'ok', map });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// --- Walls ---
// The segments that stop a light. They are drawn from one corner of the grid to another — the same
// corners the tokens' cells are counted from — so a wall lines up with the grid of the map it belongs
// to. A world's walls travel to the map they light (routes/foundry-link.js) and arrive at the corners
// of the grid the same way.
function toGridVertex(value, offset, size) {
const grid = Math.max(1, Number(size) || 50);
const origin = Number(offset) || 0;
const steps = Math.round((toCoordinate(value) - origin) / grid);
return Math.max(0, Math.round(origin + steps * grid));
}
// The two ends of a wall are corners of this map's grid, whatever the pointer asked for.
function wallCorners(body, map) {
return {
x1: toGridVertex(body.x1, map.offsetX, map.gridSize),
y1: toGridVertex(body.y1, map.offsetY, map.gridSize),
x2: toGridVertex(body.x2, map.offsetX, map.gridSize),
y2: toGridVertex(body.y2, map.offsetY, map.gridSize)
};
}
function isSameWall(wall, corner) {
return (String(wall.x1) === String(corner.x1) && String(wall.y1) === String(corner.y1)
&& String(wall.x2) === String(corner.x2) && String(wall.y2) === String(corner.y2))
// A wall drawn backwards is the same wall.
|| (String(wall.x1) === String(corner.x2) && String(wall.y1) === String(corner.y2)
&& String(wall.x2) === String(corner.x1) && String(wall.y2) === String(corner.y1));
}
router.post('/wall', async (req, res) => {
try {
const { id } = req.body;
if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' });
const map = await Map.findById(id);
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' });
const corner = wallCorners(req.body, map);
// A wall from a corner to itself blocks nothing and cannot be clicked off again.
if (corner.x1 === corner.x2 && corner.y1 === corner.y2) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
// Drawing over a wall that is already there does not add a second one.
if (map.walls.some((wall) => isSameWall(wall, corner))) return res.json({ status: 'ok', map });
map.walls.push(corner);
await map.save();
res.json({ status: 'ok', map });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/remove-wall', async (req, res) => {
try {
const { id, wall } = req.body;
if (!id || !wall) return res.json({ status: 'error', msg: 'errors.missing-data' });
const map = await Map.findById(id);
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' });
// `_id` stays with the walls that remain, like everything else hanging off a map.
map.walls = map.walls
.filter((entry) => String(entry._id) !== String(wall))
.map((entry) => ({
_id: entry._id,
x1: entry.x1,
y1: entry.y1,
x2: entry.x2,
y2: entry.y2,
foundryWallId: entry.foundryWallId
}));
await map.save();
res.json({ status: 'ok', map });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router; module.exports = router;

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

@@ -36,6 +36,12 @@ let folderSyncRunning = false;
const syncingItemIds = new Set(); const syncingItemIds = new Set();
const syncingFolderIds = new Set(); const syncingFolderIds = new Set();
const queuedItemChanges = new Map(); const queuedItemChanges = new Map();
// The lighting of the scene being played: queued while the GM drags walls about, and written back into
// the world from the campaign on a timer.
let sceneLightingTimeout;
let sceneLightingRunning = false;
let sceneLightingErrorLogged = false;
const syncingLightIds = new Set();
function getCollectionContents(collection, collectionName) { function getCollectionContents(collection, collectionName) {
if (!collection) { if (!collection) {
@@ -441,6 +447,7 @@ function handleAutoSyncChange(value) {
clearTimeout(actorSyncTimeout); clearTimeout(actorSyncTimeout);
clearTimeout(itemSyncTimeout); clearTimeout(itemSyncTimeout);
clearTimeout(folderSyncTimeout); clearTimeout(folderSyncTimeout);
clearTimeout(sceneLightingTimeout);
return; return;
} }
if (!game.user?.isGM || !getSyncToken()) return; if (!game.user?.isGM || !getSyncToken()) return;
@@ -450,6 +457,10 @@ function handleAutoSyncChange(value) {
initializeCharacterSync(); initializeCharacterSync();
reconcileDragonrollItems(); reconcileDragonrollItems();
queueFoundryItemFolders(400); queueFoundryItemFolders(400);
// The lighting of the scene the campaign mirrors converges too: a wall or a lamp moved while
// autosync was off is the world's, and the campaign's own lights are written back into the scene.
queueSceneLightingChange(400);
reconcileDragonrollSceneLighting();
if (queuedActorChanges.size) { if (queuedActorChanges.size) {
clearTimeout(actorSyncTimeout); clearTimeout(actorSyncTimeout);
actorSyncTimeout = setTimeout(flushActorChanges, 400); actorSyncTimeout = setTimeout(flushActorChanges, 400);
@@ -523,9 +534,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,
@@ -1054,6 +1072,371 @@ async function reconcileDragonrollItems() {
} }
} }
// --- Scene lighting ------------------------------------------------------------
// The lights of the scene being played, and the walls that stop them, travel to the Dragonroll map
// mirroring that scene; the lights the campaign places on that map travel back into the scene as
// ambient lights. Lighting belongs to a world the same way whatever system it runs, so unlike the
// actors and the items this asks for no particular one.
//
// Foundry measures a scene in canvas pixels (its background image as it is drawn) and a light's reach
// in the scene's distance units; Dragonroll measures both in pixels of the map image and of its grid.
// So a scene goes over as pixels of its own background image, and comes back through the grid cell,
// which is the one unit the two share.
// The canvas of the scene being played. `canvas` is a global only where a scene has been drawn, and
// only in a game client at that, so it is asked for the way the module asks for any global it cannot
// be sure of.
function foundryCanvas() {
return typeof canvas === "undefined" ? null : canvas;
}
// The scene whose lighting travels: the one being played. Foundry loads the walls and lights of a scene
// when it draws it, so nothing else of the world's is at hand to send.
function currentScene() {
return foundryCanvas()?.scene ?? game.scenes?.active ?? game.scenes?.current ?? null;
}
// A scene's embedded documents of one kind. Which collection holds them has moved about between Foundry
// versions, so each way is tried, best first, and only documents of the kind asked for are taken.
function sceneDocuments(scene, kind) {
if (!scene) return [];
for (const candidate of [
scene.getEmbeddedCollection?.(kind)?.contents,
scene[kind === "Wall" ? "walls" : "lighting"]?.contents,
scene.embedded?.[kind]?.contents,
scene.embeddedContents,
]) {
if (!Array.isArray(candidate)) continue;
return candidate.filter((document) => document?.documentName === kind);
}
return [];
}
function findSceneDocument(scene, kind, id) {
return sceneDocuments(scene, kind).find((document) => String(document.id) === String(id)) ?? null;
}
// Scene canvas pixels → pixels of the scene's background image at the size it has on disk, which is
// what a Dragonroll map is measured in. `dimensions.sceneRatio` is the scale that image is drawn at.
function sceneImageScale() {
const ratio = Number(foundryCanvas()?.dimensions?.sceneRatio);
return Number.isFinite(ratio) && ratio > 0 ? ratio : 1;
}
function toSceneImagePixels(value) {
const number = Number(value);
return Number.isFinite(number) ? Math.round(number / sceneImageScale()) : 0;
}
// How wide one of the scene's cells is, in its image pixels.
function sceneImageGrid(scene) {
const grid = Number(scene?.grid ?? foundryCanvas()?.dimensions?.grid);
return Number.isFinite(grid) && grid > 0 ? Math.round(grid) : 50;
}
function sceneGridDistance(scene) {
const distance = Number(scene?.gridDistance);
return Number.isFinite(distance) && distance > 0 ? distance : 5;
}
// A light's reach, which Foundry measures in the scene's distance units, as pixels of its image: so
// many cells, at the scene's own pixels per cell.
function lightReachToImagePixels(value, scene) {
const reach = Number(value);
if (!Number.isFinite(reach) || reach <= 0) return 0;
return Math.round((reach / sceneGridDistance(scene)) * sceneImageGrid(scene));
}
// A colour of a Foundry light as its document writes it: a hex string, or a number in the versions
// that stored one that way. Empty for a light with no tint of its own.
function sceneLightColor(color) {
if (typeof color === "string") return /^#[0-9a-f]{3,8}$/i.test(color.trim()) ? color.trim().toLowerCase() : "";
if (Number.isFinite(color) && color > 0) return `#${Math.round(color).toString(16).padStart(6, "0")}`;
return "";
}
// Foundry's wall kinds and restrictions: a wall that lets the players see through it lights whatever
// it is drawn over, a wall only sensing shapes what a sensor reaches and lets light through, and a
// door left open lets the light through along with whoever opened it.
const WALL_KIND_SENSES = "sense";
const WALL_MOVEMENT_OPEN = 2;
const WALL_RESTRICTION_BLOCK = 2;
function blocksSceneLight(wall) {
if (String(wall?.wall ?? "walls") === WALL_KIND_SENSES) return false;
if (Number(wall?.move) === WALL_MOVEMENT_OPEN) return false;
return Number(wall?.sight) === WALL_RESTRICTION_BLOCK || Number(wall?.light) === WALL_RESTRICTION_BLOCK;
}
function serializeSceneLight(light, scene) {
const config = light?.config ?? {};
return {
id: String(light.id),
x: toSceneImagePixels(light.x),
y: toSceneImagePixels(light.y),
radius: lightReachToImagePixels(config.dim, scene),
bright: lightReachToImagePixels(config.bright, scene),
color: sceneLightColor(config.color),
};
}
function serializeSceneWall(wall) {
const corner = wall?.c ?? {};
return {
id: String(wall.id),
x1: toSceneImagePixels(corner.x),
y1: toSceneImagePixels(corner.y),
x2: toSceneImagePixels(corner.x2),
y2: toSceneImagePixels(corner.y2),
};
}
function sceneLightingMeta(scene) {
return {
id: scene.id,
title: String(scene.title ?? scene.name ?? ""),
grid: sceneImageGrid(scene),
gridDistance: sceneGridDistance(scene),
image: sceneBackgroundImage(scene),
};
}
// The scene's own artwork, as an address a campaign outside the world can read — the same as every
// other image the module sends (see serializeFoundryActor).
function sceneBackgroundImage(scene) {
const image = scene?.texture?.src ?? scene?.img ?? "";
if (typeof image !== "string" || !image || /^(https?:|data:|\/\/)/i.test(image)) return image || "";
return new URL(image, window.location.origin).toString();
}
// What a scene is lit by, whole. A scene with neither lights nor walls is worth sending for what it
// takes off the campaign; it is the campaign's own business whether that is worth a map of.
function sceneLightingSnapshot(scene) {
const target = scene ?? currentScene();
if (!target) return null;
return {
scene: sceneLightingMeta(target),
lights: sceneDocuments(target, "AmbientLight").map((light) => serializeSceneLight(light, target)),
walls: sceneDocuments(target, "Wall").filter(blocksSceneLight).map(serializeSceneWall),
};
}
async function pushSceneLighting() {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world) return;
const snapshot = sceneLightingSnapshot();
if (!snapshot) return;
await postDragonroll("foundry/sync/scene", { worldId: game.world.id, ...snapshot }, token);
}
function queueSceneLightingChange(delay = 400) {
clearTimeout(sceneLightingTimeout);
sceneLightingTimeout = setTimeout(flushSceneLighting, delay);
}
async function flushSceneLighting() {
// Autosync off: the lighting edits wait with the actor and item ones, so turning it back on sends them.
if (!isAutoSyncEnabled()) return;
try {
await pushSceneLighting();
sceneLightingErrorLogged = false;
} catch (error) {
if (!sceneLightingErrorLogged) {
sceneLightingErrorLogged = true;
console.warn(`${MODULE_ID} | Scene lighting sync failed and will retry.`, error);
}
queueSceneLightingChange(5000);
}
}
// Writing into the world from the campaign is marked the same way every other Dragonroll write is, so
// the world does not echo it straight back to the campaign.
function dragonrollLightId(light) {
return light.getFlag?.(MODULE_ID, "lightId") || light.flags?.[MODULE_ID]?.lightId || "";
}
function isSceneLightingMutation(document) {
return document?.flags?.[MODULE_ID]?.syncMutation === true || syncingLightIds.has(document?.id);
}
async function withLightSyncSuppressed(light, callback) {
if (!light?.id) return callback();
syncingLightIds.add(light.id);
try {
return await callback();
} finally {
syncingLightIds.delete(light.id);
}
}
// How many canvas pixels one pixel of the campaign's map is worth in the scene being written to: cells
// first, then the cell as the world's canvas draws it.
function mapPixelsToSceneCanvas(value, mirror) {
const cell = Number(mirror?.gridSize) || sceneImageGrid(currentScene());
const gridPixels = Number(foundryCanvas()?.dimensions?.gridPixels) || sceneImageGrid(currentScene()) * sceneImageScale();
const number = Number(value);
if (!Number.isFinite(number)) return 0;
return Math.round((number / Math.max(1, cell)) * gridPixels);
}
// A reach of the campaign's map, in its pixels, as so many of the scene's distance units. `scale` is
// how much distance one cell of the map stands for, which is what Foundry measures a light in.
function mapPixelsToSceneDistance(value, mirror) {
const cell = Number(mirror?.gridSize) || sceneImageGrid(currentScene());
const perCell = Number(mirror?.scale) || sceneGridDistance(currentScene());
const number = Number(value);
if (!Number.isFinite(number) || number <= 0) return 0;
return Math.round(((number / Math.max(1, cell)) * perCell * 100)) / 100;
}
function sceneLightUpdateData(entry, mirror) {
return {
x: mapPixelsToSceneCanvas(entry.x, mirror),
y: mapPixelsToSceneCanvas(entry.y, mirror),
"config.dim": mapPixelsToSceneDistance(entry.radius, mirror),
"config.bright": mapPixelsToSceneDistance(entry.bright, mirror),
"config.color": entry.color || null,
};
}
// Whether a light of the world already says what the campaign's light says — within a pixel, and within
// a hundredth of a distance unit. Writing a light that is already where it belongs is how a sync would
// never come to rest: the two sides measure in different units and round differently doing it.
function sceneLightMatches(light, entry, mirror) {
const updates = sceneLightUpdateData(entry, mirror);
const near = (foundry, wanted, tolerance) => Math.abs(Number(foundry ?? 0) - Number(wanted ?? 0)) <= tolerance;
return near(light.x, updates.x, 1)
&& near(light.y, updates.y, 1)
&& near(light.config?.radius?.dim, updates["config.dim"], 0.01)
&& near(light.config?.radius?.bright, updates["config.bright"], 0.01)
&& sceneLightColor(light.config?.color) === String(entry.color ?? "").toLowerCase();
}
async function mapDragonrollSceneLight(mapId, lightId, foundryLightId) {
const token = getSyncToken();
return postDragonroll("foundry/sync/map-scene-light", {
worldId: game.world.id,
map: String(mapId),
light: String(lightId),
foundryLightId: String(foundryLightId),
}, token);
}
function makeSceneLightData(entry, mirror) {
return {
name: String(mirror?.name || "Dragonroll") + " light",
hidden: false,
x: mapPixelsToSceneCanvas(entry.x, mirror),
y: mapPixelsToSceneCanvas(entry.y, mirror),
config: {
alpha: 1,
dim: mapPixelsToSceneDistance(entry.radius, mirror),
bright: mapPixelsToSceneDistance(entry.bright, mirror),
color: entry.color || null,
},
flags: { [MODULE_ID]: { lightId: String(entry._id), syncMutation: true } },
};
}
async function createSceneLightFromDragonroll(scene, entry, mirror) {
const LightDocument = CONFIG.AmbientLight?.documentClass ?? (typeof AmbientLight === "undefined" ? null : AmbientLight);
if (!LightDocument?.create) return null;
const created = await LightDocument.create(makeSceneLightData(entry, mirror), { parent: scene });
const light = Array.isArray(created) ? created[0] : created;
if (!light) return null;
await withLightSyncSuppressed(light, async () => {
await light.update({ [`flags.${MODULE_ID}.syncMutation`]: false });
});
await mapDragonrollSceneLight(mirror._id, entry._id, light.id);
return light;
}
async function applyDragonrollSceneLight(light, entry, mirror) {
const retag = dragonrollLightId(light) !== String(entry._id)
? { [`flags.${MODULE_ID}.lightId`]: String(entry._id) }
: null;
// Already where the campaign says it is: nothing is written, which is what keeps this from
// rewriting the world's lighting every few seconds for the rest of the evening.
if (sceneLightMatches(light, entry, mirror)) {
if (retag) await light.update(retag);
return;
}
await withLightSyncSuppressed(light, async () => {
await light.update(sceneLightUpdateData(entry, mirror));
if (retag) await light.update(retag);
});
}
// Which of the campaign's maps the scene being played mirrors: the one that says it does, failing that
// a map of the same name — the same courtesy the item sync offers a hand-written row, and refused the
// moment two maps of that name leave it a guess.
function sceneMirrorMap(scenes, scene) {
const rows = Array.isArray(scenes) ? scenes : [];
const mapped = rows.find((row) => row.foundrySceneId && String(row.foundrySceneId) === String(scene.id));
if (mapped) return mapped;
const title = String(scene.title ?? scene.name ?? "").trim();
if (!title) return null;
const namesakes = rows.filter((row) => !row.foundrySceneId && String(row.name ?? "").trim() === title);
return namesakes.length === 1 ? namesakes[0] : null;
}
async function reconcileDragonrollSceneLighting() {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || sceneLightingRunning || !isAutoSyncEnabled()) return;
const scene = currentScene();
if (!scene) return;
sceneLightingRunning = true;
try {
const result = await getDragonroll("foundry/sync/scenes", token);
const mirror = sceneMirrorMap(result.scenes, scene);
if (!mirror) return;
const entries = Array.isArray(mirror.lights) ? mirror.lights : [];
const wanted = new Set(entries.map((entry) => String(entry._id)));
const localByRemoteId = new Map(sceneDocuments(scene, "AmbientLight")
.map((light) => [String(dragonrollLightId(light)), light])
.filter(([lightId]) => lightId));
const retained = new Set();
for (const entry of entries) {
let light = entry.foundryLightId ? findSceneDocument(scene, "AmbientLight", entry.foundryLightId) : null;
if (!light) light = localByRemoteId.get(String(entry._id));
if (light) {
retained.add(light.id);
await applyDragonrollSceneLight(light, entry, mirror);
if (!entry.foundryLightId) await mapDragonrollSceneLight(mirror._id, entry._id, light.id);
} else if (entry.foundryLightId) {
// A light of another world's scene, or one the campaign read from a scene that is not this one:
// its own scene owns it, so cloning it here would light the room twice.
continue;
} else {
const created = await createSceneLightFromDragonroll(scene, entry, mirror);
if (created) retained.add(created.id);
}
}
// A light the campaign put out is taken out of the world along with it — only one the world was
// told it wrote, never a lamp the GM lit themselves.
for (const light of sceneDocuments(scene, "AmbientLight")) {
const lightId = dragonrollLightId(light);
if (!lightId || retained.has(light.id) || wanted.has(String(lightId))) continue;
await withLightSyncSuppressed(light, () => light.delete());
}
sceneLightingErrorLogged = false;
} catch (error) {
if (!sceneLightingErrorLogged) {
sceneLightingErrorLogged = true;
console.warn(`${MODULE_ID} | Scene lighting reconcile failed and will retry.`, error);
}
} finally {
sceneLightingRunning = false;
}
}
function getDragonrollImageUrl(image) { function getDragonrollImageUrl(image) {
if (!image) return ""; if (!image) return "";
if (/^(https?:|data:|\/\/)/i.test(image)) return image; if (/^(https?:|data:|\/\/)/i.test(image)) return image;
@@ -1194,7 +1577,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 +1615,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);
} }
@@ -1428,11 +1824,17 @@ Hooks.once("ready", () => {
// already seen the world directory when it starts sending its own items back. // already seen the world directory when it starts sending its own items back.
setTimeout(reconcileDragonrollItems, 2000); setTimeout(reconcileDragonrollItems, 2000);
setInterval(reconcileDragonrollItems, 5000); setInterval(reconcileDragonrollItems, 5000);
// The scene being played is lit once its canvas is drawn: send what lights it, and write back the
// lights the campaign has placed on the map mirroring it.
queueSceneLightingChange(3000);
setInterval(reconcileDragonrollSceneLighting, 5000);
for (const event of [ for (const event of [
"createActor", "updateActor", "deleteActor", "createActor", "updateActor", "deleteActor",
"createItem", "updateItem", "deleteItem", "createItem", "updateItem", "deleteItem",
"createFolder", "updateFolder", "deleteFolder", "createFolder", "updateFolder", "deleteFolder",
"createAmbientLight", "updateAmbientLight", "deleteAmbientLight",
"createWall", "updateWall", "deleteWall",
]) { ]) {
Hooks.on(event, (document) => { Hooks.on(event, (document) => {
scheduleSnapshotSync(); scheduleSnapshotSync();
@@ -1442,6 +1844,13 @@ Hooks.once("ready", () => {
queueFoundryActorChange(isDelete ? "delete" : "upsert", document); queueFoundryActorChange(isDelete ? "delete" : "upsert", document);
return; return;
} }
// A wall the GM draws or a lamp they move changes how the scene reads, so the whole of its
// lighting goes over. A light Dragonroll has just written into the scene is not the GM's doing.
if (document.documentName === "AmbientLight" || document.documentName === "Wall") {
if (isSceneLightingMutation(document)) return;
queueSceneLightingChange();
return;
}
// An item folder the GM made, renamed or nested changes the tree the campaign // An item folder the GM made, renamed or nested changes the tree the campaign
// mirrors; nothing about the items themselves changed, so only the tree goes. // mirrors; nothing about the items themselves changed, so only the tree goes.
// A colour Dragonroll has just written into the folder is not the GM changing it. // A colour Dragonroll has just written into the folder is not the GM changing it.
@@ -1463,6 +1872,15 @@ Hooks.once("ready", () => {
} }
}); });
// Moving to another scene changes which of the world's lighting the campaign mirrors: what lights the
// new scene is sent, and the lights the campaign placed on its map are written back into it. A canvas
// is not worth reading the moment it is initialised, so both are asked for a little later.
Hooks.on("canvasInit", () => {
if (!game.user?.isGM || !getSyncToken()) return;
queueSceneLightingChange(1200);
setTimeout(reconcileDragonrollSceneLighting, 1500);
});
// A GM sends selected actors to Dragonroll from the actor directory's context // A GM sends selected actors to Dragonroll from the actor directory's context
// menu. This works with autosync on and off: it is the one push done on purpose. // menu. This works with autosync on and off: it is the one push done on purpose.
Hooks.on("getActorDirectoryEntryContext", (html, options) => { Hooks.on("getActorDirectoryEntryContext", (html, options) => {

View File

@@ -22,6 +22,11 @@ $themes: (
note-border: #202324, note-border: #202324,
// A map's lighting: the dark the lights are carved out of, and the walls that cut them. The map
// canvas reads both off these variables (see components/viewer/map/MapViewerPane.vue).
map-darkness: #000000d9,
map-wall: #e06c75,
hover: #21262d, hover: #21262d,
selected: #4a4a4b, selected: #4a4a4b,
border-color: #819796, border-color: #819796,
@@ -70,6 +75,11 @@ $themes: (
note-border: #e0e0e0, note-border: #e0e0e0,
// Same lighting keys as the dark map; the dark over a map is the dark of a room whichever theme
// the app is drawn in, and its walls are darkened to stay readable over a light image.
map-darkness: #000000d9,
map-wall: #c62828,
border-color: #e0e0e0, border-color: #e0e0e0,
border: #f0f0f0, border: #f0f0f0,
hover: #e9e9e9, hover: #e9e9e9,

View File

@@ -418,3 +418,88 @@ 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,11 +42,11 @@ function ExitCampaign() {
<TopSearchBar></TopSearchBar> <TopSearchBar></TopSearchBar>
</div> </div>
<div class="right"> <div class="right">
<!-- La documentació és una pàgina a part (/docs), i una pestanya nova deixa la <!-- La documentació s'obre en una finestra seva, davant de la campanya: les notes
campanya tal com era: les notes obertes no es perden. --> obertes no es perden i no cal obrir una pestanya nova. -->
<a class="btn-primary docs-button sound-click" href="/docs" target="_blank" rel="noopener noreferrer"> <button class="btn-primary settings-button docs-button sound-click" type="button" @click="OpenDocumentation">
{{ $t('main-menu.documentation') }} {{ $t('main-menu.documentation') }}
</a> </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>
@@ -90,29 +97,6 @@ function ExitCampaign() {
padding: 5px 10px; padding: 5px 10px;
} }
/* L'enllaç a la documentació és un `<a>` i els botons estan estilats per element, així
que li toca portar el mateix look que els dos que té al costat. */
.docs-button {
padding: 5px 10px;
margin: 5px 0;
font-size: 15px;
border-radius: 6px;
border: solid 1px var(--color-border);
background-color: var(--color-button-background);
color: var(--color-text);
text-align: center;
text-decoration: none;
transition: 300ms background-color;
}
.docs-button:hover {
background-color: var(--color-button-hover);
}
.docs-button:active {
background-color: var(--color-button-active);
}
.top-bar-title { .top-bar-title {
padding: 10px; padding: 10px;
display: flex; display: flex;

View File

@@ -5,6 +5,7 @@ import { ClearWindow, CreateWindow, GetFirstWindowId } from '@/services/Windows'
import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu'; import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu';
import { BuildNoteOptions, OptionLabel, ToImagePoint, ToScreenPoint } from '~/services/MapPins'; import { BuildNoteOptions, OptionLabel, ToImagePoint, ToScreenPoint } from '~/services/MapPins';
import { ActorDragId, CellCentre, IsActorDrag, MoveByCells, TokenSize } from '~/services/MapTokens'; import { ActorDragId, CellCentre, IsActorDrag, MoveByCells, TokenSize } from '~/services/MapTokens';
import { CastLight, SnapToGridVertex, WallAt } from '~/services/MapLighting';
import { DisplayToast } from '~/services/Toaster'; import { DisplayToast } from '~/services/Toaster';
import Server, { getBaseUrl } from '~/services/Server'; import Server, { getBaseUrl } from '~/services/Server';
import { emitter } from '~/services/Emitter'; import { emitter } from '~/services/Emitter';
@@ -29,6 +30,15 @@ const zoom = ref(1);
const pan = ref({ x: 0, y: 0 }); const pan = ref({ x: 0, y: 0 });
const imageSize = ref({ width: 0, height: 0 }); const imageSize = ref({ width: 0, height: 0 });
const showGrid = ref(true); const showGrid = ref(true);
// Lighting over the map: the dark the lights are carved out of. Off by default, so a map reads as the
// picture it is until whoever is running the table asks for the dark.
const showLighting = ref(false);
// Drawing walls instead of panning the map: a wall is dragged from one corner of the grid to another.
const wallMode = ref(false);
// The wall being drawn — the corner it starts at and the one the pointer has reached. It is written
// once, when the pointer lets go, so drawing a wall is not one request per mouse move.
const drawingWall = ref(null);
let wallPointerId = null;
const dragging = ref(false); const dragging = ref(false);
const minZoom = 0.05; const minZoom = 0.05;
@@ -114,6 +124,8 @@ let lastPointer = { x: 0, y: 0 };
function onPointerDown(event) { function onPointerDown(event) {
if (event.button !== 0 || !viewport.value) return; if (event.button !== 0 || !viewport.value) return;
// The wall tool takes the pointer for itself: holding the map then draws a wall instead of moving it.
if (wallMode.value && startWallDrag(event)) return;
dragging.value = true; dragging.value = true;
pointerId = event.pointerId; pointerId = event.pointerId;
lastPointer = { x: event.clientX, y: event.clientY }; lastPointer = { x: event.clientX, y: event.clientY };
@@ -121,12 +133,14 @@ function onPointerDown(event) {
} }
function onPointerMove(event) { function onPointerMove(event) {
if (moveWallDrag(event)) return;
if (!dragging.value || event.pointerId !== pointerId) return; if (!dragging.value || event.pointerId !== pointerId) return;
pan.value = { x: pan.value.x + (event.clientX - lastPointer.x), y: pan.value.y + (event.clientY - lastPointer.y) }; pan.value = { x: pan.value.x + (event.clientX - lastPointer.x), y: pan.value.y + (event.clientY - lastPointer.y) };
lastPointer = { x: event.clientX, y: event.clientY }; lastPointer = { x: event.clientX, y: event.clientY };
} }
function onPointerUp(event) { async function onPointerUp(event) {
if (await endWallDrag(event)) return;
if (event.pointerId !== pointerId) return; if (event.pointerId !== pointerId) return;
dragging.value = false; dragging.value = false;
pointerId = null; pointerId = null;
@@ -195,12 +209,10 @@ function onMapContextMenu(event) {
const spot = ToImagePoint({ x: event.clientX - bounds.left, y: event.clientY - bounds.top }, viewState()); const spot = ToImagePoint({ x: event.clientX - bounds.left, y: event.clientY - bounds.top }, viewState());
if (!spot) return; if (!spot) return;
if (!noteOptions.value.length) { const items = [];
ShowContextMenu([{ name: t('campaigns.map.pins.none'), action: () => HideContextMenu() }]); if (!noteOptions.value.length) items.push({ name: t('campaigns.map.pins.none'), action: () => HideContextMenu() });
return; else {
} items.push({
ShowContextMenu([{
name: t('campaigns.map.pins.add'), name: t('campaigns.map.pins.add'),
icon: '/icons/iconoir/regular/map-pin-plus.svg', icon: '/icons/iconoir/regular/map-pin-plus.svg',
context: noteOptions.value.map((option) => ({ context: noteOptions.value.map((option) => ({
@@ -208,7 +220,26 @@ function onMapContextMenu(event) {
icon: '/icons/iconoir/regular/notes.svg', icon: '/icons/iconoir/regular/notes.svg',
action: () => { HideContextMenu(); savePin(option.value, spot); } action: () => { HideContextMenu(); savePin(option.value, spot); }
})) }))
}]); });
}
items.push({ divider: true });
items.push({
name: t('campaigns.map.lights.add'),
icon: '/icons/iconoir/regular/fire-flame.svg',
action: () => { HideContextMenu(); placeLight(spot); }
});
// A wall is a line, not a marker to hold: right clicking along it is how it is taken off again.
const wall = WallAt(spot, walls.value, WALL_PICK_PX / Math.max(0.05, zoom.value));
if (wall) {
items.push({
name: t('campaigns.map.walls.remove'),
icon: '/icons/iconoir/regular/xmark-circle.svg',
action: () => { HideContextMenu(); removeWall(wall); }
});
}
ShowContextMenu(items);
} }
function onPinContextMenu(pin) { function onPinContextMenu(pin) {
@@ -503,6 +534,328 @@ function handleActorEntry({ entityType, entry }) {
actors.value = [entry, ...actors.value.filter((current) => String(current._id) !== String(entry._id))]; actors.value = [entry, ...actors.value.filter((current) => String(current._id) !== String(entry._id))];
} }
// --- Lights, and the walls that stop them ---
// A light shines from one spot of the image and is as free to place as a pin. The walls of the map are
// what cuts its reach into a shadow: CastLight works out the shape a light paints and the canvas below
// paints that shape out of the dark laid over the map.
// A new light covers this much of the map it is placed on, and half of that is bright light.
const LIGHT_CELLS = 3;
// How near a line a right click has to come to mean that wall, in screen pixels (it is divided by the
// zoom to become image pixels, so picking a wall is as easy zoomed out as zoomed in).
const WALL_PICK_PX = 10;
const lightingCanvas = ref(null);
const lights = computed(() => map.value?.lights ?? []);
const walls = computed(() => map.value?.walls ?? []);
// The light a pointer is holding, and the spot it holds it at: like a token, the move stays local until
// the pointer lets go, so dragging a light across the map is one save and not one per mouse move.
const movingLight = ref(null);
let lightPointerId = null;
// A colour from the theme the canvas paints with. The canvas cannot be styled with `var(--color-…)`
// like a stylesheet, so it asks the document for the same variable the stylesheets use.
function themeColor(name, fallback) {
if (typeof window === 'undefined' || typeof getComputedStyle !== 'function') return fallback;
return getComputedStyle(document.documentElement).getPropertyValue(name).trim() || fallback;
}
// A hex colour with an alpha end ('#ffc46b' + '4d'), because a canvas gradient needs its stops spelled
// out. Anything that is not a plain hex colour is painted as it is.
function withAlpha(color, alpha) {
const value = String(color ?? '').trim();
if (/^#[0-9a-f]{6}$/i.test(value)) return `${value}${alpha}`;
if (/^#[0-9a-f]{3}$/i.test(value)) return `#${value.slice(1)}${value.slice(1)}${alpha}`;
return value;
}
// The light a marker is drawn for: the spot it is being held at while a pointer drags it, and its own
// spot otherwise.
function heldLight(light) {
if (movingLight.value && String(movingLight.value.light?._id) === String(light?._id)) return movingLight.value;
return { x: Number(light?.x) || 0, y: Number(light?.y) || 0 };
}
function lightStyle(light) {
const point = ToScreenPoint(heldLight(light), viewState());
return { left: `${point.x}px`, top: `${point.y}px` };
}
// The reach a light is given when it is placed: enough of the map to matter at the grid it stands on.
function defaultLightReach() {
const cell = Math.max(1, Number(map.value?.gridSize) || 50);
const radius = Math.round(cell * LIGHT_CELLS);
return { radius, bright: Math.round(radius / 2) };
}
async function placeLight(spot) {
const reach = defaultLightReach();
await updateMap('/map/place-light', {
id: map.value?._id, x: spot.x, y: spot.y, ...reach
}, t('campaigns.map.lights.error'));
}
async function removeLight(light) {
await updateMap('/map/remove-light', { id: map.value?._id, light: light?._id }, t('campaigns.map.lights.error'));
}
function onLightPointerDown(event, light) {
// Holding a light moves the light, never the map.
event.stopPropagation();
if (event.button !== 0) return;
lightPointerId = event.pointerId;
event.currentTarget.setPointerCapture?.(event.pointerId);
movingLight.value = { light: { ...light }, x: Number(light.x) || 0, y: Number(light.y) || 0 };
}
function onLightPointerMove(event) {
if (!movingLight.value || event.pointerId !== lightPointerId) return;
const spot = imagePointOf(event);
// Dragged off the image, the light keeps its spot: a light is never lost over the edge.
if (!spot) return;
movingLight.value = { ...movingLight.value, x: spot.x, y: spot.y };
}
async function onLightPointerUp(event) {
if (!movingLight.value || event.pointerId !== lightPointerId) return;
const { light, x, y } = movingLight.value;
lightPointerId = null;
movingLight.value = null;
event.currentTarget?.releasePointerCapture?.(event.pointerId);
if (x === Number(light.x) && y === Number(light.y)) return;
await updateMap('/map/update-light', { id: map.value?._id, light: light._id, x, y }, t('campaigns.map.lights.error'));
}
function onLightContextMenu(light) {
ShowContextMenu([{
name: t('campaigns.map.lights.remove'),
icon: '/icons/iconoir/regular/xmark-circle.svg',
action: () => { HideContextMenu(); removeLight(light); }
}]);
}
// Delete takes a focused light off the map, like it does a focused token.
async function onLightKeydown(event, light) {
if (event.key === 'Delete' || event.key === 'Backspace') {
event.preventDefault();
await removeLight(light);
}
}
// --- Drawing walls ---
// With the wall tool on, the pointer draws instead of panning: it is held down at one corner of the
// grid and let go at another, and the wall between those two corners is what gets saved.
// Holds down the first corner of a wall, or says the wall tool has nothing to hold (off the image).
function startWallDrag(event) {
const spot = imagePointOf(event);
if (!spot) return false;
const corner = SnapToGridVertex(spot, grid.value);
if (!corner) return false;
wallPointerId = event.pointerId;
viewport.value?.setPointerCapture?.(event.pointerId);
drawingWall.value = { x1: corner.x, y1: corner.y, x2: corner.x, y2: corner.y };
return true;
}
function moveWallDrag(event) {
if (!drawingWall.value || event.pointerId !== wallPointerId) return false;
const spot = imagePointOf(event);
// Off the image the wall keeps the end it had: a wall cannot hang outside of the map.
if (!spot) return true;
const corner = SnapToGridVertex(spot, grid.value);
if (!corner) return true;
if (corner.x === drawingWall.value.x2 && corner.y === drawingWall.value.y2) return true;
drawingWall.value = { ...drawingWall.value, x2: corner.x, y2: corner.y };
return true;
}
async function endWallDrag(event) {
if (!drawingWall.value || event.pointerId !== wallPointerId) return false;
const wall = drawingWall.value;
wallPointerId = null;
drawingWall.value = null;
viewport.value?.releasePointerCapture?.(event.pointerId);
// Dragged out and back to the same corner is not a wall: it stops nothing and cannot be picked
// up again, so it is dropped where it was drawn.
if (wall.x1 === wall.x2 && wall.y1 === wall.y2) return true;
await saveWall(wall);
return true;
}
async function saveWall(wall) {
await updateMap('/map/wall', { id: map.value?._id, ...wall }, t('campaigns.map.walls.error'));
}
async function removeWall(wall) {
await updateMap('/map/remove-wall', { id: map.value?._id, wall: wall?._id }, t('campaigns.map.walls.error'));
}
// --- Painting the lights ---
// One canvas over the map, drawn in screen pixels like the pins and the tokens, and repainted whenever
// the view or the map changes. With the lighting on it lays the dark over the image and erases the shape
// of every light out of it, so what is left dark is exactly what its walls hide. With the lighting off
// the same shapes are drawn as thin outlines, which is what makes reaching for a light's size possible
// while it is still being placed.
function imageScreenRect() {
const origin = ToScreenPoint({ x: 0, y: 0 }, viewState());
return {
x: origin.x,
y: origin.y,
width: imageSize.value.width * zoom.value,
height: imageSize.value.height * zoom.value
};
}
function tracePolygon(context, points, view) {
context.beginPath();
points.forEach((point, index) => {
const screen = ToScreenPoint(point, view);
if (index) context.lineTo(screen.x, screen.y);
else context.moveTo(screen.x, screen.y);
});
context.closePath();
}
function paintDarkness(context, image) {
const view = viewState();
context.save();
context.fillStyle = themeColor('--color-map-darkness', '#000000d9');
context.fillRect(image.x, image.y, image.width, image.height);
// The lights erase the dark they stand in: only how much a gradient is transparent matters here, so
// a light fades from fully lit at its middle to nothing at the end of its reach.
context.globalCompositeOperation = 'destination-out';
for (const light of lights.value) {
const shape = CastLight(light, walls.value);
if (!shape.length) continue;
const centre = ToScreenPoint(heldLight(light), view);
const reach = Math.max(1, (Number(light.radius) || 0) * zoom.value);
const core = Math.max(0, Math.min(1, (Number(light.bright) || 0) / (Number(light.radius) || 1)));
context.save();
tracePolygon(context, shape, view);
context.clip();
const gradient = context.createRadialGradient(centre.x, centre.y, 0, centre.x, centre.y, reach);
gradient.addColorStop(0, '#000000ff');
gradient.addColorStop(core, '#000000f5');
gradient.addColorStop(1, '#00000000');
context.fillStyle = gradient;
context.fillRect(image.x, image.y, image.width, image.height);
context.restore();
}
// The tint of a coloured light, laid back over the light it colours: a lantern reads warm and a
// spell cold, and a light with no colour of its own leaves the map as it is.
context.globalCompositeOperation = 'source-over';
for (const light of lights.value) {
if (!light.color) continue;
const shape = CastLight(light, walls.value);
if (!shape.length) continue;
const centre = ToScreenPoint(heldLight(light), view);
const reach = Math.max(1, (Number(light.radius) || 0) * zoom.value);
context.save();
tracePolygon(context, shape, view);
context.clip();
const gradient = context.createRadialGradient(centre.x, centre.y, 0, centre.x, centre.y, reach);
gradient.addColorStop(0, withAlpha(light.color, '33'));
gradient.addColorStop(1, withAlpha(light.color, '00'));
context.fillStyle = gradient;
context.fillRect(image.x, image.y, image.width, image.height);
context.restore();
}
context.restore();
}
function paintLightOutlines(context) {
const view = viewState();
context.save();
context.lineWidth = 1;
for (const light of lights.value) {
const shape = CastLight(light, walls.value);
if (!shape.length) continue;
tracePolygon(context, shape, view);
context.strokeStyle = withAlpha(light.color || '#ffffff', '59');
context.stroke();
}
context.restore();
}
function paintWalls(context) {
if (!walls.value.length && !drawingWall.value) return;
const view = viewState();
context.save();
context.lineCap = 'round';
context.strokeStyle = themeColor('--color-map-wall', '#e06c75');
// The wall tool asks for a firmer line: it is the tool that has to see what it has drawn already.
context.lineWidth = wallMode.value ? 3 : 2;
for (const wall of walls.value) {
const from = ToScreenPoint({ x: Number(wall.x1) || 0, y: Number(wall.y1) || 0 }, view);
const to = ToScreenPoint({ x: Number(wall.x2) || 0, y: Number(wall.y2) || 0 }, view);
context.beginPath();
context.moveTo(from.x, from.y);
context.lineTo(to.x, to.y);
context.stroke();
}
// The wall being drawn, along the grid corners the pointer has reached so far.
if (drawingWall.value) {
context.setLineDash([6, 4]);
const from = ToScreenPoint({ x: drawingWall.value.x1, y: drawingWall.value.y1 }, view);
const to = ToScreenPoint({ x: drawingWall.value.x2, y: drawingWall.value.y2 }, view);
context.beginPath();
context.moveTo(from.x, from.y);
context.lineTo(to.x, to.y);
context.stroke();
}
context.restore();
}
function drawLighting() {
const canvas = lightingCanvas.value;
const bounds = viewport.value?.getBoundingClientRect();
if (!canvas || !bounds) return;
const width = Math.max(1, Math.round(bounds.width));
const height = Math.max(1, Math.round(bounds.height));
if (canvas.width !== width) canvas.width = width;
if (canvas.height !== height) canvas.height = height;
const context = canvas.getContext?.('2d');
if (!context) return;
context.clearRect(0, 0, width, height);
if (!imageUrl.value) return;
if (showLighting.value) paintDarkness(context, imageScreenRect());
else paintLightOutlines(context);
paintWalls(context);
}
// Every move of the view, and every light or wall that changes, is painted again.
watch(
[zoom, pan, imageSize, showLighting, wallMode, drawingWall, lights, walls, imageUrl],
() => nextTick(drawLighting),
{ deep: true }
);
onMounted(() => {
window.addEventListener('resize', drawLighting);
nextTick(drawLighting);
});
onBeforeUnmount(() => {
window.removeEventListener('resize', drawLighting);
});
// A different map was anchored while this pane was already mounted. // A different map was anchored while this pane was already mounted.
watch(() => props.map, (incoming, previous) => { watch(() => props.map, (incoming, previous) => {
if (incoming === previous) return; if (incoming === previous) return;
@@ -510,6 +863,9 @@ watch(() => props.map, (incoming, previous) => {
imageSize.value = { width: 0, height: 0 }; imageSize.value = { width: 0, height: 0 };
movingToken.value = null; movingToken.value = null;
draggingActor.value = false; draggingActor.value = false;
movingLight.value = null;
drawingWall.value = null;
wallPointerId = null;
}); });
watch(campaignId, () => { watch(campaignId, () => {
@@ -550,6 +906,14 @@ onBeforeUnmount(() => {
:aria-label="$t('campaigns.map.toggle-grid')" :aria-pressed="showGrid.toString()" @click="showGrid = !showGrid"> :aria-label="$t('campaigns.map.toggle-grid')" :aria-pressed="showGrid.toString()" @click="showGrid = !showGrid">
<img class="tool-icon" src="/icons/iconoir/regular/view-grid.svg" alt="" aria-hidden="true"> <img class="tool-icon" src="/icons/iconoir/regular/view-grid.svg" alt="" aria-hidden="true">
</button> </button>
<button class="viewer-tool" :class="{ selected: showLighting }" type="button" :title="$t('campaigns.map.toggle-lighting')"
:aria-label="$t('campaigns.map.toggle-lighting')" :aria-pressed="showLighting.toString()" @click="showLighting = !showLighting">
<img class="tool-icon" src="/icons/iconoir/regular/light-bulb-on.svg" alt="" aria-hidden="true">
</button>
<button class="viewer-tool" :class="{ selected: wallMode }" type="button" :title="$t('campaigns.map.toggle-walls')"
:aria-label="$t('campaigns.map.toggle-walls')" :aria-pressed="wallMode.toString()" @click="wallMode = !wallMode">
<img class="tool-icon" src="/icons/iconoir/regular/linear.svg" alt="" aria-hidden="true">
</button>
<button class="viewer-tool" type="button" :title="$t('campaigns.map.zoom-out')" :aria-label="$t('campaigns.map.zoom-out')" @click="zoomFromToolbar(false)"> <button class="viewer-tool" type="button" :title="$t('campaigns.map.zoom-out')" :aria-label="$t('campaigns.map.zoom-out')" @click="zoomFromToolbar(false)">
<img class="tool-icon" src="/icons/iconoir/regular/minus.svg" alt="" aria-hidden="true"> <img class="tool-icon" src="/icons/iconoir/regular/minus.svg" alt="" aria-hidden="true">
</button> </button>
@@ -573,7 +937,7 @@ onBeforeUnmount(() => {
<div <div
ref="viewport" ref="viewport"
class="map-viewport" class="map-viewport"
:class="{ dragging }" :class="{ dragging, 'wall-mode': wallMode }"
@wheel.prevent="onWheel" @wheel.prevent="onWheel"
@pointerdown="onPointerDown" @pointerdown="onPointerDown"
@pointermove="onPointerMove" @pointermove="onPointerMove"
@@ -587,6 +951,28 @@ onBeforeUnmount(() => {
<template v-if="imageUrl"> <template v-if="imageUrl">
<img class="map-image" :src="imageUrl" :style="stageStyle" :alt="map?.name" draggable="false" @load="onImageLoaded"> <img class="map-image" :src="imageUrl" :style="stageStyle" :alt="map?.name" draggable="false" @load="onImageLoaded">
<div class="map-grid" :style="gridStyle" aria-hidden="true"></div> <div class="map-grid" :style="gridStyle" aria-hidden="true"></div>
<canvas ref="lightingCanvas" class="map-lighting" aria-hidden="true"></canvas>
<div class="map-lights">
<button
v-for="light in lights"
:key="light._id"
class="map-light"
:class="{ moving: movingLight && String(movingLight.light?._id) === String(light._id) }"
type="button"
:style="lightStyle(light)"
:title="$t('campaigns.map.lights.light')"
:aria-label="$t('campaigns.map.lights.light')"
draggable="false"
@pointerdown="onLightPointerDown($event, light)"
@pointermove="onLightPointerMove"
@pointerup="onLightPointerUp"
@pointercancel="onLightPointerUp"
@contextmenu.stop.prevent="onLightContextMenu(light)"
@keydown="onLightKeydown($event, light)"
>
<img class="light-icon" src="/icons/iconoir/regular/fire-flame.svg" alt="" aria-hidden="true">
</button>
</div>
<div class="map-pins"> <div class="map-pins">
<button <button
v-for="pin in pins" v-for="pin in pins"
@@ -629,6 +1015,7 @@ onBeforeUnmount(() => {
</button> </button>
</div> </div>
<div v-if="draggingActor" class="map-drop-hint">{{ $t('campaigns.map.tokens.drop-hint') }}</div> <div v-if="draggingActor" class="map-drop-hint">{{ $t('campaigns.map.tokens.drop-hint') }}</div>
<div v-if="wallMode" class="map-drop-hint">{{ $t('campaigns.map.walls.hint') }}</div>
</template> </template>
<div v-else class="map-empty"> <div v-else class="map-empty">
{{ $t('campaigns.map.no-image') }} {{ $t('campaigns.map.no-image') }}
@@ -654,6 +1041,23 @@ onBeforeUnmount(() => {
.map-viewport.dragging { cursor: grabbing; } .map-viewport.dragging { cursor: grabbing; }
.map-image { position: absolute; top: 0; left: 0; max-width: none; transform-origin: top left; user-select: none; } .map-image { position: absolute; top: 0; left: 0; max-width: none; transform-origin: top left; user-select: none; }
.map-grid { position: absolute; top: 0; left: 0; opacity: .55; pointer-events: none; } .map-grid { position: absolute; top: 0; left: 0; opacity: .55; pointer-events: none; }
.map-viewport.wall-mode { cursor: crosshair; }
/* The lights are painted on a canvas over the image and in screen space, like the pins: the dark over
the map and the shape each light cuts in it are redrawn whenever the view moves (see drawLighting).
The canvas never catches the mouse; the light markers below do that. */
.map-lighting { position: absolute; top: 0; left: 0; pointer-events: none; }
.map-lights { position: absolute; inset: 0; pointer-events: none; }
.map-light {
position: absolute; transform: translate(-50%, -50%); pointer-events: auto;
display: flex; align-items: center; justify-content: center; width: 26px; height: 26px;
margin: 0; padding: 0; border: 1px solid var(--color-link); border-radius: 50%;
background: var(--color-background-soft); color: var(--color-text);
cursor: grab; user-select: none; box-shadow: 0px 0px 6px -1px rgba(0,0,0,0.55);
}
.map-light:hover { background: var(--color-button-hover); }
.map-light:focus-visible { outline: 1px solid var(--color-link); outline-offset: 2px; }
.map-light.moving { cursor: grabbing; }
.light-icon { width: 14px; height: 14px; filter: invert(var(--color-icon-invert)); }
/* Pins live in image pixels but are drawn in screen space (see ToScreenPoint), so the overlay stays /* Pins live in image pixels but are drawn in screen space (see ToScreenPoint), so the overlay stays
unscaled and their markers are readable at every zoom. Only the markers catch the mouse. */ unscaled and their markers are readable at every zoom. Only the markers catch the mouse. */
.map-pins { position: absolute; inset: 0; pointer-events: none; } .map-pins { position: absolute; inset: 0; pointer-events: none; }

View File

@@ -124,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;
@@ -302,88 +301,8 @@ 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) {
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 :deep(h3) {
margin: 22px 0 8px 0;
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);
}
/* Finestra molt ampla: tot el conjunt va al mig, així els apartats queden a prop del /* Finestra molt ampla: tot el conjunt va al mig, així els apartats queden a prop del
text en lloc d'estirats cap al cantó dret de la pantalla. */ text en lloc d'estirats cap al cantó dret de la pantalla. */

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,6 +390,7 @@ async function saveSheet() {
</section> </section>
</div> </div>
<main v-show="activeTab === 'abilities'" class="sheet-tab-body">
<section class="sheet-panel abilities-panel"> <section class="sheet-panel abilities-panel">
<h2>{{ $t('campaigns.character-sheet.ability-scores') }}</h2> <h2>{{ $t('campaigns.character-sheet.ability-scores') }}</h2>
<div class="ability-grid"> <div class="ability-grid">
@@ -529,6 +533,7 @@ async function saveSheet() {
</main> </main>
</div> </div>
</div> </div>
</div>
</template> </template>
<style scoped> <style scoped>
@@ -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

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

View File

@@ -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

@@ -99,6 +99,7 @@
"save-error": "No s'ha pogut desar aquest mapa.", "save-error": "No s'ha pogut desar aquest mapa.",
"no-image": "Aquest mapa encara no té imatge.", "no-image": "Aquest mapa encara no té imatge.",
"zoom-in": "Apropar", "zoom-out": "Allunyar", "fit": "Ajustar a la finestra", "toggle-grid": "Mostrar la quadrícula", "zoom-in": "Apropar", "zoom-out": "Allunyar", "fit": "Ajustar a la finestra", "toggle-grid": "Mostrar la quadrícula",
"toggle-lighting": "Mostrar la il·luminació", "toggle-walls": "Dibuixar murs",
"open-window": "Obre en una finestra", "anchored": "Ancorat", "open-window": "Obre en una finestra", "anchored": "Ancorat",
"pins": { "pins": {
"add": "Fixa una nota aquí", "none": "Encara no hi ha notes per fixar", "add": "Fixa una nota aquí", "none": "Encara no hi ha notes per fixar",
@@ -111,6 +112,15 @@
"drop-hint": "Deixa anar per posar l'actor en aquest mapa", "drop-hint": "Deixa anar per posar l'actor en aquest mapa",
"open": "Obre la fitxa de personatge", "remove": "Treu la fitxa", "open": "Obre la fitxa de personatge", "remove": "Treu la fitxa",
"error": "No s'han pogut canviar les fitxes d'aquest mapa." "error": "No s'han pogut canviar les fitxes d'aquest mapa."
},
"lights": {
"light": "Llum", "add": "Afegeix una llum aquí", "remove": "Treu la llum",
"error": "No s'han pogut canviar les llums d'aquest mapa."
},
"walls": {
"remove": "Treu el mur d'aquí",
"hint": "Arrossega d'una cantonada de la quadrícula a l'altra per dibuixar un mur",
"error": "No s'han pogut canviar els murs d'aquest mapa."
} }
}, },
"character-sheet": { "character-sheet": {

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

@@ -103,6 +103,7 @@
"save-error": "Unable to save this map.", "save-error": "Unable to save this map.",
"no-image": "This map has no image yet.", "no-image": "This map has no image yet.",
"zoom-in": "Zoom in", "zoom-out": "Zoom out", "fit": "Fit to window", "toggle-grid": "Show grid", "zoom-in": "Zoom in", "zoom-out": "Zoom out", "fit": "Fit to window", "toggle-grid": "Show grid",
"toggle-lighting": "Show lighting", "toggle-walls": "Draw walls",
"open-window": "Open in window", "anchored": "Anchored", "open-window": "Open in window", "anchored": "Anchored",
"pins": { "pins": {
"add": "Pin a note here", "none": "No notes to pin yet", "add": "Pin a note here", "none": "No notes to pin yet",
@@ -115,6 +116,15 @@
"drop-hint": "Drop to place the actor on this map", "drop-hint": "Drop to place the actor on this map",
"open": "Open character sheet", "remove": "Remove token", "open": "Open character sheet", "remove": "Remove token",
"error": "Unable to change the tokens of this map." "error": "Unable to change the tokens of this map."
},
"lights": {
"light": "Light", "add": "Add light here", "remove": "Remove light",
"error": "Unable to change the lights of this map."
},
"walls": {
"remove": "Remove wall here",
"hint": "Drag from one corner of the grid to another to draw a wall",
"error": "Unable to change the walls of this map."
} }
}, },
"character-sheet": { "character-sheet": {

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

@@ -99,6 +99,7 @@
"save-error": "No se pudo guardar este mapa.", "save-error": "No se pudo guardar este mapa.",
"no-image": "Este mapa aún no tiene imagen.", "no-image": "Este mapa aún no tiene imagen.",
"zoom-in": "Acercar", "zoom-out": "Alejar", "fit": "Ajustar a la ventana", "toggle-grid": "Mostrar cuadrícula", "zoom-in": "Acercar", "zoom-out": "Alejar", "fit": "Ajustar a la ventana", "toggle-grid": "Mostrar cuadrícula",
"toggle-lighting": "Mostrar iluminación", "toggle-walls": "Dibujar muros",
"open-window": "Abrir en una ventana", "anchored": "Anclado", "open-window": "Abrir en una ventana", "anchored": "Anclado",
"pins": { "pins": {
"add": "Fija una nota aquí", "none": "Aún no hay notas que fijar", "add": "Fija una nota aquí", "none": "Aún no hay notas que fijar",
@@ -111,6 +112,15 @@
"drop-hint": "Suelta para colocar al actor en este mapa", "drop-hint": "Suelta para colocar al actor en este mapa",
"open": "Abrir hoja de personaje", "remove": "Quitar la ficha", "open": "Abrir hoja de personaje", "remove": "Quitar la ficha",
"error": "No se pudieron cambiar las fichas de este mapa." "error": "No se pudieron cambiar las fichas de este mapa."
},
"lights": {
"light": "Luz", "add": "Añadir luz aquí", "remove": "Quitar la luz",
"error": "No se pudieron cambiar las luces de este mapa."
},
"walls": {
"remove": "Quitar el muro de aquí",
"hint": "Arrastra de una esquina de la cuadrícula a otra para dibujar un muro",
"error": "No se pudieron cambiar los muros de este mapa."
} }
}, },
"character-sheet": { "character-sheet": {

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)),
};
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"));
// The Map model is only there for the scene lighting sync, which these tests do not run.
if (id === "../models/Map") return { find: () => mongooseQuery([]), findOne: async () => null };
if (models[id]) return models[id];
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
@@ -328,39 +330,89 @@ test("the main menu points at the documentation", () => {
}); });
// Inside a campaign the documentation is reached from the top bar, on the left of the campaign // Inside a campaign the documentation is reached from the top bar, on the left of the campaign
// settings button (Syndria98/dragonroll#90). // settings button (Syndria98/dragonroll#90), and it opens as a window of its own in front of the
test("the campaign top bar points at the documentation", () => { // 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 topBar = readRepoFile("frontend", "app", "components", "viewer", "TopBar.vue");
const right = /<div class="right">([\s\S]*?)<\/div>/.exec(topBar)?.[1]; 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.ok(right, "expected the top bar to have its buttons in a right-hand group");
assert.match(right, /href="\/docs"/, "the top bar has to link to /docs"); 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(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 link has to // To the left of the settings button: the group is read left to right, so the button has to
// come first in it. // come first in it.
const docsAt = right.indexOf('href="/docs"'); const docsAt = right.indexOf("OpenDocumentation");
const settingsAt = right.indexOf("OpenCampaignSettings"); const settingsAt = right.indexOf("OpenCampaignSettings");
assert.ok( assert.ok(
docsAt !== -1 && settingsAt !== -1 && docsAt < settingsAt, docsAt !== -1 && settingsAt !== -1 && docsAt < settingsAt,
"the documentation button sits on the left of the settings button" "the documentation button sits on the left of the settings button"
); );
// /docs is another page, and the open notes of the campaign live only in memory, so the link // The open notes of the campaign live only in memory, so nothing the top bar does may leave
// opens it somewhere that does not throw the campaign away. // the app: a window comes to the front, an address would take the campaign away with it.
assert.match(right, /target="_blank"/, "the campaign stays as it was behind the documentation"); assert.doesNotMatch(topBar, /href="\/docs"/, "the top bar does not send the campaign to /docs");
assert.match(right, /rel="[^"]*noopener/, "a tab the app does not control must not be able to reach it"); assert.doesNotMatch(topBar, /target="_blank"/, "…nor opens a tab out of it");
});
// The link is an `<a>` and the buttons are styled by element, so it carries its own look, in // The window the button opens (Syndria98/dragonroll#95): registered like every other window, and
// theme colours like everything else. // reading its pages without ever leaving the window it is drawn in.
const look = /\.docs-button\s*\{[^}]*\}/.exec(topBar)?.[0]; test("the documentation is registered as a window", () => {
assert.ok(look, "the documentation link has to look like the buttons next to it"); const definitions = readRepoFile("frontend", "app", "services", "WindowDefinitions.js");
for (const declaration of [ const definition = /\n\s*documentation:\s*\{([\s\S]*?)\n\s{2}\}/.exec(definitions);
"background-color: var\\(--color-button-background\\)", assert.ok(definition, "the documentation is not registered as a window");
"color: var\\(--color-text\\)",
"border: solid 1px var\\(--color-border\\)", assert.match(definition[1], /title:\s*'windows\.documentation'/, "its title is an i18n key");
]) { assert.match(definition[1], /movable:\s*true/);
assert.match(look, new RegExp(declaration), "the link's look uses the theme's colours"); 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`);
}
} }
}); });
@@ -484,3 +536,29 @@ test("the sections aside has more room around its links than the sidebar has", (
"the sections aside asks for more padding than the two asides share" "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

@@ -280,6 +280,9 @@ 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"));
// The Map model is only there for the scene lighting sync, which these tests do not run.
if (id === "../models/Map") return { find: () => mongooseQuery([]), findOne: async () => null };
if (models[id]) return models[id]; if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`); throw new Error(`require("${id}") is not stubbed`);
}; };

View File

@@ -141,6 +141,9 @@ 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"));
// The Map model is only there for the scene lighting sync, which these tests do not run.
if (id === "../models/Map") return { find: () => mongooseQuery([]), findOne: async () => null };
if (models[id]) return models[id]; if (models[id]) return models[id];
throw new Error(`require("${id}") is not stubbed`); throw new Error(`require("${id}") is not stubbed`);
}; };