49 Commits

Author SHA1 Message Date
Gitea OpenCode Agent
3c3df58d8d Fix issue #100: Add walls to maps
Some checks failed
Test / test (push) Failing after 2s
2026-10-16 00:59:56 +00:00
c9ee16f2f2 Merge pull request 'Fix #95: Make documentation a resizable window' (#97) from ai/issue-95 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 54s
Reviewed-on: #97
2026-10-15 22:40:25 +00:00
Gitea OpenCode Agent
abcec4d2ff Fix issue #95: Make documentation a resizable window
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 22:33:31 +00:00
dcc6d7a14b kdsklkdsl
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m3s
2026-10-16 00:02:51 +02:00
227fff1351 Merge pull request 'Fix #90: Add a docs button' (#93) from ai/issue-90 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #93
2026-10-15 22:02:07 +00:00
a64fe499e9 Merge branch 'master' into ai/issue-90
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 22:02:01 +00:00
b75ee05276 Merge pull request 'Fix #91: Make character column always visible' (#94) from ai/issue-91 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #94
2026-10-15 22:01:54 +00:00
bc7231a1da Merge branch 'master' into ai/issue-91
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 22:01:49 +00:00
252ae2d6b2 Merge pull request 'Fix #89: Traits and items are mixed up' (#92) from ai/issue-89 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #92
2026-10-15 22:01:34 +00:00
Gitea OpenCode Agent
30e23b643c Fix issue #91: Make character column always visible
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 21:56:49 +00:00
Gitea OpenCode Agent
8376acfc6b Fix issue #90: Add a docs button
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 21:42:03 +00:00
Gitea OpenCode Agent
f8dae95563 Fix issue #89: Traits and items are mixed up
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 21:36:44 +00:00
98aa3be078 Merge pull request 'Fix #85: Style corrections on /docs' (#88) from ai/issue-85 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m5s
Reviewed-on: #88
2026-10-15 20:56:27 +00:00
80c6b1b62f Merge branch 'master' into ai/issue-85
All checks were successful
Test / test (push) Successful in 1s
2026-10-15 20:56:19 +00:00
2cce19e032 Merge pull request 'Fix #84: Double click token' (#87) from ai/issue-84 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #87
2026-10-15 20:56:13 +00:00
abacfeca40 Merge branch 'master' into ai/issue-84
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 20:56:08 +00:00
f925881a54 Merge pull request 'Fix #83: Add more things to the character sheet' (#86) from ai/issue-83 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #86
2026-10-15 20:55:58 +00:00
Gitea OpenCode Agent
9aad484fe9 Fix issue #85: Style corrections on /docs
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 20:55:08 +00:00
Gitea OpenCode Agent
5ee7353123 Fix issue #84: Double click token
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 20:44:53 +00:00
Gitea OpenCode Agent
f0ffa2f72b Fix issue #83: Add more things to the character sheet
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 20:40:05 +00:00
2c1cc970e6 Merge pull request 'Fix #79: Implement documentation' (#81) from ai/issue-79 into master
All checks were successful
Test / test (push) Successful in 7s
Build and Deploy Nuxt / build (push) Successful in 1m4s
Reviewed-on: #81
2026-10-15 19:31:43 +00:00
72596c3d15 Merge branch 'master' into ai/issue-79
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 19:31:37 +00:00
d9d80c4eee Merge pull request 'Fix #77: Add a "force import from foundry" context button' (#80) from ai/issue-77 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #80
2026-10-15 19:31:33 +00:00
4eda4a9d21 Merge branch 'master' into ai/issue-77
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 19:31:26 +00:00
b64d1e3089 Merge pull request 'Fix #74: Foundry's icons are not available: its bridge is not set up, or it cannot be reached right now.' (#82) from ai/issue-74 into master
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
Reviewed-on: #82
2026-10-15 19:31:20 +00:00
fefb1eba6e Merge branch 'master' into ai/issue-74
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 19:31:14 +00:00
Gitea OpenCode Agent
06144e1623 Fix issue #74: Foundry's icons are not available: its bridge is not set up, or it cannot be reached right now.
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 19:24:18 +00:00
Gitea OpenCode Agent
788f69efd3 Fix issue #79: Implement documentation
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 19:07:09 +00:00
Gitea OpenCode Agent
f928f13544 Fix issue #77: Add a "force import from foundry" context button
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 18:16:47 +00:00
a8a1e0ca41 Merge pull request 'Fix #72: Link actor with a discord user' (#78) from ai/issue-72 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m10s
Reviewed-on: #78
2026-10-15 17:08:10 +00:00
fa82c933d6 Merge branch 'master' into ai/issue-72
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 17:08:02 +00:00
Gitea OpenCode Agent
299380d143 Fix issue #72: Link actor with a discord user
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 17:06:25 +00:00
6df7d57376 Merge pull request 'Fix #71: Nuxt error with colors' (#76) from ai/issue-71 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 51s
Reviewed-on: #76
2026-10-15 16:45:44 +00:00
a8047e2814 Merge branch 'master' into ai/issue-71
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 16:45:39 +00:00
Gitea OpenCode Agent
37e6e44612 Fix issue #71: Nuxt error with colors
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 16:44:08 +00:00
b0cc98a452 Merge pull request 'Fix #67: Don't show all items on the items sidebar' (#75) from ai/issue-67 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m27s
Reviewed-on: #75
2026-10-15 16:40:39 +00:00
d35216c859 Merge branch 'master' into ai/issue-67
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 16:40:30 +00:00
Gitea OpenCode Agent
495e528124 Fix issue #67: Don't show all items on the items sidebar
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 16:40:15 +00:00
Gitea OpenCode Agent
dd4c9535d3 Fix issue #65: Item selecting icon
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m7s
2026-10-15 18:08:27 +02:00
0caacf434f Merge pull request 'Fix #64: More modifications to the character sheet' (#70) from ai/issue-64 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 1m5s
Reviewed-on: #70
2026-10-15 15:19:53 +00:00
d779d939f9 Merge branch 'master' into ai/issue-64
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 15:19:46 +00:00
eeaab7a910 Merge pull request 'Fix #63: Item modifications' (#69) from ai/issue-63 into master
All checks were successful
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Successful in 51s
Reviewed-on: #69
2026-10-15 15:17:41 +00:00
f9caff3100 Merge branch 'master' into ai/issue-63
All checks were successful
Test / test (push) Successful in 2s
2026-10-15 15:17:34 +00:00
Gitea OpenCode Agent
0567096588 Fix issue #61: Fix tests
Some checks failed
Test / test (push) Successful in 2s
Build and Deploy Nuxt / build (push) Has been cancelled
2026-10-15 17:16:48 +02:00
Gitea OpenCode Agent
8418b5c254 Fix issue #64: More modifications to the character sheet
Some checks failed
Test / test (push) Failing after 2s
2026-10-15 15:01:35 +00:00
Gitea OpenCode Agent
09e9010729 Fix issue #63: Item modifications
Some checks failed
Test / test (push) Failing after 2s
2026-10-15 14:31:00 +00:00
cdafd1f53a Merge pull request 'Fix #57: Sync foundry folder colors' (#66) from ai/issue-57 into master
Some checks failed
Test / test (push) Failing after 2s
Build and Deploy Nuxt / build (push) Successful in 1m6s
Reviewed-on: #66
2026-10-15 14:00:08 +00:00
2e2fb97e5d Merge branch 'master' into ai/issue-57
Some checks failed
Test / test (push) Failing after 2s
2026-10-15 14:00:02 +00:00
Gitea OpenCode Agent
d03cc1eb59 Fix issue #57: Sync foundry folder colors
Some checks failed
Test / test (push) Failing after 2s
2026-10-15 13:58:42 +00:00
81 changed files with 8593 additions and 403 deletions

View File

@@ -10,11 +10,11 @@ Free/open-source helper for tabletop RPG campaigns (campaigns, markdown notes, f
items, maps, dice widgets, sounds). items, maps, dice widgets, sounds).
- `backend/` — Node + **Express 5** + **Mongoose 9** (MongoDB) REST API, JWT auth, CommonJS, entry `src/index.js`. - `backend/` — Node + **Express 5** + **Mongoose 9** (MongoDB) REST API, JWT auth, CommonJS, entry `src/index.js`.
- `frontend/` — **Nuxt 4 / Vue 3** (`<script setup>`), SCSS, axios, marked, mitt, motion, entry `app/app.vue`. No routed pages (§5.1). - `frontend/` — **Nuxt 4 / Vue 3** (`<script setup>`), SCSS, axios, marked, mitt, motion, entry `app/app.vue`. Two pages: the app and `/docs` (§5.1).
- `discord-bot/` — Discord bot (slash commands) that talks to the backend with a shared service secret, no login. - `discord-bot/` — Discord bot (slash commands) that talks to the backend with a shared service secret, no login.
- `dragonroll-foundry/` — Foundry VTT module (`scripts/api.js`) + optional read-only snapshot bridge. - `dragonroll-foundry/` — Foundry VTT module (`scripts/api.js`) + optional read-only snapshot bridge.
- `obsidian-plugin/` — plain JavaScript Obsidian plugin that imports/pushes campaign notes. - `obsidian-plugin/` — plain JavaScript Obsidian plugin that imports/pushes campaign notes.
- `tests/` — `npm test` (`node --test`, no dependencies installed): Foundry sync toggle and pairing status, map pins and tokens, sidebar entries. - `tests/` — `npm test` (`node --test`, no dependencies installed): Foundry sync toggle and pairing status, map pins and tokens, sidebar entries, the `/docs` pages.
No DB seeding, no migrations, no linter/formatter, no Pinia/Vuex. Git: default branch `master` on a No DB seeding, no migrations, no linter/formatter, no Pinia/Vuex. Git: default branch `master` on a
self-hosted Gitea; `.gitea/workflows/deploy.yml` builds and deploys Docker images on push to `master`, self-hosted Gitea; `.gitea/workflows/deploy.yml` builds and deploys Docker images on push to `master`,
@@ -85,7 +85,7 @@ campaign, and handlers check ownership with a `userOwnsCampaign(campaignId, user
- `Campaign` — `name*`, `createdBy*`→User, `description`, `color`, `settings`, `foundryWorldId`/`foundryWorldTitle`/`foundrySystem`, `foundrySyncTokenHash` (`select: false`), `discordGuildId` - `Campaign` — `name*`, `createdBy*`→User, `description`, `color`, `settings`, `foundryWorldId`/`foundryWorldTitle`/`foundrySystem`, `foundrySyncTokenHash` (`select: false`), `discordGuildId`
- `Note` — `title`, `content` (markdown source), `campaign*`, `folder` (null = root), `color` - `Note` — `title`, `content` (markdown source), `campaign*`, `folder` (null = root), `color`
- `Folder` — `name*`, `campaign*`, `parentFolder` (null = root, self-ref), `color` - `Folder` — `name*`, `campaign*`, `parentFolder` (null = root, self-ref), `color`
- `Actor` — `name*`, `campaign*`, `foundryActorId` (unique per campaign), plus free-form sheet fields (`type`, `species`, `className`, `level`, `abilityScores`, `armorClass`, `speed`, `proficiencies`, `traits`, `spells`, `image`) and `inventory[{name,quantity,weight}]` (flattened Foundry items, **not** `Item` docs) - `Actor` — `name*`, `campaign*`, `foundryActorId` (unique per campaign), `discordUserId` (the Discord player holding the character, unique per campaign — set only by `routes/discord.js`), plus free-form sheet fields (`type`, `species`, `className`, `level`, `abilityScores`, `armorClass`, `speed`, `proficiencies`, `traits`, `spells`, `image`) and `inventory[{name,quantity,weight}]` (flattened Foundry items, **not** `Item` docs)
- `Item` — `name*`, `campaign*`, `foundryItemId` (unique per campaign), `foundryNames`, `category`, `rarity`, `quantity`, `weight`, `properties`, `description` - `Item` — `name*`, `campaign*`, `foundryItemId` (unique per campaign), `foundryNames`, `category`, `rarity`, `quantity`, `weight`, `properties`, `description`
- `Map` — `name*`, `campaign*`, `image` (filename in `src/uploads`), `gridSize`/`offsetX`/`offsetY`/`scale` (image px), `pins[{note→Note, x, y}]` (addressed by the pin's own `_id`), `tokens[{actor→Actor, x, y}]` (the centre of the grid cell the token stands in, also addressed by its own `_id`) - `Map` — `name*`, `campaign*`, `image` (filename in `src/uploads`), `gridSize`/`offsetX`/`offsetY`/`scale` (image px), `pins[{note→Note, x, y}]` (addressed by the pin's own `_id`), `tokens[{actor→Actor, x, y}]` (the centre of the grid cell the token stands in, also addressed by its own `_id`)
- `ServiceLinkRequest` — the pending/completed service pairings of §4; `DiscordGuildLink` maps a Discord guild to the Dragonroll user who claimed it - `ServiceLinkRequest` — the pending/completed service pairings of §4; `DiscordGuildLink` maps a Discord guild to the Dragonroll user who claimed it
@@ -99,7 +99,7 @@ campaign, and handlers check ownership with a `userOwnsCampaign(campaignId, user
- `actor` — `list`, `create`, `update` (partial, ownership checked), `upload-image?actor=` (multipart), `delete` - `actor` — `list`, `create`, `update` (partial, ownership checked), `upload-image?actor=` (multipart), `delete`
- `item` — `list`, `create`, `update` (partial), `delete` - `item` — `list`, `create`, `update` (partial), `delete`
- `map` — `list`, `create` (multipart `image` or JSON), `update` (multipart to replace the photo), `delete`, `pin` (`{id,note,x,y}`, re-pinning moves the marker), `unpin` (`{id,pin}`), `place-token` (`{id,actor,x,y}`, snapped to a cell centre, re-placing moves the token), `remove-token` (`{id,token}`) - `map` — `list`, `create` (multipart `image` or JSON), `update` (multipart to replace the photo), `delete`, `pin` (`{id,note,x,y}`, re-pinning moves the marker), `unpin` (`{id,pin}`), `place-token` (`{id,actor,x,y}`, snapped to a cell centre, re-placing moves the token), `remove-token` (`{id,token}`)
- `foundry` — read-only proxy over the bridge (`/world`, `/actors`, `/characters`, `/items`, `/actors/:id`, `/items/:id`, `/actors/:id/items`), needs `FOUNDRY_API_URL` - `foundry` — read-only proxy over the bridge (`/world`, `/actors`, `/characters`, `/items`, `/actors/:id`, `/items/:id`, `/actors/:id/items`), needs `FOUNDRY_API_URL`; `POST /import` (`{campaign, kind: 'actors'|'items'}`, the sidebar's "force import from Foundry") pulls that world's whole list off the bridge through the sync's writers, so rows the campaign already has are written over, and answers `{imported, updated}`; `/icons?campaign=&dir=&offset=` lists one folder of the world's core `icons/` library (the bridge reads it from `DRAGONROLL_FOUNDRY_DATA_PATH`) and answers `{dir, parent, folders, files[{path,name,url}], next}`, the icons paged so the library stays lazy to load
## 4. Service integrations (Foundry, Discord, Obsidian) ## 4. Service integrations (Foundry, Discord, Obsidian)
@@ -117,20 +117,35 @@ the JWT guard; CORS opened for it): `snapshot` (actors + world items, `fullSync`
`item-snapshot`, `item-delete`, `characters`, `items`, `status`, `map` / `map-item`, `delete`. Rules: `item-snapshot`, `item-delete`, `characters`, `items`, `status`, `map` / `map-item`, `delete`. Rules:
- **Identity** is `foundryActorId` / `foundryItemId` (unique per campaign, partial index); a Foundry document carrying the `dragonroll-foundry.actorId` / `.itemId` flag adopts the matching Dragonroll row. - **Identity** is `foundryActorId` / `foundryItemId` (unique per campaign, partial index); a Foundry document carrying the `dragonroll-foundry.actorId` / `.itemId` flag adopts the matching Dragonroll row.
- **Items are deduplicated by name** — Foundry keeps the same gear once per carrier, so one `Item` per name; `foundryNames` keeps Foundry's names so a Dragonroll rename does not resurrect a duplicate. `services/item-foundry.js` returns `null` for non-gear types and those are skipped. - **Only the world's item directory reaches the item list** (Syndria98/dragonroll#67) — `snapshotItemSources` reads `body.items` (`game.items`) alone; gear embedded in a character is that actor's `inventory` (see the `Actor` model), not an `Item`. A world item still folds into a hand-made or renamed row it matches by name (`foundryNames`), so a rename does not resurrect a duplicate. `services/item-foundry.js` returns `null` for non-gear types and those are skipped.
- **Item folders mirror the world's item directory** (`Folder.foundryFolderId`, target `item`): every push carries the whole tree and the world owns its names and nesting. `color` is the one field the campaign sets too, so it travels back with the folders `GET /foundry/sync/items` answers with (`{items, folders}`) and the module writes it onto the world's folder.
- **`fullSync` preserves Dragonroll edits** (only new rows are overwritten); live Foundry events overwrite. Only a full snapshot can prune. - **`fullSync` preserves Dragonroll edits** (only new rows are overwritten); live Foundry events overwrite. Only a full snapshot can prune.
- **Autosync is a Foundry-side setting** (`autoSync`, on by default): off = no CRUD push, no periodic reconcile, no startup snapshot; the actor directory's *Dragonroll: Force Sync* still upserts the selection (`fullSync:false`). - **Autosync is a Foundry-side setting** (`autoSync`, on by default): off = no CRUD push, no periodic reconcile, no startup snapshot; the actor directory's *Dragonroll: Force Sync* still upserts the selection (`fullSync:false`).
- `GET /api/foundry/*` (`routes/foundry.js`) is unrelated: a JWT-protected proxy over the read-only bridge. - `GET /api/foundry/*` (`routes/foundry.js`) is unrelated: a JWT-protected proxy over the read-only bridge. Its one write, `POST /import`, pulls the bridge's actors or world items into the campaign through the same writers as a sync push.
## 5. Frontend ## 5. Frontend
### 5.1 Not a routed app ### 5.1 Two pages: the app and the documentation
There is no `app/pages/`. `app/app.vue` renders a shell of managers (`Window`, `Content`, `Toast`, `app/pages/` routes the only two things the frontend is. `index.vue` and the `[...all].vue` catch-all
`Tooltip`, `ContextMenu`) and boots: `GetUser()` (JWT in localStorage) → `RestoreCampaign()` or open both render `components/views/AppShell.vue` — the window app, which has no routes of its own — and
`main_menu`; no user → `HasAdmin() ? 'login' : 'register' {firstTime:true}`. The one real URL is `docs/index.vue` + `docs/[slug].vue` render `views/DocsView.vue`, the documentation at `/docs`.
`/link/authorize` (and the legacy `/discord/authorize`), which renders the service link screen instead `app.vue` holds only what is site-wide (the head, the theme) and `<NuxtPage>`. AppShell boots:
of the app. `GetUser()` (JWT in localStorage) → `RestoreCampaign()` or open `main_menu`; no user →
`HasAdmin() ? 'login' : 'register' {firstTime:true}`. `/link/authorize` (and the legacy
`/discord/authorize`) is not a page either: AppShell checks the path and renders the service link
screen instead of the app.
The documentation is markdown files under `app/content/docs/<group>/<NN>-<page>.md`: the folder is the
sidebar group and its number orders the groups, the file's number orders its pages, the rest of its
name is the slug, and the first heading is the title. `services/Docs.js` reads them
(`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
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, 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
@@ -165,7 +180,7 @@ writes `localStorage.selectedCampaignId`, `RestoreCampaign`), `Content.js` (§5.
(`mitt()` bus), `Toaster.js`, `Tooltip.js`, `ContextMenu.js`, `Sound.js` (`AddSound` binds (`mitt()` bus), `Toaster.js`, `Tooltip.js`, `ContextMenu.js`, `Sound.js` (`AddSound` binds
`snap.wav` to `.sound-click`), `Marker.js` (marked + widgets), `ActionRegistry.js` (command palette: `snap.wav` to `.sound-click`), `Marker.js` (marked + widgets), `ActionRegistry.js` (command palette:
`register/unregister/search/execute`), `Windows.js` / `WindowDefinitions.js`, `MapPins.js`, `MapTokens.js`, `register/unregister/search/execute`), `Windows.js` / `WindowDefinitions.js`, `MapPins.js`, `MapTokens.js`,
`widgets/DiceParser.js`. `Docs.js` + `DocsMarkdown.js` (§5.1), `widgets/DiceParser.js`.
### 5.4 Markdown → widgets ### 5.4 Markdown → widgets
@@ -198,7 +213,9 @@ variables: always style with `var(--color-…)`, never hardcode hex, and add a n
i18n: `frontend/i18n/locales/<lang>/<namespace>.json` for `en` (default), `es`, `ca`; `plugins/i18n.ts` i18n: `frontend/i18n/locales/<lang>/<namespace>.json` for `en` (default), `es`, `ca`; `plugins/i18n.ts`
nests each file under its filename, so the key is `<file>.<path>` (`$t('windows.login')`). **Add every nests each file under its filename, so the key is `<file>.<path>` (`$t('windows.login')`). **Add every
new string to all three locales.** Namespaces in use: `general`, `login`, `register`, `main-menu`, new string to all three locales.** Namespaces in use: `general`, `login`, `register`, `main-menu`,
`settings`, `windows`, `campaigns`, `link`, `foundry`, `discord`. `settings`, `windows`, `campaigns`, `link`, `foundry`, `discord`, `docs`. (The `/docs` *content* is
markdown under `app/content/docs` and is written in English; only its chrome — sidebar labels, prev /
next — is translated.)
## 6. Conventions ## 6. Conventions
@@ -215,6 +232,7 @@ new string to all three locales.** Namespaces in use: `general`, `login`, `regis
- **New widget**: component in `components/viewer/widgets/{inline,display}/` + `widget_map` entry in `Marker.js`. - **New widget**: component in `components/viewer/widgets/{inline,display}/` + `widget_map` entry in `Marker.js`.
- **New palette action**: `register({id, label, description, execute, isActive?})` from `~/services/ActionRegistry` (palette: `Ctrl/Cmd+K` or `/`). - **New palette action**: `register({id, label, description, execute, isActive?})` from `~/services/ActionRegistry` (palette: `Ctrl/Cmd+K` or `/`).
- **New theme color**: key in *both* `dark` and `light` maps in `colors.scss`, then `var(--color-<key>)`. - **New theme color**: key in *both* `dark` and `light` maps in `colors.scss`, then `var(--color-<key>)`.
- **New documentation page**: `app/content/docs/<group>/NN-name.md` whose first heading is its title (§5.1); a brand-new group also needs `groups.<folder>` in `i18n/locales/*/docs.json` (all three locales).
## 8. Known landmines (verified in code — do not "fix" silently, never make them worse) ## 8. Known landmines (verified in code — do not "fix" silently, never make them worse)

View File

@@ -22,11 +22,69 @@ const ActorSchema = new Schema({
}, },
armorClass: { type: Number, min: 0, default: 10 }, armorClass: { type: Number, min: 0, default: 10 },
speed: { type: Number, min: 0, default: 30 }, speed: { type: Number, min: 0, default: 30 },
// The two pools the sheet draws as bars under the portrait (Syndria98/dragonroll#64): the bar
// fills `current` of `max`, so both travel together. `current` is kept below `max` by whoever
// writes them (routes/actor.js), the same way the sheet clamps the bar.
hitPoints: {
current: { type: Number, min: 0, default: 10 },
max: { type: Number, min: 0, default: 10 }
},
hitDice: {
current: { type: Number, min: 0, default: 1 },
max: { type: Number, min: 0, default: 1 }
},
proficiencies: { type: String, default: '' }, proficiencies: { type: String, default: '' },
// The skills the character is proficient with (Syndria98/dragonroll#83). Dragonroll holds
// whole names; services/actor-foundry.js translates the short keys a Foundry world uses.
skills: {
acrobatics: { type: Boolean, default: false },
animalHandling: { type: Boolean, default: false },
arcana: { type: Boolean, default: false },
athletics: { type: Boolean, default: false },
deception: { type: Boolean, default: false },
history: { type: Boolean, default: false },
insight: { type: Boolean, default: false },
intimidation: { type: Boolean, default: false },
investigation: { type: Boolean, default: false },
medicine: { type: Boolean, default: false },
nature: { type: Boolean, default: false },
perception: { type: Boolean, default: false },
performance: { type: Boolean, default: false },
persuasion: { type: Boolean, default: false },
religion: { type: Boolean, default: false },
sleightOfHand: { type: Boolean, default: false },
stealth: { type: Boolean, default: false },
survival: { type: Boolean, default: false }
},
// Which of the six saving throws the character adds its proficiency bonus to.
savingThrows: {
str: { type: Boolean, default: false },
dex: { type: Boolean, default: false },
con: { type: Boolean, default: false },
int: { type: Boolean, default: false },
wis: { type: Boolean, default: false },
cha: { type: Boolean, default: false }
},
// Tool and language proficiencies: plain names, one per entry. The free-form
// `proficiencies` text keeps whatever else the character is proficient with
// (armour and weapons, say), which has no list of its own.
tools: [{ type: String, trim: true }],
languages: [{ type: String, trim: true }],
// The coins the character holds, in the five D&D denominations.
currency: {
pp: { type: Number, min: 0, default: 0 },
gp: { type: Number, min: 0, default: 0 },
ep: { type: Number, min: 0, default: 0 },
sp: { type: Number, min: 0, default: 0 },
cp: { type: Number, min: 0, default: 0 }
},
inventory: [{ inventory: [{
name: { type: String, trim: true, default: '' }, name: { type: String, trim: true, default: '' },
quantity: { type: Number, min: 1, default: 1 }, quantity: { type: Number, min: 1, default: 1 },
weight: { type: Number, min: 0, default: 0 } weight: { type: Number, min: 0, default: 0 },
// The gear's own picture: what a Foundry world sends with the item it stands
// for, shown on the left of the inventory row.
icon: { type: String, default: '' }
}], }],
traits: { type: String, default: '' }, traits: { type: String, default: '' },
spells: { type: String, default: '' }, spells: { type: String, default: '' },
@@ -43,6 +101,10 @@ const ActorSchema = new Schema({
default: null default: null
}, },
foundryActorId: { type: String }, foundryActorId: { type: String },
// The Discord player this character belongs to (Syndria98/dragonroll#72): each player
// of the server a campaign is linked to holds one character of it. Only
// routes/discord.js writes it, so the campaign keeps owning it whichever guild claimed it.
discordUserId: { type: String, default: null },
date: { type: Date, default: Date.now } date: { type: Date, default: Date.now }
}); });
@@ -51,4 +113,10 @@ ActorSchema.index(
{ unique: true, partialFilterExpression: { foundryActorId: { $type: 'string' } } } { unique: true, partialFilterExpression: { foundryActorId: { $type: 'string' } } }
); );
// A player holds at most one character of a campaign: the id is unique within it.
ActorSchema.index(
{ campaign: 1, discordUserId: 1 },
{ unique: true, partialFilterExpression: { discordUserId: { $type: 'string' } } }
);
module.exports = mongoose.model('Actor', ActorSchema); module.exports = mongoose.model('Actor', ActorSchema);

View File

@@ -27,6 +27,19 @@ const MapSchema = new Schema({
x: { type: Number, default: 0 }, x: { type: Number, default: 0 },
y: { type: Number, default: 0 } y: { type: Number, default: 0 }
}], }],
// Segments that block the map like walls. The endpoints are image pixels from the top left corner
// of the image, like a pin — and the very space Foundry draws a scene's walls in, so a paired
// scene and map trade them as they stand. `move`/`sight` say what passes through the segment, and
// `door` is 0 (not a door), 1 (open) or 2 (closed), following Foundry's own wall values.
walls: [{
x1: { type: Number, default: 0 },
y1: { type: Number, default: 0 },
x2: { type: Number, default: 0 },
y2: { type: Number, default: 0 },
move: { type: Boolean, default: true },
sight: { type: Boolean, default: true },
door: { type: Number, min: 0, max: 2, default: 0 }
}],
campaign: { campaign: {
type: Schema.Types.ObjectId, type: Schema.Types.ObjectId,
ref: 'Campaign', ref: 'Campaign',
@@ -39,7 +52,16 @@ const MapSchema = new Schema({
ref: 'Folder', ref: 'Folder',
default: null default: null
}, },
// The Foundry scene whose walls this map mirrors once the linked world has paired them (see
// routes/foundry-link.js): the whole wall set of one is the whole wall set of the other.
foundrySceneId: { type: String },
date: { type: Date, default: Date.now } date: { type: Date, default: Date.now }
}); });
// A scene walls one map of a campaign at most, like a Foundry actor one actor row.
MapSchema.index(
{ campaign: 1, foundrySceneId: 1 },
{ unique: true, partialFilterExpression: { foundrySceneId: { $type: 'string' } } }
);
module.exports = mongoose.model('Map', MapSchema); module.exports = mongoose.model('Map', MapSchema);

View File

@@ -13,6 +13,22 @@ async function userOwnsCampaign(campaignId, userId) {
return Boolean(campaign); return Boolean(campaign);
} }
// Hit points and hit dice travel as a bar the sheet fills (`current` of `max`, see models/Actor.js).
// A partial update keeps whatever half of the pair it did not send, and `current` never passes the
// maximum it ends up with.
function barPool(existing, value) {
const max = Math.max(0, Number(value?.max ?? existing?.max) || 0);
const current = Math.max(0, Math.min(Number(value?.current ?? existing?.current) || 0, max));
return { current, max };
}
// The tool and language lists (Syndria98/dragonroll#83): plain names, blank ones and
// repeats dropped.
function textList(value) {
if (!Array.isArray(value)) return [];
return [...new Set(value.map((name) => String(name).trim()).filter(Boolean))];
}
// Folders the campaign's actors are grouped into, in the shape the sidebar groups by // Folders the campaign's actors are grouped into, in the shape the sidebar groups by
// (the notes, items and maps each keep a tree of their own, see models/Folder.js). // (the notes, items and maps each keep a tree of their own, see models/Folder.js).
async function actorFolders(campaignId) { async function actorFolders(campaignId) {
@@ -56,7 +72,10 @@ router.post('/create', async (req, res) => {
router.post('/update', async (req, res) => { router.post('/update', async (req, res) => {
try { try {
const { id, name, species, className, subclass, level, abilityScores, armorClass, speed, proficiencies, inventory, traits, spells, image, folder } = req.body; const {
id, name, species, className, subclass, level, abilityScores, armorClass, speed, hitPoints, hitDice,
proficiencies, skills, savingThrows, tools, languages, currency, inventory, traits, spells, image, folder
} = req.body;
if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' }); if (!id) return res.json({ status: 'error', msg: 'errors.missing-data' });
const actor = await Actor.findById(id); const actor = await Actor.findById(id);
@@ -80,7 +99,17 @@ router.post('/update', async (req, res) => {
if (abilityScores !== undefined) actor.abilityScores = abilityScores; if (abilityScores !== undefined) actor.abilityScores = abilityScores;
if (armorClass !== undefined) actor.armorClass = Number(armorClass); if (armorClass !== undefined) actor.armorClass = Number(armorClass);
if (speed !== undefined) actor.speed = Number(speed); if (speed !== undefined) actor.speed = Number(speed);
if (hitPoints !== undefined) actor.hitPoints = barPool(actor.hitPoints, hitPoints);
if (hitDice !== undefined) actor.hitDice = barPool(actor.hitDice, hitDice);
if (proficiencies !== undefined) actor.proficiencies = proficiencies; if (proficiencies !== undefined) actor.proficiencies = proficiencies;
// The lists the sheet toggles and fills in (Syndria98/dragonroll#83): which skills
// and saving throws the character is proficient with, its tools, its languages and
// the coins it carries.
if (skills !== undefined) actor.skills = skills;
if (savingThrows !== undefined) actor.savingThrows = savingThrows;
if (tools !== undefined) actor.tools = textList(tools);
if (languages !== undefined) actor.languages = textList(languages);
if (currency !== undefined) actor.currency = currency;
if (inventory !== undefined) actor.inventory = inventory; if (inventory !== undefined) actor.inventory = inventory;
if (traits !== undefined) actor.traits = traits; if (traits !== undefined) actor.traits = traits;
if (spells !== undefined) actor.spells = spells; if (spells !== undefined) actor.spells = spells;

View File

@@ -16,6 +16,11 @@ function validGuildId(value) {
return /^\d{5,25}$/.test(String(value ?? '')); return /^\d{5,25}$/.test(String(value ?? ''));
} }
// Discord ids are snowflakes the same shape as guild ids.
function validUserId(value) {
return /^\d{5,25}$/.test(String(value ?? ''));
}
// Connecting a Discord server is the service link of issue: the bot asks // Connecting a Discord server is the service link of issue: the bot asks
// /api/link/start for a sign-up link, and whoever opens it signs in and picks the // /api/link/start for a sign-up link, and whoever opens it signs in and picks the
// campaign this server may read. What is left here is what the bot needs once // campaign this server may read. What is left here is what the bot needs once
@@ -179,4 +184,92 @@ router.get('/bot/guild/:guildId/actors', requireBot, async (req, res) => {
} }
}); });
// Who may take a character already held by somebody else is decided in Discord,
// where the server administrators are: the bot authenticates with the shared
// secret and says whether the person asking is one (`admin`). Everything else
// the backend still guards itself: only the guild's own campaign is reachable.
// One command per player link (Syndria98/dragonroll#72): assigning takes the
// character for `discordUserId`, and a player never holds two of them, so a
// second assign moves the player instead of doubling them up.
router.post('/bot/guild/:guildId/actors/assign', requireBot, async (req, res) => {
try {
const guildId = String(req.params.guildId);
const discordUserId = String(req.body.discordUserId ?? '');
if (!validGuildId(guildId) || !validUserId(discordUserId) || !req.body.actorId) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const link = await DiscordGuildLink.findOne({ guildId }).lean();
if (!link) return res.json({ status: 'error', msg: 'discord.errors.not-connected' });
const campaign = await Campaign.findOne({ discordGuildId: guildId, createdBy: link.dragonrollUser }).select('_id name').lean();
if (!campaign) return res.json({ status: 'error', msg: 'errors.notfound' });
const actor = await Actor.findOne({ _id: req.body.actorId, campaign: campaign._id });
if (!actor) return res.json({ status: 'error', msg: 'errors.notfound' });
const holder = String(actor.discordUserId ?? '');
if (holder && holder !== discordUserId && !req.body.admin) {
return res.json({ status: 'error', msg: 'discord.errors.actor-held' });
}
// The character this player hands over to take the new one.
const previous = await Actor.findOne({ campaign: campaign._id, discordUserId, _id: { $ne: actor._id } }).lean();
if (previous) {
await Actor.updateMany(
{ campaign: campaign._id, discordUserId, _id: { $ne: actor._id } },
{ $set: { discordUserId: null } }
);
}
actor.discordUserId = discordUserId;
await actor.save();
res.json({
status: 'ok',
actor: { id: String(actor._id), name: actor.name, discordUserId },
previous: previous ? { id: String(previous._id), name: previous.name } : null
});
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// Freeing a character: without `actorId` the player gives up their own, with
// one a server administrator frees anybody's.
router.post('/bot/guild/:guildId/actors/unassign', requireBot, async (req, res) => {
try {
const guildId = String(req.params.guildId);
const discordUserId = String(req.body.discordUserId ?? '');
if (!validGuildId(guildId) || !validUserId(discordUserId)) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const link = await DiscordGuildLink.findOne({ guildId }).lean();
if (!link) return res.json({ status: 'error', msg: 'discord.errors.not-connected' });
const campaign = await Campaign.findOne({ discordGuildId: guildId, createdBy: link.dragonrollUser }).select('_id name').lean();
if (!campaign) return res.json({ status: 'error', msg: 'errors.notfound' });
const filter = { campaign: campaign._id };
if (req.body.actorId) filter._id = req.body.actorId;
else filter.discordUserId = discordUserId;
const actor = await Actor.findOne(filter);
if (!actor || !actor.discordUserId) return res.json({ status: 'error', msg: 'errors.notfound' });
const holder = String(actor.discordUserId);
if (holder !== discordUserId && !req.body.admin) {
return res.json({ status: 'error', msg: 'discord.errors.actor-held' });
}
actor.discordUserId = null;
await actor.save();
res.json({ status: 'ok', actor: { id: String(actor._id), name: actor.name }, wasYours: holder === discordUserId });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router; module.exports = router;

View File

@@ -7,8 +7,11 @@ const Campaign = require('../models/Campaign');
const Actor = require('../models/Actor'); const Actor = require('../models/Actor');
const Item = require('../models/Item'); const Item = require('../models/Item');
const Folder = require('../models/Folder'); const Folder = require('../models/Folder');
// `MapModel`, not `Map`: this file uses the built-in `Map` for the item folder maps.
const MapModel = require('../models/Map');
const { foundryActorToCharacter } = require('../services/actor-foundry'); const { foundryActorToCharacter } = require('../services/actor-foundry');
const { foundryItemToItemData } = require('../services/item-foundry'); const { foundryItemToItemData } = require('../services/item-foundry');
const { joinFoundryAssetUrl } = require('../services/foundry-icons');
// 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 +44,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;
@@ -62,30 +88,30 @@ async function saveFoundryActor(campaign, source, fullSync = false) {
: new Actor({ campaign: campaign._id }); : new Actor({ campaign: campaign._id });
} }
actor.foundryActorId = foundryActorId; actor.foundryActorId = foundryActorId;
// `created` says whether this row is new: whoever imports a whole world counts
// the rows it made apart from the ones it only wrote over.
const created = actor.isNew;
// A full snapshot runs when a GM reconnects. Preserve existing Dragonroll // A full snapshot runs when a GM reconnects. Preserve existing Dragonroll
// edits then; live Foundry change events continue to overwrite normally. // edits then; live Foundry change events continue to overwrite normally.
if (!fullSync || actor.isNew) Object.assign(actor, fields); if (!fullSync || actor.isNew) Object.assign(actor, fields);
await actor.save(); await actor.save();
return { foundryActorId, actorId: actor.id }; return { foundryActorId, actorId: actor.id, created };
} }
// A snapshot carries world-level items plus the items embedded in every actor it // The campaign's item list mirrors the world's item directory and nothing else
// sends. World items are listed first so they own a name before its copies. // (Syndria98/dragonroll#67). The items embedded in an actor are that character's own
// inventory: they travel with the actor document (see services/actor-foundry.js), so a
// snapshot feeds Item rows from the world directory (`body.items`) alone and gear a
// character merely carries stays on its sheet instead of standing in the item list.
function snapshotItemSources(body) { function snapshotItemSources(body) {
const sources = []; return Array.isArray(body.items) ? body.items : [];
if (Array.isArray(body.items)) sources.push(...body.items);
if (Array.isArray(body.actors)) {
for (const actor of body.actors) {
if (Array.isArray(actor?.items)) sources.push(...actor.items);
}
}
return sources;
} }
async function saveFoundryItem(campaign, source, fullSync = false, folders = null) { async function saveFoundryItem(campaign, source, fullSync = false, folders = null) {
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;
@@ -95,9 +121,9 @@ async function saveFoundryItem(campaign, source, fullSync = false, folders = nul
if (flagged && (!flagged.foundryItemId || flagged.foundryItemId === foundryItemId)) item = flagged; if (flagged && (!flagged.foundryItemId || flagged.foundryItemId === foundryItemId)) item = flagged;
} }
if (!item) { if (!item) {
// The same gear exists more than once in Foundry: once in the world // A world item can share its name with a Dragonroll row the campaign made by
// directory and once inside each actor carrying it. Keep a single // hand, or with one it renamed away from. Keep a single item per name so a
// Dragonroll item per name so inventories do not flood the Item list. // piece of gear the world sends folds into that row instead of doubling it.
const sameName = await Item.find({ const sameName = await Item.find({
campaign: campaign._id, campaign: campaign._id,
$or: [{ name: fields.name }, { foundryNames: fields.name }] $or: [{ name: fields.name }, { foundryNames: fields.name }]
@@ -109,6 +135,9 @@ async function saveFoundryItem(campaign, source, fullSync = false, folders = nul
} }
item.foundryItemId = foundryItemId; item.foundryItemId = foundryItemId;
// `created` says whether this row is new: whoever imports a whole world counts
// the rows it made apart from the ones it only wrote over.
const created = item.isNew;
if (!fullSync || item.isNew) Object.assign(item, fields); if (!fullSync || item.isNew) Object.assign(item, fields);
// Foundry's own icon is kept on every save, not only when the edits above // Foundry's own icon is kept on every save, not only when the edits above
// land: the item window offers it back after the user picked their own. // land: the item window offers it back after the user picked their own.
@@ -117,14 +146,14 @@ async function saveFoundryItem(campaign, source, fullSync = false, folders = nul
item.foundryNames = [...item.foundryNames, fields.name].slice(-MAX_FOUNDRY_NAMES); item.foundryNames = [...item.foundryNames, fields.name].slice(-MAX_FOUNDRY_NAMES);
} }
// Which folder of the campaign's item tree the world says this item stands in. // Which folder of the campaign's item tree the world says this item stands in.
// `undefined` means the push says nothing about folders — an item embedded in an // `undefined` means the push says nothing about folders — an older module that
// actor, or a module that knows nothing about them — and the item stays where it // knows nothing about them — and the item stays where it is. The world owns the
// is. The world owns the folder of its own directory, so a move it reports lands on // folder of its own directory, so a move it reports lands on a full snapshot too
// a full snapshot too and wins over one a campaign made from its item list. // and wins over one a campaign made from its item list.
const folder = resolveFoundryItemFolder(source, folders); const folder = resolveFoundryItemFolder(source, folders);
if (folder !== undefined) item.folder = folder; if (folder !== undefined) item.folder = folder;
await item.save(); await item.save();
return { foundryItemId, itemId: item.id }; return { foundryItemId, itemId: item.id, created };
} }
async function syncFoundryItems(campaign, sources, fullSync = false, folders = null) { async function syncFoundryItems(campaign, sources, fullSync = false, folders = null) {
@@ -140,9 +169,19 @@ async function syncFoundryItems(campaign, sources, fullSync = false, folders = n
// A Foundry world groups its item directory into folders; the campaign mirrors that // A Foundry world groups its item directory into folders; the campaign mirrors that
// tree as Folders of target 'item' so its item list reads like the world's. Every // tree as Folders of target 'item' so its item list reads like the world's. Every
// push from a module that knows about folders carries the whole world tree, and // push from a module that knows about folders carries the whole world tree, and
// names the folder each world item it sends stands in. Items embedded in an actor // names the folder each world item it sends stands in. Only the world's item
// say nothing: the folders they carry belong to that actor's own inventory, and // directory reaches the campaign's item list, so only its folders are mirrored; the
// Dragonroll keeps one item per piece of gear anyway. // inventory folders an actor keeps for itself are none of the item list's business.
// The colour a pushed folder carries. `undefined` means the push says nothing about
// colours — an older module, which knows nothing about them — and the colour the
// campaign has stays; `null` is the world leaving a folder uncoloured, which takes
// the campaign's colour off along with it. Anything else is the colour to show.
function foundryFolderColor(source) {
if (source?.color === undefined) return undefined;
const color = typeof source.color === 'string' ? source.color.trim() : '';
return color || null;
}
// Parents before children, so a folder is mapped before the one nested in it. // Parents before children, so a folder is mapped before the one nested in it.
// A folder whose parent is missing, or caught in a cycle, becomes a root. // A folder whose parent is missing, or caught in a cycle, becomes a root.
@@ -152,7 +191,12 @@ function orderFoundryFolderSources(sources) {
const id = String(source?.id || '').trim().slice(0, 120); const id = String(source?.id || '').trim().slice(0, 120);
const name = String(source?.name || '').trim(); const name = String(source?.name || '').trim();
if (!id || !name) continue; if (!id || !name) continue;
byId.set(id, { id, name, parent: String(source?.parent || '').trim().slice(0, 120) }); byId.set(id, {
id,
name,
parent: String(source?.parent || '').trim().slice(0, 120),
color: foundryFolderColor(source)
});
} }
const ordered = []; const ordered = [];
@@ -195,6 +239,10 @@ async function syncFoundryItemFolders(campaign, folderSources) {
// The world owns this tree, so unlike an item's fields a rename or a move // The world owns this tree, so unlike an item's fields a rename or a move
// lands whatever kind of push carried it: the whole tree arrives with each. // lands whatever kind of push carried it: the whole tree arrives with each.
folder.name = source.name; folder.name = source.name;
// Its colour is the one part of the tree the campaign colours too: what the
// world shows arrives here, and what the campaign picks travels back to the
// world with the folder list `/sync/items` answers with.
if (source.color !== undefined) folder.color = source.color;
const parent = inTree.has(source.parent) ? folders.get(source.parent) : null; const parent = inTree.has(source.parent) ? folders.get(source.parent) : null;
folder.parentFolder = parent ? parent._id : null; folder.parentFolder = parent ? parent._id : null;
await folder.save(); await folder.save();
@@ -278,8 +326,8 @@ router.post('/sync/snapshot', async (req, res) => {
foundryActorId: { $exists: true, $nin: currentIds } foundryActorId: { $exists: true, $nin: currentIds }
}); });
} }
// Pruning needs a full snapshot: only that request sees the world // Pruning needs a full snapshot: only that request sees the whole world
// directory and every actor's copies at the same time. // directory, so it alone knows which synced rows the world has let go of.
if (fullSync && itemSources) { if (fullSync && itemSources) {
const currentIds = snapshotItemSources(req.body) const currentIds = snapshotItemSources(req.body)
.map((source) => String(source?._id || source?.id || '').trim()) .map((source) => String(source?._id || source?.id || '').trim())
@@ -388,12 +436,20 @@ router.post('/sync/item-delete', async (req, res) => {
} }
}); });
// The item list the world reconciles against, together with the folders its rows are
// grouped into — the same shape the campaign's own `/item/list` answers with. The folders
// travel back for their colour: the world owns the tree's name and nesting, while whoever
// colours a folder on either side expects to see it coloured on the other.
router.get('/sync/items', async (req, res) => { router.get('/sync/items', async (req, res) => {
try { try {
const campaign = await syncCampaign(req, res); const campaign = await syncCampaign(req, res);
if (!campaign) return; if (!campaign) return;
const items = await Item.find({ campaign: campaign._id }).sort({ name: 1 }).lean(); const items = await Item.find({ campaign: campaign._id }).sort({ name: 1 }).lean();
res.json({ status: 'ok', items }); const folders = await Folder.find({ campaign: campaign._id, target: 'item' })
.select('_id name color foundryFolderId')
.sort({ name: 1 })
.lean();
res.json({ status: 'ok', items, folders });
} catch (err) { } catch (err) {
console.error(err); console.error(err);
res.json({ status: 'error', msg: 'errors.internal' }); res.json({ status: 'error', msg: 'errors.internal' });
@@ -423,4 +479,107 @@ router.post('/sync/map-item', async (req, res) => {
} }
}); });
// --- Scene walls -----------------------------------------------------------
// A campaign map can mirror the walls of a Foundry scene: the whole set travels whoever edits
// it, so the map's editor and the scene's wall tool see the same segments. A map is paired with
// a scene by name while the module reconciles its campaign — the way an unmapped item maps to
// the world document it shares its name with — and `POST /sync/map-scene` records that pairing.
// The endpoints are image pixels of the scene's background there too, so a segment crosses
// unchanged; `door` follows Foundry's own wall values (1 open, 2 closed), and locked doors
// arrive closed.
// Same shape the campaign's own `/map/walls` saves by: finite endpoints or nothing, whole pixels
// that never go off the top left corner, no segment without length.
function toSyncedWall(source) {
const corners = [source?.x1, source?.y1, source?.x2, source?.y2];
if (!corners.every((value) => Number.isFinite(Number(value)))) return null;
const toPixel = (value) => Math.max(0, Math.round(Number(value)));
const wall = {
x1: toPixel(source.x1),
y1: toPixel(source.y1),
x2: toPixel(source.x2),
y2: toPixel(source.y2),
move: source.move !== false,
sight: source.sight !== false,
door: [1, 2].includes(Math.round(Number(source.door))) ? Math.round(Number(source.door)) : 0
};
return wall.x1 === wall.x2 && wall.y1 === wall.y2 ? null : wall;
}
// The maps the module pairs scenes with and reconciles walls against: what a wall set needs to
// land on a scene, and nothing the module has no use for.
router.get('/sync/maps', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const maps = await MapModel.find({ campaign: campaign._id })
.select('_id name image foundrySceneId walls')
.sort({ name: 1 })
.lean();
res.json({ status: 'ok', maps });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
router.post('/sync/map-scene', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const { mapId, foundrySceneId, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !mapId || !foundrySceneId) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const map = await MapModel.findOne({ _id: mapId, campaign: campaign._id });
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
const existing = await MapModel.findOne({
campaign: campaign._id,
foundrySceneId: String(foundrySceneId).trim(),
_id: { $ne: map._id }
});
if (existing) return res.json({ status: 'error', msg: 'foundry.errors.scene-already-synced' });
map.foundrySceneId = String(foundrySceneId).trim().slice(0, 120);
await map.save();
res.json({ status: 'ok', map });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// A scene's whole wall set, as the module draws it: the paired map takes it over, like the
// world's item folders take over the campaign's tree. A scene the campaign has no map paired
// with answers `notfound` — most scenes are none of the campaign's business.
router.post('/sync/map-walls', async (req, res) => {
try {
const campaign = await syncCampaign(req, res);
if (!campaign) return;
const { foundrySceneId, walls, worldId } = req.body;
if (!requestMatchesWorld(campaign, worldId) || !foundrySceneId || !Array.isArray(walls)) {
return res.json({ status: 'error', msg: 'errors.missing-data' });
}
const map = await MapModel.findOne({ campaign: campaign._id, foundrySceneId: String(foundrySceneId).trim() });
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
map.walls = walls.map(toSyncedWall).filter(Boolean);
await map.save();
res.json({ status: 'ok', map: { _id: map.id } });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router; module.exports = router;
// The writers every Foundry document goes through: the sync pushes above, and the
// force import a campaign asks for from its sidebar (routes/foundry.js). One set of
// rules decides which campaign row a world document owns, so pulling a world over
// twice updates its rows instead of doubling them.
module.exports.saveFoundryActor = saveFoundryActor;
module.exports.saveFoundryItem = saveFoundryItem;

View File

@@ -1,6 +1,21 @@
const express = require('express'); const express = require('express');
const router = express.Router(); const router = express.Router();
const { requestFoundry } = require('../services/foundry'); const { requestFoundry } = require('../services/foundry');
const { normalizeIconDirectory, readIconListingPage, shapeIconListing } = require('../services/foundry-icons');
const Campaign = require('../models/Campaign');
// The writers a Foundry document is stored through, shared with the sync pushes the
// linked module sends (routes/foundry-link.js) so both write a world's rows by the
// same rules.
const { saveFoundryActor, saveFoundryItem } = require('./foundry-link');
// The world address the icons are loaded from is kept on the campaign, so an icon
// listing is always asked for one of the caller's own campaigns. The linked world's
// id travels along: an import has to know whose data it is pulling over.
async function findOwnedCampaign(campaignId, userId) {
if (!campaignId) return null;
return Campaign.findOne({ _id: campaignId, createdBy: userId }).select('settings foundryWorldId').lean();
}
async function proxy(path, res) { async function proxy(path, res) {
try { try {
@@ -24,4 +39,95 @@ router.get('/actors/:id/items', (req, res) => proxy(`api/actors/${encodeURICompo
router.get('/actors/:id', (req, res) => proxy(`api/actors/${encodeURIComponent(req.params.id)}`, res)); router.get('/actors/:id', (req, res) => proxy(`api/actors/${encodeURIComponent(req.params.id)}`, res));
router.get('/items/:id', (req, res) => proxy(`api/items/${encodeURIComponent(req.params.id)}`, res)); router.get('/items/:id', (req, res) => proxy(`api/items/${encodeURIComponent(req.params.id)}`, res));
// Force import (Syndria98/dragonroll#77): the sidebar's "force import from Foundry"
// pulls the whole actor list or item directory of the world the bridge is showing
// right now. The documents go through the writers the module's own snapshot push
// uses, so a world document lands on the row it owns: what the campaign already has
// is written over, not imported a second time. Nothing is pruned here — only a full
// snapshot from the module sees the whole world, so dropping rows the world let go of
// stays that snapshot's job.
router.post('/import', async (req, res) => {
try {
const kind = ['actors', 'items'].includes(req.body?.kind) ? req.body.kind : null;
if (!kind) return res.json({ status: 'error', msg: 'errors.missing-data' });
const campaign = await findOwnedCampaign(req.body.campaign, req.user.id);
if (!campaign) return res.json({ status: 'error', msg: 'errors.notfound' });
if (!campaign.foundryWorldId) {
return res.json({ status: 'error', msg: 'foundry.errors.import-not-linked' });
}
// The bridge answers `{status, data, world}`: `data` holds the world's actors
// or its world-level items, in the shape the module published them in.
let snapshot;
try {
snapshot = await requestFoundry(`api/${kind}`);
} catch (err) {
if (err.code !== 'FOUNDRY_NOT_CONFIGURED') console.error(err);
return res.json({ status: 'error', msg: 'foundry.errors.import-unavailable' });
}
if (snapshot.status !== 200 || snapshot.data?.status !== 'ok' || !Array.isArray(snapshot.data.data)) {
return res.json({ status: 'error', msg: 'foundry.errors.import-unavailable' });
}
// The bridge keeps one world's snapshot at a time, so a campaign linked to
// another world must not be filled with it. A bridge that does not say whose
// world it holds is taken at its word: only a known mismatch stops the import.
if (snapshot.data.world?.id && snapshot.data.world.id !== campaign.foundryWorldId) {
return res.json({ status: 'error', msg: 'foundry.errors.import-world-mismatch' });
}
let imported = 0;
let updated = 0;
for (const source of snapshot.data.data) {
// An actor without a name, or a world document that is not gear, maps to
// nothing and is skipped exactly like a sync push skips it.
const mapping = kind === 'actors'
? await saveFoundryActor(campaign, source)
: await saveFoundryItem(campaign, source);
if (!mapping) continue;
if (mapping.created) imported += 1;
else updated += 1;
}
res.json({ status: 'ok', kind, imported, updated });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
// Foundry's core icon library: the `icons/` folder of the world's data directory.
// One folder per request, and the icons inside it paged, because that library runs
// into the thousands and the window only ever shows where the user is standing.
// The bridge reads it on the Foundry host; the images themselves are loaded by the
// browser from the campaign's world address, the same way a synced item's icon is.
router.get('/icons', async (req, res) => {
try {
const campaign = await findOwnedCampaign(req.query.campaign, req.user.id);
if (!campaign) return res.status(404).json({ status: 'error', msg: 'errors.notfound' });
const base = campaign.settings?.integrations?.foundryUrl || '';
if (!base) return res.status(400).json({ status: 'error', msg: 'foundry.errors.icons-no-world-url' });
const dir = normalizeIconDirectory(req.query.dir);
if (!dir) return res.status(400).json({ status: 'error', msg: 'errors.missing-data' });
const { limit, offset } = readIconListingPage(req.query);
const query = new URLSearchParams({ dir, offset: String(offset), limit: String(limit) });
const result = await requestFoundry(`api/icons?${query}`);
if (result.status !== 200 || result.data?.status !== 'ok') {
return res.status(502).json({ status: 'error', msg: 'foundry.errors.icons-unavailable' });
}
res.json({ status: 'ok', ...shapeIconListing({ base, dir, listing: result.data }) });
} catch (err) {
if (err.code === 'FOUNDRY_NOT_CONFIGURED') {
return res.status(503).json({ status: 'error', msg: 'foundry.errors.icons-unavailable' });
}
console.error(err);
res.status(502).json({ status: 'error', msg: 'foundry.errors.icons-unavailable' });
}
});
module.exports = router; module.exports = router;

View File

@@ -238,4 +238,50 @@ router.post('/remove-token', async (req, res) => {
} }
}); });
// A wall is a segment of the map that blocks it like one does. The editor saves the whole set at
// once — drawing, moving, re-typing and taking off segments are all the same request — and a paired
// Foundry scene takes that set whole too, so the set is the contract on both sides. Endpoints are
// image pixels like a pin's, and a wall keeps the `_id` it is sent with when one of the current
// walls has it, so the markers on screen do not jump through a save. A segment with no length is
// dropped: it is a click that was not meant to draw anything.
function toStoredWall(source, currentWalls) {
const corners = [source?.x1, source?.y1, source?.x2, source?.y2];
if (!corners.every((value) => Number.isFinite(Number(value)))) return null;
const wall = {
x1: toCoordinate(source.x1),
y1: toCoordinate(source.y1),
x2: toCoordinate(source.x2),
y2: toCoordinate(source.y2),
// What the editor draws is a wall, not an opening: both stay out unless it says otherwise.
move: source.move !== false,
sight: source.sight !== false,
door: [1, 2].includes(Math.round(Number(source.door))) ? Math.round(Number(source.door)) : 0
};
if (wall.x1 === wall.x2 && wall.y1 === wall.y2) return null;
const id = String(source?._id ?? '').trim();
if (id && currentWalls.some((current) => String(current?._id) === id)) wall._id = id;
return wall;
}
router.post('/walls', async (req, res) => {
try {
const { id, walls } = req.body;
if (!id || !Array.isArray(walls)) return res.json({ status: 'error', msg: 'errors.missing-data' });
const map = await Map.findById(id);
if (!map) return res.json({ status: 'error', msg: 'errors.notfound' });
if (!(await userOwnsCampaign(map.campaign, req.user.id))) return res.json({ status: 'error', msg: 'unauthorized' });
const currentWalls = Array.from(map.walls ?? []);
map.walls = walls.map((source) => toStoredWall(source, currentWalls)).filter(Boolean);
await map.save();
res.json({ status: 'ok', map });
} catch (err) {
console.error(err);
res.json({ status: 'error', msg: 'errors.internal' });
}
});
module.exports = router; module.exports = router;

View File

@@ -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
@@ -23,6 +24,112 @@ function detailsName(value, items) {
return looksLikeFoundryId(text) ? '' : text; return looksLikeFoundryId(text) ? '' : text;
} }
// --- Skills, saving throws, tools, languages and coins (Syndria98/dragonroll#83) ---
// The eighteen skills a 5e character has, as the system keys them and as Dragonroll
// names them. The short keys mean nothing outside Foundry, and Dragonroll's sheet holds
// the names it shows a user.
const FOUNDRY_SKILLS = {
acr: 'acrobatics', ani: 'animalHandling', arc: 'arcana', ath: 'athletics', dec: 'deception',
his: 'history', ins: 'insight', itm: 'intimidation', inv: 'investigation', med: 'medicine',
nat: 'nature', prc: 'perception', perf: 'performance', prs: 'persuasion', rel: 'religion',
sle: 'sleightOfHand', stl: 'stealth', sur: 'survival'
};
const ABILITIES = ['str', 'dex', 'con', 'int', 'wis', 'cha'];
const CURRENCIES = ['pp', 'gp', 'ep', 'sp', 'cp'];
// Whether one of the system's proficiency fields says the character has that
// proficiency. The system has held it several ways across its releases — a boolean, a
// number of proficiency steps, a list of proficiency modes ('prof', 'exp'), or one of
// those under `value`, `proficient` or `prof` — and worlds run different releases of
// it. Anything above nothing counts as proficient.
function isProficient(value, depth = 0) {
if (value === undefined || value === null || depth > 3) return false;
if (typeof value === 'boolean') return value;
if (typeof value === 'number') return value > 0;
if (typeof value === 'string') {
const text = value.trim();
if (!text) return false;
const number = Number(text);
return Number.isFinite(number) ? number > 0 : text.toLowerCase() !== 'none';
}
if (Array.isArray(value)) return value.some((entry) => isProficient(entry, depth + 1));
return ['value', 'proficient', 'prof'].some((key) => isProficient(value[key], depth + 1));
}
// A toggled map (skill name or ability → proficient) from whatever the actor lists.
// `null` says the actor says nothing about them at all, which is what keeps a live
// Foundry edit from clearing the toggles the campaign set by hand.
function toggleMap(sources) {
const toggled = {};
for (const [name, value] of Object.entries(sources)) {
if (value !== undefined) toggled[name] = isProficient(value);
}
return Object.keys(toggled).length ? toggled : null;
}
function foundrySkills(system) {
const skills = system.skills && typeof system.skills === 'object' ? system.skills : {};
return toggleMap(Object.fromEntries(Object.entries(FOUNDRY_SKILLS)
.map(([key, name]) => [name, skills[key]])));
}
function foundrySavingThrows(system) {
const saves = system.saves && typeof system.saves === 'object' ? system.saves : {};
return toggleMap(Object.fromEntries(ABILITIES.map((key) => [
key,
system.savingThrows?.[key] ?? system.abilities?.[key]?.save ?? saves[key]
])));
}
// Tools and languages: the module sends the labels its own CONFIG holds, because a
// world's proficiency lists are keys — and, since the third system release, language
// documents — that mean nothing outside Foundry. Without them the keys are the best
// there is to name a proficiency with, and a bare Foundry document id is worse than
// nothing at all. `null` says the actor says nothing about the kind, `[]` that it has
// none of it. Dragonroll names its lists in full; the world keeps its tools under
// `system.traits.tool` and its languages under `system.traits.languages`.
const TRAIT_FIELDS = { tools: 'tool', languages: 'languages' };
function foundryTraitNames(actor, kind) {
const labels = actor.dragonroll?.[kind];
if (Array.isArray(labels)) {
return [...new Set(labels.map((label) => asText(label).trim()).filter(Boolean))];
}
const trait = actor.system?.traits?.[TRAIT_FIELDS[kind] ?? kind];
if (!trait || typeof trait !== 'object') return null;
const names = [
...stringList(trait.value),
...asText(trait.custom).split(',').map((name) => name.trim())
].filter((name) => name && !looksLikeFoundryId(name));
return [...new Set(names)];
}
function foundryCurrency(system) {
const coins = system.currency;
if (!coins || typeof coins !== 'object') return null;
return Object.fromEntries(CURRENCIES.map((key) => [key, Math.max(0, numberOr(coins[key], 0))]));
}
// The character's traits as the world writes them: the free-text details field some
// system releases keep, or its trait items, which are how a monster's traits and a
// character's racial and class features are written. `undefined` says the world holds
// no traits to show.
function foundryTraits(source, items) {
const text = plainText(source.system?.details?.trait);
if (text) return text;
const features = items
.filter((item) => item.type === 'feat' && stringList(item.system?.featType?.value ?? item.system?.featType)
.some((type) => asText(type).toLowerCase().startsWith('tr')))
.map((item) => {
const name = asText(item.name).trim();
const description = plainText(item.system?.description?.value ?? item.system?.description);
return name ? `${name}\n${description}`.trim() : '';
})
.filter(Boolean);
return features.length ? features.join('\n\n') : undefined;
}
function foundryActorToCharacter(foundryActor) { function foundryActorToCharacter(foundryActor) {
const system = foundryActor.system || {}; const system = foundryActor.system || {};
const details = system.details || {}; const details = system.details || {};
@@ -43,7 +150,7 @@ function foundryActorToCharacter(foundryActor) {
...stringList(traits.tool?.value) ...stringList(traits.tool?.value)
].join(', '); ].join(', ');
return { const fields = {
name: asText(foundryActor.name).trim(), name: asText(foundryActor.name).trim(),
type: ['character', 'npc', 'creature'].includes(savedDragonrollType) type: ['character', 'npc', 'creature'].includes(savedDragonrollType)
? savedDragonrollType ? savedDragonrollType
@@ -56,24 +163,48 @@ function foundryActorToCharacter(foundryActor) {
challengeRating: String(details.cr ?? ''), challengeRating: String(details.cr ?? ''),
description: plainText(details.biography?.value || details.biography), description: plainText(details.biography?.value || details.biography),
image: asText(foundryActor.img || foundryActor.image), image: asText(foundryActor.img || foundryActor.image),
abilityScores: Object.fromEntries(['str', 'dex', 'con', 'int', 'wis', 'cha'].map((key) => [ abilityScores: Object.fromEntries(ABILITIES.map((key) => [
key, key,
numberOr(abilities[key]?.value, 10) numberOr(abilities[key]?.value, 10)
])), ])),
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),
traits: asText(savedDragonrollFields.traits), // 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),
weight: numberOr(item.system?.weight?.value ?? item.system?.weight, 0) weight: numberOr(item.system?.weight?.value ?? item.system?.weight, 0),
icon: asText(item.img).trim()
})) }))
.filter((item) => item.name), .filter((item) => item.name),
spells: items.filter((item) => item.type === 'spell').map((item) => asText(item.name)).filter(Boolean).join('\n') spells: items.filter((item) => item.type === 'spell').map((item) => asText(item.name)).filter(Boolean).join('\n')
}; };
// What the world says about each of these, when it says anything: leaving a field
// out of the character is what keeps a live Foundry edit from clearing what the
// campaign toggled or wrote for it. Traits lead from the world when it has them, the
// way the proficiencies do; the text the module carries back on its flag is what the
// tab shows for an actor the world says nothing about.
const skills = foundrySkills(system);
if (skills) fields.skills = skills;
const savingThrows = foundrySavingThrows(system);
if (savingThrows) fields.savingThrows = savingThrows;
const tools = foundryTraitNames(foundryActor, 'tools');
if (tools) fields.tools = tools;
const languages = foundryTraitNames(foundryActor, 'languages');
if (languages) fields.languages = languages;
const currency = foundryCurrency(system);
if (currency) fields.currency = currency;
const worldTraits = foundryTraits(foundryActor, items);
const campaignTraits = asText(savedDragonrollFields.traits);
if (worldTraits || campaignTraits) fields.traits = worldTraits || campaignTraits;
return fields;
} }
module.exports = { foundryActorToCharacter }; module.exports = { foundryActorToCharacter };

View File

@@ -0,0 +1,110 @@
// Foundry's core icon library is the `icons/` folder of its data directory: a few
// thousand images spread over its own folder tree. Dragonroll never reads that
// tree itself — the bridge on the Foundry host lists one folder per request (see
// dragonroll-foundry/bridge/server.js) — but everything that goes over the wire is
// normalised here first, so a caller cannot ask for a folder outside the icon root.
const ICON_ROOT = 'icons';
// Image formats Foundry's own file picker offers.
const ICON_EXTENSIONS = ['.svg', '.png', '.webp', '.jpg', '.jpeg', '.gif', '.avif'];
// How many icons one request lists. The window asks again for the next page, so a
// folder with hundreds of them is never sent or rendered all at once.
const DEFAULT_ICON_PAGE_SIZE = 120;
const MAX_ICON_PAGE_SIZE = 500;
// The folder a listing request asks for, inside the icon root: `icons`, `icons/svg`,
// ... Empty asks for the root. Anything that tries to leave the root is invalid.
function normalizeIconDirectory(input) {
const raw = String(input ?? '').trim().replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
if (!raw || raw === '.') return ICON_ROOT;
const segments = raw.split('/').filter((segment) => segment && segment !== '.');
if (!segments.length || segments.includes('..')) return null;
if (segments[0] !== ICON_ROOT) return null;
return segments.join('/');
}
// The folder above an icon folder, or null at the root.
function parentIconDirectory(dir) {
const normalized = normalizeIconDirectory(dir);
if (!normalized || normalized === ICON_ROOT) return null;
return normalized.slice(0, normalized.lastIndexOf('/'));
}
function iconName(filePath) {
const path = String(filePath ?? '');
return path.slice(path.lastIndexOf('/') + 1);
}
function isIconFile(filePath) {
const lower = String(filePath ?? '').toLowerCase();
return ICON_EXTENSIONS.some((extension) => lower.endsWith(extension));
}
// Where the browser loads a Foundry data file from: Foundry serves its data
// directory over the world's own address, which is the one the campaign keeps
// (settings.integrations.foundryUrl). Items store icons as these absolute URLs,
// the same way a synced Foundry item's icon arrives as one.
function joinFoundryAssetUrl(baseUrl, filePath) {
const base = String(baseUrl ?? '').trim();
const file = String(filePath ?? '').trim().replace(/^\/+/, '');
if (!base || !file) return '';
return `${base.replace(/\/+$/, '')}/${encodeURI(file)}`;
}
// The page a request asks for. Directories are always listed whole — the window
// needs every subfolder to navigate — so paging only ever covers the icons.
function readIconListingPage(query) {
const requestedLimit = Number(query?.limit);
const limit = Number.isFinite(requestedLimit)
? Math.min(MAX_ICON_PAGE_SIZE, Math.max(1, Math.trunc(requestedLimit)))
: DEFAULT_ICON_PAGE_SIZE;
const requestedOffset = Number(query?.offset);
const offset = Number.isFinite(requestedOffset) ? Math.max(0, Math.trunc(requestedOffset)) : 0;
return { limit, offset };
}
// The bridge answers with plain relative paths; this is the shape the icon window
// works with: the folder it shows, the one above it, its subfolders, and its icons
// with a url to load. `next` is the offset of the next page, null once it is all
// listed, which is what keeps a big library lazy to load.
function shapeIconListing({ base = '', dir, listing = {} } = {}) {
const current = normalizeIconDirectory(dir ?? listing.dir) || ICON_ROOT;
const folders = [];
const seenFolders = new Set();
for (const entry of Array.isArray(listing.directories) ? listing.directories : []) {
const path = normalizeIconDirectory(typeof entry === 'string' ? entry : entry?.path);
if (!path || path === current || seenFolders.has(path)) continue;
seenFolders.add(path);
folders.push({ path, name: iconName(path) });
}
const files = (Array.isArray(listing.files) ? listing.files : [])
.map((entry) => String(typeof entry === 'string' ? entry : entry?.path ?? '').trim().replace(/^\/+/, ''))
.filter((entry) => entry.startsWith(`${ICON_ROOT}/`) && isIconFile(entry))
.map((entry) => ({ path: entry, name: iconName(entry), url: joinFoundryAssetUrl(base, entry) }));
const offset = Number.isFinite(Number(listing.offset)) ? Math.max(0, Math.trunc(Number(listing.offset))) : 0;
const next = Number.isFinite(Number(listing.next)) && Number(listing.next) > offset
? Math.trunc(Number(listing.next))
: null;
return { dir: current, parent: parentIconDirectory(current), folders, files, offset, next };
}
module.exports = {
ICON_ROOT,
ICON_EXTENSIONS,
DEFAULT_ICON_PAGE_SIZE,
MAX_ICON_PAGE_SIZE,
normalizeIconDirectory,
parentIconDirectory,
iconName,
isIconFile,
joinFoundryAssetUrl,
readIconListingPage,
shapeIconListing
};

View File

@@ -1,5 +1,11 @@
async function requestFoundry(path) { async function requestFoundry(path) {
const baseUrl = process.env.FOUNDRY_API_URL; // The bridge a campaign's icon and world reads go to is the very one that
// world already pushes its snapshot to. It is often configured under
// FOUNDRY_API_CLIENT_URL alone — the address the Foundry client reaches —
// while FOUNDRY_API_URL is the optional private one the backend prefers.
// Falling back to it keeps a connected, syncing world's reads working
// instead of reporting its bridge as unset (Syndria98/dragonroll#74).
const baseUrl = process.env.FOUNDRY_API_URL || process.env.FOUNDRY_API_CLIENT_URL;
const token = process.env.FOUNDRY_API_TOKEN; const token = process.env.FOUNDRY_API_TOKEN;
if (!baseUrl || !token) { if (!baseUrl || !token) {

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

@@ -13,12 +13,14 @@ Discord server B ──link──▶ Dragonroll campaign "Silang" (account g
## Commands ## Commands
- `/characters [type]` lists the linked campaign's actors, optionally filtered to characters, NPCs, or creatures. - `/characters [type]` lists the linked campaign's actors, optionally filtered to characters, NPCs, or creatures. Each one that a player has claimed with `/dragonroll assign` shows that player next to it.
- `/character name public:true` shows the matching actor's portrait (when one has been uploaded), profile, ability scores, combat stats, proficiencies, traits, spells, and inventory. Type part of a name to pick it from the campaign's current roster. Set `public` to `true` to show the reply to everyone in the channel. - `/character name public:true` shows the matching actor's portrait (when one has been uploaded), profile, ability scores, combat stats, proficiencies, traits, spells, and inventory. Type part of a name to pick it from the campaign's current roster. Set `public` to `true` to show the reply to everyone in the channel.
- `/dragonroll connect` starts a short-lived Dragonroll sign-in and authorization link, and confirms here once somebody authorizes the server. - `/dragonroll connect` starts a short-lived Dragonroll sign-in and authorization link, and confirms here once somebody authorizes the server.
- `/dragonroll link` lets a server administrator choose a campaign owned by the connected Dragonroll account. Type part of a campaign name to filter the choices. - `/dragonroll link` lets a server administrator choose a campaign owned by the connected Dragonroll account. Type part of a campaign name to filter the choices.
- `/dragonroll unlink` removes this server’s campaign link. - `/dragonroll unlink` removes this server’s campaign link.
- `/dragonroll status` shows the campaign linked to this server. - `/dragonroll status` shows the campaign linked to this server, and the character linked to your Discord account on it.
- `/dragonroll assign character` links that character of the campaign to your Discord account: each player holds one character, so claiming a second one frees the first. Anyone can take a free character; only a server administrator can take a character another player already holds.
- `/dragonroll unassign [character]` removes a character link. Without the option you give up your own character; naming somebody else’s character takes it off them, which only a server administrator can do.
- `/dragonroll refresh` rechecks the current connection and campaign in Dragonroll. - `/dragonroll refresh` rechecks the current connection and campaign in Dragonroll.
Replies are private by default. `/character` can be made public with its `public` option, so everyone in the channel can see the character sheet. Replies are private by default. `/character` can be made public with its `public` option, so everyone in the channel can see the character sheet.

View File

@@ -51,7 +51,24 @@ const commands = [
.setDescription('Show the campaign linked to this server.')) .setDescription('Show the campaign linked to this server.'))
.addSubcommand((subcommand) => subcommand .addSubcommand((subcommand) => subcommand
.setName('refresh') .setName('refresh')
.setDescription('Refresh this server’s Dragonroll connection status.'))) .setDescription('Refresh this server’s Dragonroll connection status.'))
.addSubcommand((subcommand) => subcommand
.setName('assign')
.setDescription('Link one character of the campaign to your Discord account.')
.addStringOption((option) => option
.setName('character')
.setDescription('Character to play (pick it from the campaign roster).')
.setRequired(true)
.setMaxLength(100)
.setAutocomplete(true)))
.addSubcommand((subcommand) => subcommand
.setName('unassign')
.setDescription('Remove the link between a character and a Discord player.')
.addStringOption((option) => option
.setName('character')
.setDescription('Character to free (yours by default, anyone’s as a server administrator).')
.setMaxLength(100)
.setAutocomplete(true))))
]; ];
module.exports = commands; module.exports = commands;

View File

@@ -123,7 +123,32 @@ function createDragonrollApi(config) {
return { campaign, actors: payload.actors }; return { campaign, actors: payload.actors };
} }
return { startAuthorization, claimLinkNotifications, getStatus, getCampaign, listCampaigns, linkCampaign, unlinkCampaign, listActors }; // Linking players to characters (Syndria98/dragonroll#72). `admin` says
// whether the Discord side already checked the person is a server
// administrator, who may move a character somebody else holds.
async function assignActor(guildId, { actorId, discordUserId, admin = false }) {
const payload = await request(`/discord/bot/guild/${encodeURIComponent(guildId)}/actors/assign`, {
method: 'POST',
body: JSON.stringify({ actorId, discordUserId: String(discordUserId), admin })
});
if (!payload.actor) throw new Error('Dragonroll returned an invalid character link.');
return { actor: payload.actor, previous: payload.previous ?? null };
}
async function unassignActor(guildId, { actorId, discordUserId, admin = false }) {
const payload = await request(`/discord/bot/guild/${encodeURIComponent(guildId)}/actors/unassign`, {
method: 'POST',
body: JSON.stringify({
discordUserId: String(discordUserId),
...(actorId ? { actorId } : {}),
admin
})
});
if (!payload.actor) throw new Error('Dragonroll returned an invalid character link.');
return { actor: payload.actor, wasYours: payload.wasYours === true };
}
return { startAuthorization, claimLinkNotifications, getStatus, getCampaign, listCampaigns, linkCampaign, unlinkCampaign, listActors, assignActor, unassignActor };
} }
module.exports = { createDragonrollApi, CampaignNotLinkedError, DragonrollNotConnectedError }; module.exports = { createDragonrollApi, CampaignNotLinkedError, DragonrollNotConnectedError };

View File

@@ -234,6 +234,20 @@ async function main() {
: 'Not linked yet.' } : 'Not linked yet.' }
); );
// The campaign's character linked to this Discord account (#72), when there is one.
if (status.campaign) {
try {
const { actors } = await dragonroll.listActors(guildId);
const yours = actors.find((actor) => String(actor.discordUserId ?? '') === interaction.user.id);
embed.addFields({
name: 'Your character',
value: yours ? safeField(yours.name, 100) : 'None. Run /dragonroll assign to link one to your Discord account.'
});
} catch {
// The roster is a bonus of this card, which stays useful without it.
}
}
if (!status.connected) { if (!status.connected) {
embed.setDescription('A server administrator can run /dragonroll connect to connect a Dragonroll account.'); embed.setDescription('A server administrator can run /dragonroll connect to connect a Dragonroll account.');
} else if (!status.campaign) { } else if (!status.campaign) {
@@ -243,6 +257,78 @@ async function main() {
await respond(interaction, { embeds: [embed] }); await respond(interaction, { embeds: [embed] });
} }
// /dragonroll assign and unassign (Syndria98/dragonroll#72): each player of the
// server holds one character of the linked campaign. Anyone claims a free
// character for themselves; server administrators also move and free the ones
// somebody else holds.
async function handleActorAssignment(interaction, guildId, subcommand) {
const isAdmin = interaction.memberPermissions?.has(PermissionFlagsBits.Administrator) === true;
const name = interaction.options.getString('character');
const { actors } = await dragonroll.listActors(guildId);
// Unassign without a character gives up the one linked to you.
if (subcommand === 'unassign' && !name) {
const mine = actors.find((actor) => String(actor.discordUserId ?? '') === interaction.user.id);
if (!mine) {
await respond(interaction, { content: 'You do not have a character linked to your Discord account here. Run `/dragonroll assign` to claim one.' });
return;
}
await dragonroll.unassignActor(guildId, { discordUserId: interaction.user.id });
await respond(interaction, { content: `You are no longer linked to **${safeField(mine.name, 100)}**.` });
return;
}
const result = findActor(actors, name);
if (!result.actor) {
await respond(interaction, {
content: result.matches?.length
? safeField(`Several characters match **${name}**: ${result.matches.slice(0, 15).map((actor) => actor.name).join(', ')}. Try a more specific name.`, 1800)
: safeField(`I couldn't find a character named **${name}**. Try \`/characters\` to see the campaign roster.`, 1800)
});
return;
}
const actor = result.actor;
const holder = String(actor.discordUserId ?? '');
if (subcommand === 'assign') {
if (holder === interaction.user.id) {
await respond(interaction, { content: `You are already linked to **${safeField(actor.name, 100)}**.` });
return;
}
if (holder && !isAdmin) {
await respond(interaction, { content: `**${safeField(actor.name, 100)}** is already linked to <@${holder}>. A server administrator can give it away and take it with the same command.` });
return;
}
const { previous } = await dragonroll.assignActor(guildId, {
actorId: String(actor._id),
discordUserId: interaction.user.id,
admin: isAdmin
});
const lines = [`You are now linked to **${safeField(actor.name, 100)}**.`];
if (holder) lines.push(`That character was linked to <@${holder}>; the link is removed.`);
if (previous) lines.push(`Your previous character, **${safeField(previous.name, 100)}**, is free again.`);
await respond(interaction, { content: safeField(lines.join('\n'), 1800) });
return;
}
// Unassign with a character named: your own, or anybody's as an administrator.
if (!holder) {
await respond(interaction, { content: `**${safeField(actor.name, 100)}** does not have a linked Discord player.` });
return;
}
if (holder !== interaction.user.id && !isAdmin) {
await respond(interaction, { content: `**${safeField(actor.name, 100)}** is linked to <@${holder}>. Only a server administrator can unlink it.` });
return;
}
await dragonroll.unassignActor(guildId, { actorId: String(actor._id), discordUserId: interaction.user.id, admin: isAdmin });
await respond(interaction, {
content: holder === interaction.user.id
? `You are no longer linked to **${safeField(actor.name, 100)}**.`
: `**${safeField(actor.name, 100)}** is no longer linked to <@${holder}>.`
});
}
client.once(Events.ClientReady, (readyClient) => { client.once(Events.ClientReady, (readyClient) => {
console.log(`Dragonroll character bot is online as ${readyClient.user.tag}, in ${readyClient.guilds.cache.size} servers.`); console.log(`Dragonroll character bot is online as ${readyClient.user.tag}, in ${readyClient.guilds.cache.size} servers.`);
// Guild commands registered when the bot joined shadow global ones and // Guild commands registered when the bot joined shadow global ones and
@@ -331,9 +417,16 @@ async function main() {
await respondActorChoices(interaction, guildId); await respondActorChoices(interaction, guildId);
return; return;
} }
if (interaction.commandName === 'dragonroll' && interaction.options.getSubcommand() === 'link') { if (interaction.commandName === 'dragonroll') {
await respondCampaignChoices(interaction, guildId); const subcommand = interaction.options.getSubcommand();
return; if (subcommand === 'link') {
await respondCampaignChoices(interaction, guildId);
return;
}
if (['assign', 'unassign'].includes(subcommand)) {
await respondActorChoices(interaction, guildId);
return;
}
} }
return; return;
} }
@@ -412,6 +505,34 @@ async function main() {
return; return;
} }
// Players link themselves to a character of the campaign (Syndria98/dragonroll#72).
if (['assign', 'unassign'].includes(subcommand)) {
await interaction.deferReply({ flags: MessageFlags.Ephemeral });
try {
await handleActorAssignment(interaction, guildId, subcommand);
} catch (error) {
if (error instanceof DragonrollNotConnectedError) {
await explainNotConnected(interaction, guildId);
return;
}
if (error instanceof CampaignNotLinkedError) {
await explainMissingCampaign(interaction, guildId);
return;
}
if (error.code === 'discord.errors.actor-held') {
await respond(interaction, { content: 'That character is already linked to another player. A server administrator can give it away and take it with the same command.' });
return;
}
if (error.status === 401 || error.message.includes('DRAGONROLL_DISCORD_BOT_SECRET')) {
await respond(interaction, { content: 'The bot API secret is missing or does not match the backend. Contact the bot operator.' });
return;
}
console.error(`Could not ${subcommand} a character link in Discord server ${guildId}:`, error.message);
await respond(interaction, { content: 'I could not change that character link right now. Please try again.' });
}
return;
}
await interaction.deferReply({ flags: MessageFlags.Ephemeral }); await interaction.deferReply({ flags: MessageFlags.Ephemeral });
await showStatus(interaction, guildId); await showStatus(interaction, guildId);
return; return;
@@ -442,7 +563,10 @@ async function main() {
const details = [actor.species, actor.className, actor.level ? `Lv. ${actor.level}` : null] const details = [actor.species, actor.className, actor.level ? `Lv. ${actor.level}` : null]
.filter(Boolean) .filter(Boolean)
.join(' · '); .join(' · ');
return `• **${actor.name}**${details ? ` — ${details}` : ''}`; // The player a character is linked to (#72); mentions never ping
// here, the replies parse no mentions.
const player = actor.discordUserId ? ` 🎮 <@${actor.discordUserId}>` : '';
return `• **${actor.name}**${details ? ` — ${details}` : ''}${player}`;
}); });
const embed = new EmbedBuilder() const embed = new EmbedBuilder()
.setTitle(`Characters of ${campaign.name}`) .setTitle(`Characters of ${campaign.name}`)

View File

@@ -82,25 +82,28 @@ The optional read-only snapshot bridge is not affected: it keeps publishing the
### Items ### Items
The campaign's Item list is synchronized with the world's gear, both ways: The campaign's Item list mirrors the world's item directory (Foundry's **items tab**) and nothing
else (Syndria98/dragonroll#67):
- The GM sends the world item directory (`game.items`) with every snapshot, and world items created, - The GM sends the world item directory (`game.items`) with every snapshot, and world items created,
changed or deleted in Foundry are pushed as they happen. Items embedded in a character travel with changed or deleted in Foundry are pushed as they happen. The items embedded in a character are that
that character's snapshot instead. character's own inventory: they travel with its snapshot and stay on its sheet, so gear a character
- Gear is deduplicated by name: the same sword in the world directory and in three characters' merely carries does not stand in the campaign's item list.
inventories becomes one Dragonroll item. Names Dragonroll renames away from are remembered on the - A world item folds into a Dragonroll row that already carries its name — one a campaign made by hand,
item (`foundryNames`), so Foundry's copies keep folding into it rather than coming back as a or one it renamed away from and remembers (`foundryNames`) — instead of doubling it. Spells, classes,
duplicate. Spells, classes, subclasses, backgrounds, feats and species are not gear and are not subclasses, backgrounds, feats and species are not gear and are not imported.
imported.
- Foundry owns the fields it sends (category from the item type, rarity, quantity, weight, weapon - Foundry owns the fields it sends (category from the item type, rarity, quantity, weight, weapon
properties, description). An item made by hand in Dragonroll is created in the world's item properties, description). An item made by hand in Dragonroll is created in the world's item
directory on the next reconcile, mapped afterwards, and editing it in Dragonroll updates the Foundry directory on the next reconcile, mapped afterwards, and editing it in Dragonroll updates the Foundry
document. document.
- The folders grouping the world's item directory arrive in the campaign as its own item folders, tree
and nesting included, and the items are filed in them. A folder's **colour** goes the other way too:
what the GM colours in Foundry shows on the campaign's folder, and what the campaign colours lands on
the world's folder on the next reconcile (the world's document keeps its name and nesting either way).
- A full snapshot keeps Dragonroll edits on reconnect; live Foundry edits overwrite. Item removal is - A full snapshot keeps Dragonroll edits on reconnect; live Foundry edits overwrite. Item removal is
pruned only by a full snapshot, so a live item push never deletes anything. Deleting a synced item in pruned only by a full snapshot, so a live item push never deletes anything: only a full snapshot sees
Dragonroll removes its Foundry world copy on the next reconcile. Items that live only in an actor's the whole world directory and can tell which synced rows it has let go of. Deleting a synced item in
inventory are owned by that actor's snapshot: editing such an item in Dragonroll does not rewrite the Dragonroll removes its Foundry world copy on the next reconcile.
actor's copy.
The module calls these Dragonroll routes with the campaign sync token (no Dragonroll login): The module calls these Dragonroll routes with the campaign sync token (no Dragonroll login):
@@ -110,14 +113,15 @@ The module calls these Dragonroll routes with the campaign sync token (no Dragon
| `POST /api/foundry/sync/item-snapshot` | Live world item edits, upsert only | | `POST /api/foundry/sync/item-snapshot` | Live world item edits, upsert only |
| `POST /api/foundry/sync/item-delete` | A world item was deleted | | `POST /api/foundry/sync/item-delete` | A world item was deleted |
| `GET /api/foundry/sync/characters` | Characters to apply back in Foundry | | `GET /api/foundry/sync/characters` | Characters to apply back in Foundry |
| `GET /api/foundry/sync/items` | Items to apply back in Foundry | | `GET /api/foundry/sync/items` | Items, and the item folders with their Dragonroll colours, to apply back in Foundry |
| `GET /api/foundry/sync/status` | The campaign this world's token belongs to, for the module's pairing status | | `GET /api/foundry/sync/status` | The campaign this world's token belongs to, for the module's pairing status |
| `POST /api/foundry/sync/map` / `map-item` | Store an id mapping after creating a document | | `POST /api/foundry/sync/map` / `map-item` | Store an id mapping after creating a document |
| `POST /api/foundry/sync/delete` | An actor was deleted | | `POST /api/foundry/sync/delete` | An actor was deleted |
Foundry documents keep the Dragonroll id in the `dragonroll-foundry.actorId` / `dragonroll-foundry.itemId` Foundry documents keep the Dragonroll id in the `dragonroll-foundry.actorId` / `dragonroll-foundry.itemId`
flag, and world items are marked with `dragonroll-foundry.syncMutation` while Dragonroll writes them so flag, and world items are marked with `dragonroll-foundry.syncMutation` while Dragonroll writes them so
the write is not echoed back. the write is not echoed back. A folder colour is written with that folder held in the client's set of
folders being synced, for the same reason.
## 2. Run the bridge on the Foundry host ## 2. Run the bridge on the Foundry host
@@ -130,6 +134,9 @@ export DRAGONROLL_FOUNDRY_PUSH_TOKEN='replace-with-a-different-long-random-publi
export DRAGONROLL_FOUNDRY_ALLOWED_ORIGINS='https://vtt.example.com' export DRAGONROLL_FOUNDRY_ALLOWED_ORIGINS='https://vtt.example.com'
export DRAGONROLL_FOUNDRY_HOST='0.0.0.0' export DRAGONROLL_FOUNDRY_HOST='0.0.0.0'
export DRAGONROLL_FOUNDRY_PORT='8787' export DRAGONROLL_FOUNDRY_PORT='8787'
# Optional: the Foundry Data directory. With it the bridge can list the core
# `icons/` library Dragonroll's item icon browser shows.
export DRAGONROLL_FOUNDRY_DATA_PATH='/home/foundry/Foundry Data'
npm start --prefix foundry/bridge npm start --prefix foundry/bridge
``` ```
@@ -165,6 +172,7 @@ The backend exposes these JWT-protected routes when the optional snapshot bridge
| `GET /api/foundry/actors/:id/items` | Items embedded in an actor | | `GET /api/foundry/actors/:id/items` | Items embedded in an actor |
| `GET /api/foundry/items` | World-level items | | `GET /api/foundry/items` | World-level items |
| `GET /api/foundry/items/:id` | One world-level item | | `GET /api/foundry/items/:id` | One world-level item |
| `GET /api/foundry/icons?campaign=&dir=&offset=` | One folder of Foundry's core icon library |
The bridge exposes the matching routes under `/api/*`, plus `GET /health`. Data routes require The bridge exposes the matching routes under `/api/*`, plus `GET /health`. Data routes require
`Authorization: Bearer <read-token>`. Responses contain `{ status: "ok", data, world, syncedAt, `Authorization: Bearer <read-token>`. Responses contain `{ status: "ok", data, world, syncedAt,
@@ -172,6 +180,13 @@ ageSeconds, stale }`. The snapshot stays in memory; `stale` becomes true when th
received a GM heartbeat for more than two minutes. The bridge returns `503 foundry.not-ready` until a received a GM heartbeat for more than two minutes. The bridge returns `503 foundry.not-ready` until a
configured GM client has published its first snapshot. configured GM client has published its first snapshot.
The icon library is the one route that reads the disk instead of the snapshot: with
`DRAGONROLL_FOUNDRY_DATA_PATH` set, `GET /api/icons?dir=icons/svg&offset=120&limit=120` answers one
folder at a time — `{ status: "ok", dir, directories, files, offset, next }` of paths relative to the
data directory — and never reads outside `icons/`. `next` is the offset of the next page of icons, or
null once the folder is listed, which is how the campaign's icon browser keeps a library of thousands
lazy to load. Without that variable the route answers `503 foundry.errors.icons-unavailable`.
World-level items come from Foundry's `game.items`; actor inventories come from each actor's embedded World-level items come from Foundry's `game.items`; actor inventories come from each actor's embedded
items collection. The API returns plain document data snapshots. This is a read-only integration: it items collection. The API returns plain document data snapshots. This is a read-only integration: it
does not create or update Foundry documents, and it does not persist the bridge cache across restarts. does not create or update Foundry documents, and it does not persist the bridge cache across restarts.

View File

@@ -1,4 +1,6 @@
const http = require("node:http"); const http = require("node:http");
const fs = require("node:fs");
const path = require("node:path");
const { timingSafeEqual } = require("node:crypto"); const { timingSafeEqual } = require("node:crypto");
const host = process.env.DRAGONROLL_FOUNDRY_HOST || "0.0.0.0"; const host = process.env.DRAGONROLL_FOUNDRY_HOST || "0.0.0.0";
@@ -12,6 +14,9 @@ const allowedOrigins = new Set(
.filter(Boolean), .filter(Boolean),
); );
const maxBodySize = 50 * 1024 * 1024; const maxBodySize = 50 * 1024 * 1024;
// The Foundry Data directory, for listing the core `icons/` library. Optional:
// without it the bridge simply cannot answer icon listing requests.
const dataPath = (process.env.DRAGONROLL_FOUNDRY_DATA_PATH || "").trim();
if (!readToken || !pushToken) { if (!readToken || !pushToken) {
throw new Error("Set DRAGONROLL_FOUNDRY_READ_TOKEN and DRAGONROLL_FOUNDRY_PUSH_TOKEN before starting the bridge."); throw new Error("Set DRAGONROLL_FOUNDRY_READ_TOKEN and DRAGONROLL_FOUNDRY_PUSH_TOKEN before starting the bridge.");
@@ -106,6 +111,80 @@ function decodePathSegment(segment) {
} }
} }
// --- Core icon library -----------------------------------------------------
// Foundry keeps the icons it ships in the `icons/` folder of its data directory:
// thousands of images over a folder tree of their own. The campaign's icon window
// browses that tree, so the bridge lists one folder per request and pages the
// icons inside it. It never reads outside `icons/`.
const iconRoot = "icons";
const iconExtensions = new Set([".svg", ".png", ".webp", ".jpg", ".jpeg", ".gif", ".avif"]);
const defaultIconPageSize = 120;
const maxIconPageSize = 500;
function normalizeIconDirectory(input) {
const raw = String(input ?? "").trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
if (!raw || raw === ".") return iconRoot;
const segments = raw.split("/").filter((segment) => segment && segment !== ".");
if (!segments.length || segments.includes("..") || segments[0] !== iconRoot) return null;
return segments.join("/");
}
function readIconDirectory(dir, offset, limit) {
const root = path.resolve(dataPath, iconRoot);
const target = path.resolve(dataPath, dir);
if (target !== root && !target.startsWith(root + path.sep)) return null;
const directories = [];
const files = [];
for (const entry of fs.readdirSync(target, { withFileTypes: true })) {
const entryPath = path.posix.join(dir, entry.name);
if (entry.isDirectory()) directories.push(entryPath);
else if (entry.isFile() && iconExtensions.has(path.extname(entry.name).toLowerCase())) files.push(entryPath);
}
directories.sort((a, b) => a.localeCompare(b));
files.sort((a, b) => a.localeCompare(b));
const page = files.slice(offset, offset + limit);
return {
// Subfolders always come back whole: the window needs every one of them to
// navigate, and there are never many. Paging covers the icons.
directories,
files: page,
offset,
next: offset + page.length < files.length ? offset + page.length : null,
};
}
function sendIconListing(request, response) {
if (!dataPath) return sendJson(response, 503, { status: "error", msg: "foundry.errors.icons-unavailable" });
const params = new URL(request.url, "http://localhost").searchParams;
const dir = normalizeIconDirectory(params.get("dir"));
if (!dir) return sendJson(response, 400, { status: "error", msg: "errors.missing-data" });
const requestedLimit = Number(params.get("limit"));
const limit = Number.isFinite(requestedLimit)
? Math.min(maxIconPageSize, Math.max(1, Math.trunc(requestedLimit)))
: defaultIconPageSize;
const requestedOffset = Number(params.get("offset"));
const offset = Number.isFinite(requestedOffset) ? Math.max(0, Math.trunc(requestedOffset)) : 0;
try {
const listing = readIconDirectory(dir, offset, limit);
if (!listing) return sendJson(response, 400, { status: "error", msg: "errors.missing-data" });
sendJson(response, 200, { status: "ok", dir, ...listing });
} catch (error) {
if (error.code === "ENOENT" || error.code === "ENOTDIR") {
sendJson(response, 404, { status: "error", msg: "errors.notfound" });
return;
}
console.error(`Could not list the Foundry icon folder ${dir}.`, error);
sendJson(response, 500, { status: "error", msg: "foundry.errors.icons-unavailable" });
}
}
const server = http.createServer(async (request, response) => { const server = http.createServer(async (request, response) => {
if (!setCorsHeaders(request, response)) { if (!setCorsHeaders(request, response)) {
sendJson(response, 403, { status: "error", msg: "foundry.origin-not-allowed" }); sendJson(response, 403, { status: "error", msg: "foundry.origin-not-allowed" });
@@ -188,6 +267,10 @@ const server = http.createServer(async (request, response) => {
return; return;
} }
// The icon library is on disk, not in the world snapshot, so it answers whether
// or not a GM client has published one yet.
if (pathname === "/api/icons") return sendIconListing(request, response);
const current = currentSnapshot(response); const current = currentSnapshot(response);
if (!current) return; if (!current) return;

View File

@@ -34,7 +34,13 @@ let itemSyncErrorLogged = false;
let folderSyncTimeout; let folderSyncTimeout;
let folderSyncRunning = false; let folderSyncRunning = false;
const syncingItemIds = new Set(); const syncingItemIds = new Set();
const syncingFolderIds = new Set();
const queuedItemChanges = new Map(); const queuedItemChanges = new Map();
let wallSyncTimeout;
let mapSyncRunning = false;
let mapSyncErrorLogged = false;
const queuedWallSceneIds = new Set();
const applyingWallsSceneIds = new Set();
function getCollectionContents(collection, collectionName) { function getCollectionContents(collection, collectionName) {
if (!collection) { if (!collection) {
@@ -299,6 +305,7 @@ async function applyDragonrollLink(result) {
scheduleSnapshotSync(0); scheduleSnapshotSync(0);
setTimeout(initializeCharacterSync, 0); setTimeout(initializeCharacterSync, 0);
setTimeout(reconcileDragonrollItems, 2000); setTimeout(reconcileDragonrollItems, 2000);
setTimeout(reconcileDragonrollMaps, 2500);
} else { } else {
// Without a token this client cannot sync, and only a fresh link gives one. // Without a token this client cannot sync, and only a fresh link gives one.
linkProblem = "this client could not save the token it was given"; linkProblem = "this client could not save the token it was given";
@@ -440,6 +447,7 @@ function handleAutoSyncChange(value) {
clearTimeout(actorSyncTimeout); clearTimeout(actorSyncTimeout);
clearTimeout(itemSyncTimeout); clearTimeout(itemSyncTimeout);
clearTimeout(folderSyncTimeout); clearTimeout(folderSyncTimeout);
clearTimeout(wallSyncTimeout);
return; return;
} }
if (!game.user?.isGM || !getSyncToken()) return; if (!game.user?.isGM || !getSyncToken()) return;
@@ -449,6 +457,7 @@ function handleAutoSyncChange(value) {
initializeCharacterSync(); initializeCharacterSync();
reconcileDragonrollItems(); reconcileDragonrollItems();
queueFoundryItemFolders(400); queueFoundryItemFolders(400);
reconcileDragonrollMaps();
if (queuedActorChanges.size) { if (queuedActorChanges.size) {
clearTimeout(actorSyncTimeout); clearTimeout(actorSyncTimeout);
actorSyncTimeout = setTimeout(flushActorChanges, 400); actorSyncTimeout = setTimeout(flushActorChanges, 400);
@@ -457,6 +466,10 @@ function handleAutoSyncChange(value) {
clearTimeout(itemSyncTimeout); clearTimeout(itemSyncTimeout);
itemSyncTimeout = setTimeout(flushItemChanges, 400); itemSyncTimeout = setTimeout(flushItemChanges, 400);
} }
if (queuedWallSceneIds.size) {
clearTimeout(wallSyncTimeout);
wallSyncTimeout = setTimeout(flushFoundrySceneWalls, 400);
}
} }
function dragonrollActorId(actor) { function dragonrollActorId(actor) {
@@ -473,17 +486,65 @@ function serializeFoundryActor(actor) {
if (data.img && !/^(https?:|data:|\/\/)/i.test(data.img)) { if (data.img && !/^(https?:|data:|\/\/)/i.test(data.img)) {
data.img = new URL(data.img, window.location.origin).toString(); data.img = new URL(data.img, window.location.origin).toString();
} }
// Tools and languages travel by their names: what the actor holds are proficiency
// keys (and, since the third release of the system, language documents), which mean
// nothing to a sheet outside Foundry.
const names = { tools: foundryTraitNames(actor, "tools"), languages: foundryTraitNames(actor, "languages") };
if (names.tools || names.languages) data.dragonroll = { ...names };
return data; return data;
} }
// A proficiency list of `system.traits`: its keys resolved to the labels CONFIG gives
// them, plus whatever the GM typed as a proficiency of their own. `null` for an actor
// that has no such list, an empty array for one that has none of that kind. Dragonroll
// names its lists in full, while the world keeps its tools under `system.traits.tool`
// and its languages under `system.traits.languages`.
const TRAIT_FIELDS = { tools: "tool", languages: "languages" };
function foundryTraitNames(actor, kind) {
if (game.system?.id !== "dnd5e") return null;
const trait = actor.system?.traits?.[TRAIT_FIELDS[kind] ?? kind];
if (!trait || typeof trait !== "object") return null;
const names = (Array.isArray(trait.value) ? trait.value : [])
.map((key) => foundryProficiencyLabel(kind, key))
.filter(Boolean);
for (const custom of String(trait.custom ?? "").split(",")) {
const name = custom.trim();
if (name) names.push(name);
}
return [...new Set(names)];
}
function foundryProficiencyLabel(kind, key) {
if (typeof key !== "string" || !key) return "";
const entry = CONFIG.DND5E?.[kind === "languages" ? "languages" : "tools"]?.[key];
const label = entry?.label ?? entry?.name;
if (label) return String(label);
// A language the world added itself stands as a document of its own rather than in
// the system's config.
const document = kind === "languages" ? game.items?.get?.(key) : null;
if (document?.name) return String(document.name);
// The key beats dropping a proficiency the character really has.
return key;
}
function isSupportedCharacterActor(actor) { function isSupportedCharacterActor(actor) {
const savedType = actor.getFlag?.(MODULE_ID, "actorType") || actor.flags?.[MODULE_ID]?.actorType; const savedType = actor.getFlag?.(MODULE_ID, "actorType") || actor.flags?.[MODULE_ID]?.actorType;
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,
@@ -529,8 +590,9 @@ async function pushFoundryActors(actors, fullSync = false) {
const result = await postDragonroll("foundry/sync/snapshot", { const result = await postDragonroll("foundry/sync/snapshot", {
worldId: game.world.id, worldId: game.world.id,
actors: supportedActors.map(serializeFoundryActor), actors: supportedActors.map(serializeFoundryActor),
// Dragonroll deduplicates by name, so sending the world directory next to // The world item directory is what the campaign lists as its items
// the actor copies keeps a single Item per piece of gear. // (Syndria98/dragonroll#67); the gear a character carries travels inside that
// actor's snapshot as its inventory, not as campaign items.
items: getWorldItemSnapshots(), items: getWorldItemSnapshots(),
// The folder tree those world items stand in (see worldItemFolderSnapshots). // The folder tree those world items stand in (see worldItemFolderSnapshots).
folders: worldItemFolderSnapshots(), folders: worldItemFolderSnapshots(),
@@ -676,10 +738,23 @@ function isWorldItemFolder(folder, seen = new Set()) {
return isWorldItemFolder(parent, seen); return isWorldItemFolder(parent, seen);
} }
// A Foundry folder's colour, or null for one the GM left uncoloured. Null travels as null:
// it tells Dragonroll to take a colour off the folder it was given before, whereas a module
// that says nothing about colours at all leaves the campaign's own choice alone.
function itemFolderColor(folder) {
const color = typeof folder?.color === "string" ? folder.color.trim() : "";
return color || null;
}
function worldItemFolderSnapshots() { function worldItemFolderSnapshots() {
return (game.folders?.contents || []) return (game.folders?.contents || [])
.filter((folder) => isWorldItemFolder(folder)) .filter((folder) => isWorldItemFolder(folder))
.map((folder) => ({ id: folder.id, name: folder.name, parent: itemFolderParent(folder)?.id || null })); .map((folder) => ({
id: folder.id,
name: folder.name,
parent: itemFolderParent(folder)?.id || null,
color: itemFolderColor(folder),
}));
} }
// A world item travels with the folder it stands in, so Dragonroll can file it the // A world item travels with the folder it stands in, so Dragonroll can file it the
@@ -707,6 +782,35 @@ function getWorldItemSnapshots() {
return (game.items?.contents || []).map(serializeFoundryWorldItem).filter(Boolean); return (game.items?.contents || []).map(serializeFoundryWorldItem).filter(Boolean);
} }
// --- Folder colours ----------------------------------------------------------
// Colouring a folder is the one thing about the tree the campaign gets to do on its
// own: the world owns what the folders are called and how they nest, and Dragonroll
// owns the colour its user picks for one. So the colour travels back with the folder
// list the item reconcile reads, and lands on the world's folder — marked, like every
// Dragonroll write, so the world does not echo it straight back to the campaign.
async function withFolderSyncSuppressed(folder, callback) {
if (!folder?.id) return callback();
syncingFolderIds.add(folder.id);
try {
return await callback();
} finally {
syncingFolderIds.delete(folder.id);
}
}
async function applyDragonrollFolderColors(entries) {
for (const entry of entries || []) {
const folder = entry?.foundryFolderId ? game.folders?.get(entry.foundryFolderId) : null;
// Only the world's item directories: a Dragonroll folder the world has no document
// for is the campaign's business alone, and making one there is not ours to do.
if (!folder || folder.documentName !== "Folder" || !isWorldItemFolder(folder)) continue;
const color = entry.color || null;
if (itemFolderColor(folder) === color) continue;
await withFolderSyncSuppressed(folder, () => folder.update({ color }));
}
}
function dragonrollItemIdOf(item) { function dragonrollItemIdOf(item) {
return item.getFlag?.(MODULE_ID, "itemId") || item.flags?.[MODULE_ID]?.itemId || ""; return item.getFlag?.(MODULE_ID, "itemId") || item.flags?.[MODULE_ID]?.itemId || "";
} }
@@ -826,6 +930,239 @@ async function flushItemChanges() {
} }
} }
// --- Scene walls -----------------------------------------------------------
// A campaign map can mirror the walls of a Foundry scene: the whole set travels to whoever did
// not edit it, so the map's wall editor and the scene's wall tool see the same segments. The
// endpoints are image pixels of the scene's background there too, so a segment crosses unchanged.
// Walls need no D&D 5e — they are plain scene geometry — and unlike actors and items, a scene is
// never made or deleted here: only its walls are read and written.
// Wall endpoints are whole image pixels on either side, rounded the same way before a set is
// compared, written or sent, so a set that only differs in Foundry's float precision is still
// recognised as unchanged and no write is made for it.
function toWallPixel(value) {
return Math.max(0, Math.round(Number(value) || 0));
}
function toWallDoor(value) {
const door = Number(value) || 0;
return door === 1 || door === 2 ? door : 0;
}
// A Foundry wall in the campaign's shape: `sense` blocks sight, `move` passage, and a door is
// open or closed by its state (`ds`) — Foundry's locked doors read as closed.
function campaignWallFromFoundry(wall) {
const c = Array.from(wall?.c ?? []);
return {
x1: toWallPixel(c[0]),
y1: toWallPixel(c[1]),
x2: toWallPixel(c[2]),
y2: toWallPixel(c[3]),
move: (Number(wall?.move) || 0) !== 0,
sight: (Number(wall?.sense) || 0) !== 0,
door: Number(wall?.door) > 0 ? (Number(wall?.ds) === 1 ? 1 : 2) : 0,
};
}
function campaignWallFromSync(wall) {
return {
x1: toWallPixel(wall?.x1),
y1: toWallPixel(wall?.y1),
x2: toWallPixel(wall?.x2),
y2: toWallPixel(wall?.y2),
move: wall?.move !== false,
sight: wall?.sight !== false,
door: toWallDoor(wall?.door),
};
}
// A campaign wall in Foundry's own shape: blocking sight is its opaque wall (light and sense
// alike, the way the wall tool sets them), blocking movement its impassable one, and a door
// carries the open/closed state it has.
function foundryWallData(wall) {
const sight = wall?.sight !== false;
const door = toWallDoor(wall?.door);
return {
c: [
toWallPixel(wall?.x1),
toWallPixel(wall?.y1),
toWallPixel(wall?.x2),
toWallPixel(wall?.y2),
],
light: sight ? 2 : 0,
sense: sight ? 2 : 0,
move: wall?.move === false ? 0 : 1,
door,
ds: door === 1 ? 1 : 0,
};
}
// Whether the scene already stands with the campaign's set, both read in the campaign's shape.
function wallsMatch(localWalls, remoteWalls) {
if (localWalls.length !== remoteWalls.length) return false;
return remoteWalls.every((entry, index) => {
const wanted = campaignWallFromSync(entry);
const local = localWalls[index];
return ["x1", "y1", "x2", "y2", "move", "sight", "door"].every((key) => local?.[key] === wanted[key]);
});
}
function wallDocumentsOf(scene) {
return (scene?.wallDocuments?.contents || scene?.walls?.contents || []).slice();
}
function sceneWallSnapshots(scene) {
return wallDocumentsOf(scene).map(campaignWallFromFoundry);
}
function reportMapSyncError(error) {
if (mapSyncErrorLogged) return;
mapSyncErrorLogged = true;
console.warn(`${MODULE_ID} | Map sync failed and will retry.`, error);
}
// The scene a wall hook is about: Foundry v11 hands the Wall document and older versions the
// Scene, and both are taken for one.
function wallSceneFromHook(...hookArgs) {
for (const argument of hookArgs) {
if (argument?.documentName === "Scene") return argument;
if (argument?.documentName === "Wall") return argument.parent ?? null;
}
return null;
}
function queueFoundrySceneWalls(...hookArgs) {
const scene = wallSceneFromHook(...hookArgs);
if (!scene || !game.user?.isGM || !game.world || !getSyncToken()) return;
// Walls Dragonroll itself just wrote into the scene are not the GM editing them.
if (applyingWallsSceneIds.has(scene.id)) return;
queuedWallSceneIds.add(scene.id);
clearTimeout(wallSyncTimeout);
wallSyncTimeout = setTimeout(flushFoundrySceneWalls, 400);
}
async function flushFoundrySceneWalls() {
// Autosync off: the queued wall sets wait, like the item edits do.
if (!isAutoSyncEnabled()) return;
const sceneIds = [...queuedWallSceneIds];
queuedWallSceneIds.clear();
for (const sceneId of sceneIds) {
const scene = game.scenes?.get(sceneId);
if (!scene) continue;
try {
await pushFoundrySceneWalls(scene);
mapSyncErrorLogged = false;
} catch (error) {
// A scene no campaign map mirrors is the normal case — most of a world's scenes are
// none of the campaign's business — so it is not a failure worth retrying.
if (error.message === "errors.notfound") continue;
reportMapSyncError(error);
queuedWallSceneIds.add(sceneId);
}
}
if (queuedWallSceneIds.size) {
clearTimeout(wallSyncTimeout);
wallSyncTimeout = setTimeout(flushFoundrySceneWalls, 5000);
}
}
async function pushFoundrySceneWalls(scene) {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || !scene) return;
await postDragonroll("foundry/sync/map-walls", {
worldId: game.world.id,
foundrySceneId: scene.id,
walls: sceneWallSnapshots(scene),
}, token);
}
// The campaign's walls reconciled onto its maps: paired with a scene by name where they are not
// paired yet, and every paired scene brought to the campaign's set. Live wall edits in the scene
// run the other way — they push the scene's set to the campaign as they happen.
async function reconcileDragonrollMaps() {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || mapSyncRunning || !isAutoSyncEnabled()) return;
mapSyncRunning = true;
try {
const result = await getDragonroll("foundry/sync/maps", token);
const remoteMaps = result.maps || [];
const pairedSceneIds = new Set(remoteMaps.map((entry) => entry.foundrySceneId).filter(Boolean));
for (const entry of remoteMaps) {
let scene = entry.foundrySceneId ? game.scenes?.get(entry.foundrySceneId) : null;
if (!scene) {
// Pair by name, the way an unmapped item maps to the world document that shares its
// name — but only when map and scene are each other's only one with it: writing the
// walls into the wrong scene is not a mistake to make on an ambiguous name. A map
// whose paired scene is gone (deleted, or a copied world) is paired anew the same way.
const namesakes = (game.scenes?.contents || [])
.filter((candidate) => !pairedSceneIds.has(candidate.id)
&& candidate.name === String(entry.name).trim());
scene = namesakes.length === 1 ? namesakes[0] : null;
if (scene) {
pairedSceneIds.add(scene.id);
await postDragonroll("foundry/sync/map-scene", {
worldId: game.world.id,
mapId: String(entry._id),
foundrySceneId: scene.id,
}, token);
}
}
if (!scene) continue;
const localWalls = sceneWallSnapshots(scene);
const campaignWalls = Array.isArray(entry.walls) ? entry.walls : [];
// A map with no walls of its own adopts the walls the scene already has: they are the
// GM's work, and writing an empty set over them would undo it before the campaign's
// editor ever opened. Once both sides hold walls, the campaign's set rules the scene.
if (!campaignWalls.length && localWalls.length) {
await pushFoundrySceneWalls(scene);
continue;
}
await applyDragonrollWalls(scene, campaignWalls, localWalls);
}
mapSyncErrorLogged = false;
} catch (error) {
reportMapSyncError(error);
} finally {
mapSyncRunning = false;
}
}
// The campaign's whole set lands on the scene: segments are updated in place while a wall
// document exists for them, ones beyond the documents are made, and ones the campaign let go of
// are deleted. Marked as Dragonroll's own write while it runs, so the scene's wall hooks do not
// push the set straight back to the campaign.
async function applyDragonrollWalls(scene, walls, current = sceneWallSnapshots(scene)) {
if (wallsMatch(current, walls)) return;
const documents = wallDocumentsOf(scene);
const updates = [];
const creates = [];
for (const [index, wall] of walls.entries()) {
// A document that already stands where the campaign wants it is left alone; one index
// over the documents is made, and the ones the campaign let go of are deleted.
if (documents[index]) {
if (wallsMatch([campaignWallFromFoundry(documents[index])], [wall])) continue;
updates.push({ _id: documents[index].id, ...foundryWallData(wall) });
} else {
creates.push(foundryWallData(wall));
}
}
const deleteIds = documents.slice(walls.length).map((document) => document.id);
applyingWallsSceneIds.add(scene.id);
try {
if (updates.length) await scene.updateEmbeddedDocuments("Wall", updates);
if (creates.length) await scene.createEmbeddedDocuments("Wall", creates);
if (deleteIds.length) await scene.deleteEmbeddedDocuments("Wall", deleteIds);
} finally {
applyingWallsSceneIds.delete(scene.id);
}
}
const CATEGORY_TO_FOUNDRY_ITEM_TYPE = { const CATEGORY_TO_FOUNDRY_ITEM_TYPE = {
weapon: "weapon", weapon: "weapon",
armor: "equipment", armor: "equipment",
@@ -917,10 +1254,13 @@ async function reconcileDragonrollItems() {
if (!token || !game.user?.isGM || !game.world || itemSyncRunning || !isAutoSyncEnabled()) return; if (!token || !game.user?.isGM || !game.world || itemSyncRunning || !isAutoSyncEnabled()) return;
itemSyncRunning = true; itemSyncRunning = true;
try { try {
const result = await getDragonroll("foundry/sync/items", token);
// The folder colours are applied first, and whatever system this world runs: a
// colour is the same on every one of them, while writing an item is what needs D&D 5e.
await applyDragonrollFolderColors(result.folders);
if (game.system.id !== "dnd5e") { if (game.system.id !== "dnd5e") {
throw new Error("Item sync currently requires the D&D 5e Foundry system."); throw new Error("Item sync currently requires the D&D 5e Foundry system.");
} }
const result = await getDragonroll("foundry/sync/items", token);
const remoteItems = result.items || []; const remoteItems = result.items || [];
const remoteById = new Map(remoteItems.map((entry) => [String(entry._id), entry])); const remoteById = new Map(remoteItems.map((entry) => [String(entry._id), entry]));
const localByRemoteId = new Map(game.items.contents const localByRemoteId = new Map(game.items.contents
@@ -1106,7 +1446,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 };
@@ -1132,7 +1484,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);
} }
@@ -1340,6 +1693,8 @@ Hooks.once("ready", () => {
// already seen the world directory when it starts sending its own items back. // already seen the world directory when it starts sending its own items back.
setTimeout(reconcileDragonrollItems, 2000); setTimeout(reconcileDragonrollItems, 2000);
setInterval(reconcileDragonrollItems, 5000); setInterval(reconcileDragonrollItems, 5000);
setTimeout(reconcileDragonrollMaps, 2500);
setInterval(reconcileDragonrollMaps, 5000);
for (const event of [ for (const event of [
"createActor", "updateActor", "deleteActor", "createActor", "updateActor", "deleteActor",
@@ -1356,7 +1711,9 @@ Hooks.once("ready", () => {
} }
// 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.
if (document.documentName === "Folder") { if (document.documentName === "Folder") {
if (syncingFolderIds.has(document.id)) return;
if (document.type === "Item" && isWorldItemFolder(document)) queueFoundryItemFolders(); if (document.type === "Item" && isWorldItemFolder(document)) queueFoundryItemFolders();
return; return;
} }
@@ -1371,6 +1728,13 @@ Hooks.once("ready", () => {
queueFoundryItemChange(isDelete ? "delete" : "upsert", document); queueFoundryItemChange(isDelete ? "delete" : "upsert", document);
}); });
} }
// A GM's wall edit sends the scene's whole set to the campaign map mirroring it,
// debounced like the item changes: dragging a wall fires an update per move.
// Scenes no campaign map mirrors answer `notfound`, and the queue lets those go.
for (const event of ["createWall", "updateWall", "deleteWall"]) {
Hooks.on(event, (...args) => queueFoundrySceneWalls(...args));
}
}); });
// A GM sends selected actors to Dragonroll from the actor directory's context // A GM sends selected actors to Dragonroll from the actor directory's context

View File

@@ -1,43 +1,6 @@
<script setup lang="ts"> <script setup lang="ts">
import ContentManager from './components/managers/ContentManager.vue'; // El que es veu és la pàgina que toca (app/pages): /docs porta la documentació, i la
import ToastManager from './components/managers/ToastManager.vue'; // resta de rutes obren l'aplicació de finestres. Aquí només hi ha el que és de tot el lloc.
import WindowManager from './components/managers/WindowManager.vue';
import ServiceLinkAuthorize from './components/views/ServiceLinkAuthorize.vue';
import { CreateWindow } from '@/services/Windows'
import { GetUser, HasAdmin } from './services/User';
import TooltipManager from './components/managers/TooltipManager.vue';
import ContextMenuManager from './components/managers/ContextMenuManager.vue';
import { useCampaignService } from './services/Campaign';
const { RestoreCampaign } = useCampaignService();
// Els serveis (Discord, Foundry, Obsidian) enllacen amb aquesta pantalla única; no són part
// de l'aplicació i no han d'arrencar les finestres normals. La ruta antiga de Discord també
// hi porta, perquè els enllaços que ja corren per Discord no queden morts.
const requestUrl = useRequestURL();
const isServiceLink = computed(() => {
const path = requestUrl.pathname.replace(/\/+$/, '');
return path === '/link/authorize' || path === '/discord/authorize';
});
async function start(){
if(GetUser()){
const restoredCampaign = await RestoreCampaign();
if (!restoredCampaign) {
CreateWindow('main_menu');
}
return;
}
if(await HasAdmin()){
CreateWindow('login');
} else {
CreateWindow('register', {firstTime: true});
}
// DisplayToast('aqua', 'All plugins loaded successfully');
}
useHead({ useHead({
title: 'Dragonroll', title: 'Dragonroll',
meta: [ meta: [
@@ -50,29 +13,9 @@ useHead({
onMounted(() => { onMounted(() => {
setupTheme(); setupTheme();
setTheme('dark'); setTheme('dark');
if(!isServiceLink.value){
start();
}
}) })
</script> </script>
<template> <template>
<ServiceLinkAuthorize v-if="isServiceLink"></ServiceLinkAuthorize> <NuxtPage></NuxtPage>
<div v-else class="viewer">
<ToastManager></ToastManager>
<TooltipManager></TooltipManager>
<ContextMenuManager></ContextMenuManager>
<WindowManager></WindowManager>
<ContentManager></ContentManager>
<!-- Managers -->
</div>
</template> </template>
<style scoped>
.viewer {
display: flex;
flex-direction: column;
width: 100%;
height: 100vh;
}
</style>

View File

@@ -30,9 +30,19 @@ $themes: (
container-shadow: #151d28, container-shadow: #151d28,
sticky-header-bg: #20202077, sticky-header-bg: #20202077,
red: #e06c75, // Quoted: red/green/gray are also Sass colour keywords, so unquoted they are parsed as
green: #98c379, // colour values, and interpolating one into `--color-#{$name}` warns
gray: #cccccc, // (Syndria98/dragonroll#71).
"red": #e06c75,
"green": #98c379,
"gray": #cccccc,
// The rarity of an item colours its row in the sidebar (Syndria98/dragonroll#63).
rarity-common: #ffffff,
rarity-uncommon: #1eff00,
rarity-rare: #2f81f7,
rarity-very-rare: #a855f7,
rarity-legendary: #ff8000,
icon-invert: 100%, icon-invert: 100%,
@@ -68,9 +78,17 @@ $themes: (
container-shadow: #5f6774, container-shadow: #5f6774,
sticky-header-bg: #fff, sticky-header-bg: #fff,
red: #e06c75, // Quoted for the same reason as in the dark map.
green: #98c379, "red": #e06c75,
gray: #cccccc, "green": #98c379,
"gray": #cccccc,
// Same rarities as the dark map, darkened to stay readable on a light background.
rarity-common: #1e1e1e,
rarity-uncommon: #157f2b,
rarity-rare: #1d4ed8,
rarity-very-rare: #7e22ce,
rarity-legendary: #c05621,
icon-invert: 0%, icon-invert: 0%,

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

@@ -8,6 +8,7 @@ import { emitter } from '~/services/Emitter';
import { BuildColorMenu } from '~/services/EntryColors'; import { BuildColorMenu } from '~/services/EntryColors';
import { BuildItemRows } from '~/services/ItemFolders'; import { BuildItemRows } from '~/services/ItemFolders';
import Server, { getBaseUrl } from '~/services/Server'; import Server, { getBaseUrl } from '~/services/Server';
import { DisplayToast } from '~/services/Toaster';
import { ClearWindow, CreateWindow, GetFirstWindowId } from '~/services/Windows'; import { ClearWindow, CreateWindow, GetFirstWindowId } from '~/services/Windows';
import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu'; import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu';
import { ACTOR_DRAG_TYPE } from '~/services/MapTokens'; import { ACTOR_DRAG_TYPE } from '~/services/MapTokens';
@@ -29,6 +30,9 @@ const entryFolders = { actor: ref([]), item: ref([]), map: ref([]) };
const collapsedFolderIds = ref([]); const collapsedFolderIds = ref([]);
const loadingNotes = ref(false); const loadingNotes = ref(false);
const loadingEntries = ref(false); const loadingEntries = ref(false);
// An import of the whole linked world takes a moment, and clicking the row again while
// it runs must not start a second one.
const importingFoundry = ref(false);
const notesError = ref(''); const notesError = ref('');
const entriesError = ref(''); const entriesError = ref('');
const sidebarCollapsed = ref(false); const sidebarCollapsed = ref(false);
@@ -279,8 +283,13 @@ function entrySummary(actor) {
return bits.join(' · '); return bits.join(' · ');
} }
function itemSummary(item) { // The rarity of an item colours the text of its row instead of listing category, rarity and
return `${t(`campaigns.item.categories.${item.category}`)} · ${t(`campaigns.item.rarities.${item.rarity}`)} · ${t('campaigns.item.quantity-short')} ${item.quantity}`; // quantity (Syndria98/dragonroll#63): common white, uncommon green, rare blue, very rare purple,
// legendary orange. Anything else (artifact) keeps the default text colour.
function rarityClass(item) {
return ['common', 'uncommon', 'rare', 'very-rare', 'legendary'].includes(item.rarity)
? `rarity-${item.rarity}`
: '';
} }
// An item's icon in the sidebar: an uploaded filename served from /api/public, or a full URL // An item's icon in the sidebar: an uploaded filename served from /api/public, or a full URL
@@ -304,6 +313,35 @@ function editMap(map) {
CreateWindow('create_map', { campaign: campaignId.value, entry: map }); CreateWindow('create_map', { campaign: campaignId.value, entry: map });
} }
// The one sidebar action that asks the linked world instead of the campaign's own rows
// (Syndria98/dragonroll#77): the backend reads what the Foundry bridge is showing and
// writes every actor or item of it through the writers a sync push uses, so the rows
// the campaign already has are written over and only the world's new ones are made.
// The list is read back once the answer is in, so whatever arrived is on screen, and
// the toast says how the world landed.
async function forceImportFromFoundry(entityType) {
const section = sectionForTarget(entityType);
if (!campaignId.value || !section || importingFoundry.value) return;
importingFoundry.value = true;
try {
const response = await Server().post('/foundry/import', { campaign: campaignId.value, kind: section });
if (response.data.status !== 'ok') {
DisplayToast('red', t(response.data.msg || 'campaigns.foundry-import.error'), 3000);
return;
}
DisplayToast('green', t('campaigns.foundry-import.done', {
imported: response.data.imported ?? 0,
updated: response.data.updated ?? 0
}), 3000);
await fetchCampaignEntries(section);
} catch (error) {
DisplayToast('red', t('campaigns.foundry-import.error'), 3000);
} finally {
importingFoundry.value = false;
}
}
function showEntryMenu(entry, entityType) { function showEntryMenu(entry, entityType) {
const list = entryLists[entityType]; const list = entryLists[entityType];
const menuItems = []; const menuItems = [];
@@ -323,6 +361,18 @@ function showEntryMenu(entry, entityType) {
}); });
} }
// The actor and item lists mirror a linked Foundry world, so their rows also offer
// to pull the whole world over: this row is not sent or fetched on its own, the
// section's whole list is imported and the rows already in it are only updated.
if (entityType === 'actor' || entityType === 'item') {
menuItems.push({ divider: true });
menuItems.push({
name: t('campaigns.foundry-import.run'),
icon: '/icons/iconoir/regular/import.svg',
action: () => { HideContextMenu(); forceImportFromFoundry(entityType); }
});
}
// Rows of every section can be filed into a folder of their own list, like a note // Rows of every section can be filed into a folder of their own list, like a note
// into a folder of the note tree. // into a folder of the note tree.
menuItems.push({ menuItems.push({
@@ -681,9 +731,8 @@ onBeforeUnmount(() => {
<span v-if="row.item.image" class="entity-entry-image" aria-hidden="true"> <span v-if="row.item.image" class="entity-entry-image" aria-hidden="true">
<img :src="itemImageUrl(row.item.image)" alt=""> <img :src="itemImageUrl(row.item.image)" alt="">
</span> </span>
<span class="entity-entry-name">{{ row.item.name }}</span> <span class="entity-entry-name" :class="rarityClass(row.item)">{{ row.item.name }}</span>
</span> </span>
<span class="entity-entry-meta">{{ itemSummary(row.item) }}</span>
</div> </div>
</template> </template>
</template> </template>
@@ -877,6 +926,13 @@ onBeforeUnmount(() => {
/* An item row leads with the item's own icon on the left of its name, standing in for the /* An item row leads with the item's own icon on the left of its name, standing in for the
"SYNCED" text it used to show (Syndria98/dragonroll#53). */ "SYNCED" text it used to show (Syndria98/dragonroll#53). */
.entity-entry-title { display: flex; align-items: center; gap: 9px; min-width: 0; } .entity-entry-title { display: flex; align-items: center; gap: 9px; min-width: 0; }
/* The rarity of an item colours the text of its row (Syndria98/dragonroll#63): common white,
uncommon green, rare blue, very rare purple, legendary orange. */
.entity-entry-name.rarity-common { color: var(--color-rarity-common); }
.entity-entry-name.rarity-uncommon { color: var(--color-rarity-uncommon); }
.entity-entry-name.rarity-rare { color: var(--color-rarity-rare); }
.entity-entry-name.rarity-very-rare { color: var(--color-rarity-very-rare); }
.entity-entry-name.rarity-legendary { color: var(--color-rarity-legendary); }
.entity-entry-image { .entity-entry-image {
flex: 0 0 30px; width: 30px; height: 30px; box-sizing: border-box; flex: 0 0 30px; width: 30px; height: 30px; box-sizing: border-box;
display: grid; place-items: center; overflow: hidden; display: grid; place-items: center; overflow: hidden;

View File

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

View File

@@ -5,6 +5,7 @@ import { ClearWindow, CreateWindow, GetFirstWindowId } from '@/services/Windows'
import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu'; import { HideContextMenu, ShowContextMenu } from '~/services/ContextMenu';
import { BuildNoteOptions, OptionLabel, ToImagePoint, ToScreenPoint } from '~/services/MapPins'; import { BuildNoteOptions, OptionLabel, ToImagePoint, ToScreenPoint } from '~/services/MapPins';
import { ActorDragId, CellCentre, IsActorDrag, MoveByCells, TokenSize } from '~/services/MapTokens'; import { ActorDragId, CellCentre, IsActorDrag, MoveByCells, TokenSize } from '~/services/MapTokens';
import { IsWall, MoveWall, SnapToGrid, ToDrawPoint, ToScreenWall } from '~/services/MapWalls';
import { DisplayToast } from '~/services/Toaster'; import { DisplayToast } from '~/services/Toaster';
import Server, { getBaseUrl } from '~/services/Server'; import Server, { getBaseUrl } from '~/services/Server';
import { emitter } from '~/services/Emitter'; import { emitter } from '~/services/Emitter';
@@ -114,6 +115,18 @@ let lastPointer = { x: 0, y: 0 };
function onPointerDown(event) { function onPointerDown(event) {
if (event.button !== 0 || !viewport.value) return; if (event.button !== 0 || !viewport.value) return;
if (editingWalls.value && imageUrl.value) {
// While the wall editor is open the left pointer draws instead of panning: the wheel and
// the zoom buttons still move the view about.
const spot = wallSpot(event);
const first = spot && SnapToGrid(spot, grid.value);
if (!first) return;
pointerId = event.pointerId;
viewport.value.setPointerCapture?.(event.pointerId);
drawingWall.value = { x1: first.x, y1: first.y, x2: first.x, y2: first.y };
selectedWall.value = null;
return;
}
dragging.value = true; dragging.value = true;
pointerId = event.pointerId; pointerId = event.pointerId;
lastPointer = { x: event.clientX, y: event.clientY }; lastPointer = { x: event.clientX, y: event.clientY };
@@ -121,13 +134,28 @@ function onPointerDown(event) {
} }
function onPointerMove(event) { function onPointerMove(event) {
if (drawingWall.value && event.pointerId === pointerId) {
const spot = wallSpot(event);
const snapped = spot && SnapToGrid(spot, grid.value);
if (snapped) drawingWall.value = { ...drawingWall.value, x2: snapped.x, y2: snapped.y };
return;
}
if (!dragging.value || event.pointerId !== pointerId) return; if (!dragging.value || event.pointerId !== pointerId) return;
pan.value = { x: pan.value.x + (event.clientX - lastPointer.x), y: pan.value.y + (event.clientY - lastPointer.y) }; pan.value = { x: pan.value.x + (event.clientX - lastPointer.x), y: pan.value.y + (event.clientY - lastPointer.y) };
lastPointer = { x: event.clientX, y: event.clientY }; lastPointer = { x: event.clientX, y: event.clientY };
} }
function onPointerUp(event) { async function onPointerUp(event) {
if (event.pointerId !== pointerId) return; if (event.pointerId !== pointerId) return;
if (drawingWall.value) {
const segment = drawingWall.value;
pointerId = null;
drawingWall.value = null;
viewport.value?.releasePointerCapture?.(event.pointerId);
// A drag that ended where it started drew no wall; anything with length becomes one.
if (IsWall(segment)) await saveWalls([...walls.value, segment]);
return;
}
dragging.value = false; dragging.value = false;
pointerId = null; pointerId = null;
viewport.value?.releasePointerCapture?.(event.pointerId); viewport.value?.releasePointerCapture?.(event.pointerId);
@@ -436,6 +464,14 @@ async function onTokenPointerUp(event) {
await placeToken(token.actor, { x, y }); await placeToken(token.actor, { x, y });
} }
// Double clicking a token (or Enter on a focused one) opens the sheet of the actor it stands for.
// A single click cannot be the trigger: the click that ends a drag lands on the token too, so
// dragging a token over the map would open its sheet every time.
function openTokenSheet(token) {
const actor = tokenActor(token);
if (actor) openActorSheet(actor);
}
const CELL_STEPS = { const CELL_STEPS = {
ArrowLeft: [-1, 0], ArrowLeft: [-1, 0],
ArrowRight: [1, 0], ArrowRight: [1, 0],
@@ -443,7 +479,8 @@ const CELL_STEPS = {
ArrowDown: [0, 1] ArrowDown: [0, 1]
}; };
// A focused token answers to the keyboard too: arrows walk it over the grid, Delete takes it off. // A focused token answers to the keyboard too: arrows walk it over the grid, Delete takes it off
// and Enter opens its sheet, the way a double click does.
async function onTokenKeydown(event, token) { async function onTokenKeydown(event, token) {
const step = CELL_STEPS[event.key]; const step = CELL_STEPS[event.key];
if (step) { if (step) {
@@ -456,6 +493,7 @@ async function onTokenKeydown(event, token) {
event.preventDefault(); event.preventDefault();
await removeToken(token); await removeToken(token);
} }
if (event.key === 'Enter') openTokenSheet(token);
} }
function onTokenContextMenu(token) { function onTokenContextMenu(token) {
@@ -493,6 +531,215 @@ function handleActorEntry({ entityType, entry }) {
actors.value = [entry, ...actors.value.filter((current) => String(current._id) !== String(entry._id))]; actors.value = [entry, ...actors.value.filter((current) => String(current._id) !== String(entry._id))];
} }
// --- Walls blocking the map ---
// The wall editor: with walls on, dragging over the map draws a segment from one grid intersection
// to the next, dragging an endpoint retypes it, dragging the segment itself moves it, and right
// clicking one (or Delete on a focused one) opens its controls and takes it off. Walls are stored
// in image pixels like the pins, and every edit saves the whole set — the same set a paired
// Foundry scene takes over, so the two see the same walls.
const walls = computed(() => map.value?.walls ?? []);
const editingWalls = ref(false);
// The wall a pointer is holding: a new segment being dragged, the whole segment being slid, or one
// endpoint being retyped. Like a token's move, the change stays local until the pointer lets go,
// so a drag across the map is one save and not one per mouse move.
const drawingWall = ref(null);
const draggingWall = ref(null);
const draggingEnd = ref(null);
// The wall whose controls are asked for: selected before its menu opens, kept while it is dragged.
const selectedWall = ref(null);
const END_KEYS = [['x1', 'y1'], ['x2', 'y2']];
let wallDragPointerId = null;
let lastWallDrag = { x: 0, y: 0 };
function toggleWallEditing() {
editingWalls.value = !editingWalls.value;
if (!editingWalls.value) {
drawingWall.value = null;
draggingWall.value = null;
draggingEnd.value = null;
selectedWall.value = null;
}
}
// The spot of the viewport in image pixels, clamped to the image: while a wall is being held the
// pointer may cross an edge, and the wall should stay on the map rather than vanish.
function wallSpot(event) {
const bounds = viewport.value?.getBoundingClientRect();
if (!bounds) return null;
return ToDrawPoint({ x: event.clientX - bounds.left, y: event.clientY - bounds.top }, viewState());
}
// The wall as it should be drawn right now: with the drag's preview on top of what is stored.
function wallGeometry(wall) {
if (draggingWall.value && String(draggingWall.value.wall?._id) === String(wall?._id)) {
const moved = MoveWall(wall, draggingWall.value.dx, draggingWall.value.dy);
if (moved) return { ...wall, ...moved };
}
if (draggingEnd.value && String(draggingEnd.value.wall?._id) === String(wall?._id) && draggingEnd.value.point) {
const [keyX, keyY] = END_KEYS[draggingEnd.value.end];
return { ...wall, [keyX]: draggingEnd.value.point.x, [keyY]: draggingEnd.value.point.y };
}
return wall;
}
function wallScreen(wall) {
return ToScreenWall(wallGeometry(wall), viewState());
}
function wallClasses(wall) {
return {
'wall-door': Number(wall?.door) > 0,
'wall-move-only': !wall?.sight && Number(wall?.door) === 0,
selected: Boolean(selectedWall.value) && String(selectedWall.value) === String(wall?._id)
};
}
// The wire shape of a wall: what the server keeps, with the `_id` of the ones it already has so a
// save neither doubles them nor re-ids them under the viewer's feet.
function plainWall(wall) {
const stored = {
x1: Number(wall.x1), y1: Number(wall.y1), x2: Number(wall.x2), y2: Number(wall.y2),
move: wall.move !== false, sight: wall.sight !== false, door: Number(wall.door) || 0
};
return wall._id ? { _id: String(wall._id), ...stored } : stored;
}
async function saveWalls(next) {
return updateMap('/map/walls', { id: map.value?._id, walls: next.map(plainWall) }, t('campaigns.map.walls.error'));
}
async function replaceWall(wall, patch) {
const next = walls.value.map((current) => (
String(current?._id) === String(wall?._id) ? { ...current, ...patch } : current
));
await saveWalls(next);
}
async function removeWall(wall) {
if (String(selectedWall.value) === String(wall?._id)) selectedWall.value = null;
await saveWalls(walls.value.filter((current) => String(current?._id) !== String(wall?._id)));
}
function onWallPointerDown(event, wall) {
// The segment is what is being held here: the map must not start panning under the pointer.
event.stopPropagation();
if (event.button !== 0) return;
wallDragPointerId = event.pointerId;
event.currentTarget.setPointerCapture?.(event.pointerId);
lastWallDrag = { x: event.clientX, y: event.clientY };
selectedWall.value = String(wall?._id ?? '');
draggingWall.value = { wall, dx: 0, dy: 0 };
}
function onWallPointerMove(event) {
if (!draggingWall.value || event.pointerId !== wallDragPointerId) return;
const zoomScale = zoom.value || 1;
draggingWall.value = {
...draggingWall.value,
// The drag is measured in screen pixels and applied in image ones, and the whole segment
// goes by the same delta: a moved wall keeps its shape and the grid it was drawn on.
dx: draggingWall.value.dx + (event.clientX - lastWallDrag.x) / zoomScale,
dy: draggingWall.value.dy + (event.clientY - lastWallDrag.y) / zoomScale
};
lastWallDrag = { x: event.clientX, y: event.clientY };
}
async function onWallPointerUp(event) {
if (!draggingWall.value || event.pointerId !== wallDragPointerId) return;
const { wall, dx, dy } = draggingWall.value;
wallDragPointerId = null;
draggingWall.value = null;
event.currentTarget?.releasePointerCapture?.(event.pointerId);
const moved = MoveWall(wall, dx, dy);
if (!moved || (moved.x1 === Number(wall.x1) && moved.y1 === Number(wall.y1)
&& moved.x2 === Number(wall.x2) && moved.y2 === Number(wall.y2))) return;
await replaceWall(wall, moved);
}
function onWallEndPointerDown(event, wall, end) {
event.stopPropagation();
if (event.button !== 0) return;
wallDragPointerId = event.pointerId;
event.currentTarget.setPointerCapture?.(event.pointerId);
selectedWall.value = String(wall?._id ?? '');
draggingEnd.value = { wall, end, point: { x: Number(wall[END_KEYS[end][0]]), y: Number(wall[END_KEYS[end][1]]) } };
}
function onWallEndPointerMove(event) {
if (!draggingEnd.value || event.pointerId !== wallDragPointerId) return;
const spot = wallSpot(event);
const snapped = spot && SnapToGrid(spot, grid.value);
if (!snapped) return;
draggingEnd.value = { ...draggingEnd.value, point: snapped };
}
async function onWallEndPointerUp(event) {
if (!draggingEnd.value || event.pointerId !== wallDragPointerId) return;
const { wall, end, point } = draggingEnd.value;
wallDragPointerId = null;
draggingEnd.value = null;
event.currentTarget?.releasePointerCapture?.(event.pointerId);
const [keyX, keyY] = END_KEYS[end];
if (point.x === Number(wall[keyX]) && point.y === Number(wall[keyY])) return;
const retyped = { ...wall, [keyX]: point.x, [keyY]: point.y };
// Retyped into its own end, the segment has no length left: the wall is gone.
if (!IsWall(retyped)) await removeWall(wall);
else await replaceWall(wall, { [keyX]: point.x, [keyY]: point.y });
}
function onWallContextMenu(wall) {
selectedWall.value = String(wall?._id ?? '');
ShowContextMenu([
{
name: t(wall.sight ? 'campaigns.map.walls.sight-open' : 'campaigns.map.walls.sight-block'),
icon: '/icons/iconoir/regular/eye.svg',
action: () => { HideContextMenu(); replaceWall(wall, { sight: !wall.sight }); }
},
{
name: t(wall.move ? 'campaigns.map.walls.move-open' : 'campaigns.map.walls.move-block'),
icon: '/icons/iconoir/regular/lock.svg',
action: () => { HideContextMenu(); replaceWall(wall, { move: !wall.move }); }
},
{
name: t('campaigns.map.walls.door'),
icon: '/icons/iconoir/regular/home-simple-door.svg',
context: [
{ name: t('campaigns.map.walls.door-none'), action: () => { HideContextMenu(); replaceWall(wall, { door: 0 }); } },
{ name: t('campaigns.map.walls.door-closed'), action: () => { HideContextMenu(); replaceWall(wall, { door: 2 }); } },
{ name: t('campaigns.map.walls.door-open'), action: () => { HideContextMenu(); replaceWall(wall, { door: 1 }); } }
]
},
{ divider: true },
{
name: t('campaigns.map.walls.remove'),
icon: '/icons/iconoir/regular/xmark-circle.svg',
action: () => { HideContextMenu(); removeWall(wall); }
}
]);
}
// A focused wall answers Delete too, the way a focused token does.
async function onWallKeydown(event, wall) {
if (event.key !== 'Delete' && event.key !== 'Backspace') return;
event.preventDefault();
await removeWall(wall);
}
// Escape lets go of whatever the editor is holding: an unfinished segment first, the selection next.
function onWindowKeydown(event) {
if (event.key !== 'Escape') return;
if (drawingWall.value) drawingWall.value = null;
else if (selectedWall.value) selectedWall.value = null;
}
// A different map was anchored while this pane was already mounted. // A different map was anchored while this pane was already mounted.
watch(() => props.map, (incoming, previous) => { watch(() => props.map, (incoming, previous) => {
if (incoming === previous) return; if (incoming === previous) return;
@@ -500,6 +747,10 @@ watch(() => props.map, (incoming, previous) => {
imageSize.value = { width: 0, height: 0 }; imageSize.value = { width: 0, height: 0 };
movingToken.value = null; movingToken.value = null;
draggingActor.value = false; draggingActor.value = false;
drawingWall.value = null;
draggingWall.value = null;
draggingEnd.value = null;
selectedWall.value = null;
}); });
watch(campaignId, () => { watch(campaignId, () => {
@@ -515,6 +766,7 @@ onMounted(() => {
emitter.on('campaign-entry-updated', handleActorEntry); emitter.on('campaign-entry-updated', handleActorEntry);
emitter.on('delete-note', handlePinnedNoteDeleted); emitter.on('delete-note', handlePinnedNoteDeleted);
emitter.on('title-updated', handlePinnedNoteRenamed); emitter.on('title-updated', handlePinnedNoteRenamed);
window.addEventListener('keydown', onWindowKeydown);
fetchPinnableNotes(); fetchPinnableNotes();
fetchTokenActors(); fetchTokenActors();
}); });
@@ -525,6 +777,7 @@ onBeforeUnmount(() => {
emitter.off('campaign-entry-updated', handleActorEntry); emitter.off('campaign-entry-updated', handleActorEntry);
emitter.off('delete-note', handlePinnedNoteDeleted); emitter.off('delete-note', handlePinnedNoteDeleted);
emitter.off('title-updated', handlePinnedNoteRenamed); emitter.off('title-updated', handlePinnedNoteRenamed);
window.removeEventListener('keydown', onWindowKeydown);
}); });
</script> </script>
@@ -540,6 +793,10 @@ onBeforeUnmount(() => {
:aria-label="$t('campaigns.map.toggle-grid')" :aria-pressed="showGrid.toString()" @click="showGrid = !showGrid"> :aria-label="$t('campaigns.map.toggle-grid')" :aria-pressed="showGrid.toString()" @click="showGrid = !showGrid">
<img class="tool-icon" src="/icons/iconoir/regular/view-grid.svg" alt="" aria-hidden="true"> <img class="tool-icon" src="/icons/iconoir/regular/view-grid.svg" alt="" aria-hidden="true">
</button> </button>
<button class="viewer-tool" :class="{ selected: editingWalls }" type="button" :title="$t('campaigns.map.walls.edit')"
:aria-label="$t('campaigns.map.walls.edit')" :aria-pressed="editingWalls.toString()" @click="toggleWallEditing">
<img class="tool-icon" src="/icons/iconoir/regular/border-out.svg" alt="" aria-hidden="true">
</button>
<button class="viewer-tool" type="button" :title="$t('campaigns.map.zoom-out')" :aria-label="$t('campaigns.map.zoom-out')" @click="zoomFromToolbar(false)"> <button class="viewer-tool" type="button" :title="$t('campaigns.map.zoom-out')" :aria-label="$t('campaigns.map.zoom-out')" @click="zoomFromToolbar(false)">
<img class="tool-icon" src="/icons/iconoir/regular/minus.svg" alt="" aria-hidden="true"> <img class="tool-icon" src="/icons/iconoir/regular/minus.svg" alt="" aria-hidden="true">
</button> </button>
@@ -577,6 +834,42 @@ onBeforeUnmount(() => {
<template v-if="imageUrl"> <template v-if="imageUrl">
<img class="map-image" :src="imageUrl" :style="stageStyle" :alt="map?.name" draggable="false" @load="onImageLoaded"> <img class="map-image" :src="imageUrl" :style="stageStyle" :alt="map?.name" draggable="false" @load="onImageLoaded">
<div class="map-grid" :style="gridStyle" aria-hidden="true"></div> <div class="map-grid" :style="gridStyle" aria-hidden="true"></div>
<!-- Walls are drawn in screen space like the pins, so their lines stay thin at any
zoom. They only catch the mouse while the editor is open, and never when there
is no image to hold them. -->
<svg v-if="imageUrl && (walls.length || drawingWall || editingWalls)" class="map-walls" :class="{ editing: editingWalls }">
<g v-for="wall in walls" :key="wall._id">
<line class="wall-line" :class="wallClasses(wall)" v-bind="wallScreen(wall)"></line>
<template v-if="editingWalls">
<line
class="wall-hit"
role="button"
tabindex="0"
:aria-label="$t('campaigns.map.walls.wall')"
v-bind="wallScreen(wall)"
@pointerdown="onWallPointerDown($event, wall)"
@pointermove="onWallPointerMove"
@pointerup="onWallPointerUp"
@pointercancel="onWallPointerUp"
@contextmenu.stop.prevent="onWallContextMenu(wall)"
@keydown="onWallKeydown($event, wall)"
></line>
<circle
v-for="end in [0, 1]"
:key="end"
class="wall-end"
:cx="end === 0 ? wallScreen(wall).x1 : wallScreen(wall).x2"
:cy="end === 0 ? wallScreen(wall).y1 : wallScreen(wall).y2"
r="5"
@pointerdown="onWallEndPointerDown($event, wall, end)"
@pointermove="onWallEndPointerMove"
@pointerup="onWallEndPointerUp"
@pointercancel="onWallEndPointerUp"
></circle>
</template>
</g>
<line v-if="drawingWall" class="wall-draft" v-bind="ToScreenWall(drawingWall, viewState())"></line>
</svg>
<div class="map-pins"> <div class="map-pins">
<button <button
v-for="pin in pins" v-for="pin in pins"
@@ -609,6 +902,7 @@ onBeforeUnmount(() => {
@pointermove="onTokenPointerMove" @pointermove="onTokenPointerMove"
@pointerup="onTokenPointerUp" @pointerup="onTokenPointerUp"
@pointercancel="onTokenPointerUp" @pointercancel="onTokenPointerUp"
@dblclick="openTokenSheet(token)"
@contextmenu.stop.prevent="onTokenContextMenu(token)" @contextmenu.stop.prevent="onTokenContextMenu(token)"
@keydown="onTokenKeydown($event, token)" @keydown="onTokenKeydown($event, token)"
> >
@@ -618,6 +912,7 @@ onBeforeUnmount(() => {
</button> </button>
</div> </div>
<div v-if="draggingActor" class="map-drop-hint">{{ $t('campaigns.map.tokens.drop-hint') }}</div> <div v-if="draggingActor" class="map-drop-hint">{{ $t('campaigns.map.tokens.drop-hint') }}</div>
<div v-if="editingWalls" class="map-walls-hint">{{ $t('campaigns.map.walls.hint') }}</div>
</template> </template>
<div v-else class="map-empty"> <div v-else class="map-empty">
{{ $t('campaigns.map.no-image') }} {{ $t('campaigns.map.no-image') }}
@@ -688,6 +983,27 @@ onBeforeUnmount(() => {
background: var(--color-background-soft); color: var(--color-text); font-size: 12px; background: var(--color-background-soft); color: var(--color-text); font-size: 12px;
pointer-events: none; box-shadow: 0px 0px 6px -1px rgba(0,0,0,0.55); pointer-events: none; box-shadow: 0px 0px 6px -1px rgba(0,0,0,0.55);
} }
/* Walls are drawn in screen space like the pins, so their lines stay thin at any zoom. A sight
wall is red, a wall that only stops movement grey, a door green — close to how Foundry paints
them on its own scenes. Only the editor's hit lines and handles catch the mouse. */
.map-walls { position: absolute; inset: 0; width: 100%; height: 100%; pointer-events: none; overflow: visible; }
.wall-line { stroke: var(--color-red); stroke-width: 2; opacity: .85; pointer-events: none; }
.wall-line.wall-move-only { stroke: var(--color-gray); }
.wall-line.wall-door { stroke: var(--color-green); stroke-width: 3; }
.wall-line.selected { stroke: var(--color-link); opacity: 1; }
/* The grabbable line and the endpoint handles: each wall gives its own hit area, wide enough that
the pointer finds it at any zoom. */
.wall-hit { stroke: transparent; stroke-width: 16; stroke-linecap: round; pointer-events: stroke; cursor: move; }
.wall-hit:focus-visible { stroke: var(--color-link); stroke-opacity: .35; outline: none; }
.wall-end { fill: var(--color-background-soft); stroke: var(--color-link); stroke-width: 1.5; pointer-events: auto; cursor: crosshair; }
.wall-draft { stroke: var(--color-link); stroke-width: 2; stroke-dasharray: 6 4; pointer-events: none; }
/* Shown while the wall editor is open, so the gestures it answers to are at hand. */
.map-walls-hint {
position: absolute; bottom: 10px; left: 50%; transform: translateX(-50%);
padding: 5px 10px; border: 1px dashed var(--color-link); border-radius: 7px;
background: var(--color-background-soft); color: var(--color-text); font-size: 12px;
pointer-events: none; box-shadow: 0px 0px 6px -1px rgba(0,0,0,0.55);
}
.map-empty { width: 100%; height: 100%; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 8px; font-size: 13px; opacity: .8; } .map-empty { width: 100%; height: 100%; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 8px; font-size: 13px; opacity: .8; }
.map-edit { border: 1px solid var(--color-border); border-radius: 7px; padding: 6px 11px; background: var(--color-background-soft); color: var(--color-text); font-size: 12px; cursor: pointer; } .map-edit { border: 1px solid var(--color-border); border-radius: 7px; padding: 6px 11px; background: var(--color-background-soft); color: var(--color-text); font-size: 12px; cursor: pointer; }
.map-edit:hover { background: var(--color-button-hover); } .map-edit:hover { background: var(--color-button-hover); }

View File

@@ -0,0 +1,67 @@
<script setup>
import ContentManager from '../managers/ContentManager.vue';
import ToastManager from '../managers/ToastManager.vue';
import WindowManager from '../managers/WindowManager.vue';
import ServiceLinkAuthorize from './ServiceLinkAuthorize.vue';
import { CreateWindow } from '@/services/Windows'
import { GetUser, HasAdmin } from '@/services/User';
import TooltipManager from '../managers/TooltipManager.vue';
import ContextMenuManager from '../managers/ContextMenuManager.vue';
import { useCampaignService } from '@/services/Campaign';
const { RestoreCampaign } = useCampaignService();
// Els serveis (Discord, Foundry, Obsidian) enllacen amb aquesta pantalla única; no són part
// de l'aplicació i no han d'arrencar les finestres normals. La ruta antiga de Discord també
// hi porta, perquè els enllaços que ja corren per Discord no queden morts.
const requestUrl = useRequestURL();
const isServiceLink = computed(() => {
const path = requestUrl.pathname.replace(/\/+$/, '');
return path === '/link/authorize' || path === '/discord/authorize';
});
async function start(){
if(GetUser()){
const restoredCampaign = await RestoreCampaign();
if (!restoredCampaign) {
CreateWindow('main_menu');
}
return;
}
if(await HasAdmin()){
CreateWindow('login');
} else {
CreateWindow('register', {firstTime: true});
}
// DisplayToast('aqua', 'All plugins loaded successfully');
}
onMounted(() => {
if(!isServiceLink.value){
start();
}
})
</script>
<template>
<ServiceLinkAuthorize v-if="isServiceLink"></ServiceLinkAuthorize>
<div v-else class="viewer">
<ToastManager></ToastManager>
<TooltipManager></TooltipManager>
<ContextMenuManager></ContextMenuManager>
<WindowManager></WindowManager>
<ContentManager></ContentManager>
<!-- Managers -->
</div>
</template>
<style scoped>
.viewer {
display: flex;
flex-direction: column;
width: 100%;
height: 100vh;
}
</style>

View File

@@ -0,0 +1,343 @@
<script setup>
import { computed } from 'vue';
import { GetDocsFirstSlug, GetDocsNav, GetDocsPage } from '~/services/Docs';
// La documentació pública, a /docs: el sumari a l'esquerra, la pàgina al centre i els
// apartats d'aquesta pàgina a la dreta. Tot el que hi ha escrit ve dels markdown de
// app/content/docs (mira ~/services/Docs.js), i cada enllaç del sumari és una ruta,
// així que moure-s'hi no recarrega la pàgina.
const route = useRoute();
const slug = computed(() => String(route.params.slug || GetDocsFirstSlug()));
const page = computed(() => GetDocsPage(slug.value));
const nav = GetDocsNav();
useHead({
title: computed(() => `${page.value?.title || 'Documentation'} · Dragonroll`)
});
</script>
<template>
<div class="docs">
<aside class="docs-sidebar">
<NuxtLink class="docs-brand" to="/">
<img src="/img/logo.png" alt="Dragonroll logo" class="docs-logo" draggable="false">
<span>{{ $t('docs.title') }}</span>
</NuxtLink>
<nav 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">
<NuxtLink
:to="entry.href"
class="docs-nav-link"
:class="{ active: entry.slug === slug }"
>{{ entry.title }}</NuxtLink>
</li>
</ul>
</section>
</nav>
<NuxtLink class="docs-open" to="/">{{ $t('docs.open-app') }}</NuxtLink>
</aside>
<main class="docs-main">
<template v-if="page">
<article class="docs-article">
<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">
<NuxtLink
v-if="page.previous"
:to="page.previous.href"
class="docs-pager-link"
>
<span class="docs-pager-label">{{ $t('docs.previous') }}</span>
<strong>{{ page.previous.title }}</strong>
</NuxtLink>
<NuxtLink
v-if="page.next"
:to="page.next.href"
class="docs-pager-link next"
>
<span class="docs-pager-label">{{ $t('docs.next') }}</span>
<strong>{{ page.next.title }}</strong>
</NuxtLink>
</nav>
</template>
<article v-else class="docs-article">
<h1>{{ $t('docs.title') }}</h1>
<p>{{ $t('docs.not-found', { page: slug }) }}</p>
<p><NuxtLink to="/docs">{{ $t('docs.back-to-docs') }}</NuxtLink></p>
</article>
</main>
<aside
v-if="page && page.headings.length"
class="docs-sections"
:aria-label="$t('docs.on-this-page')"
>
<h2>{{ $t('docs.on-this-page') }}</h2>
<ul>
<li
v-for="heading in page.headings"
:key="heading.slug"
:class="`depth-${heading.depth}`"
>
<a :href="`#${heading.slug}`">{{ heading.text }}</a>
</li>
</ul>
</aside>
</div>
</template>
<style scoped lang="scss">
.docs {
display: flex;
align-items: flex-start;
width: 100%;
min-height: 100vh;
box-sizing: border-box;
background-color: var(--color-background);
color: var(--color-text);
}
/* Els dos aside fan la pàgina sencera avall: amb alçada d'una pantalla i enganxats a
dalt, el fons i la vora arriben sempre fins a baix, per molt llarg que sigui el text. */
.docs-sidebar,
.docs-sections {
position: sticky;
top: 0;
height: 100vh;
overflow-y: auto;
box-sizing: border-box;
padding: 18px 14px;
}
.docs-sidebar {
flex: 0 0 268px;
width: 268px;
border-right: 1px solid var(--color-border);
display: flex;
flex-direction: column;
gap: 14px;
}
.docs-brand {
display: flex;
align-items: center;
gap: 10px;
font-family: 'MrEavesRemake', serif;
font-size: 1.15rem;
text-decoration: none;
}
.docs-logo {
width: 30px;
height: 30px;
}
.docs-contents {
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;
}
.docs-nav-link {
display: block;
padding: 6px 9px;
border-radius: 6px;
font-size: 0.97rem;
line-height: 1.35;
color: var(--color-text);
text-decoration: none;
}
.docs-nav-link:hover {
background-color: var(--color-hover);
}
.docs-nav-link.active {
background-color: var(--color-background-soft);
color: var(--color-link);
}
.docs-open {
margin-top: auto;
padding: 8px 9px;
border: 1px solid var(--color-border);
border-radius: 6px;
background-color: var(--color-button-background);
font-size: 0.95rem;
text-align: center;
text-decoration: none;
}
.docs-open:hover {
background-color: var(--color-button-hover);
}
.docs-main {
flex: 1;
min-width: 0;
padding: 26px 34px 60px 34px;
box-sizing: border-box;
}
/* La columna de lectura, centrada dins l'espai que deixa la barra lateral: en una finestra
ampla el text queda al mig, no enganxat a l'esquerra. */
.docs-article,
.docs-pager {
width: 100%;
max-width: 760px;
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: 34px;
padding-top: 18px;
border-top: 1px solid var(--color-border);
display: flex;
gap: 14px;
}
.docs-pager-link {
flex: 1 1 0;
min-width: 0;
padding: 10px 12px;
border: 1px solid var(--color-border);
border-radius: 8px;
color: var(--color-text);
text-decoration: none;
}
.docs-pager-link:hover {
background-color: var(--color-hover);
}
.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);
}
.docs-sections {
flex: 0 0 240px;
width: 240px;
/* Més aire al voltant dels apartats, que ara mateix van clavats a la vora. */
padding: 26px 22px 26px 18px;
border-left: 1px solid var(--color-border);
}
.docs-sections h2 {
margin: 0 0 8px 0;
font-family: 'MrEavesRemake', serif;
font-size: 0.78rem;
font-weight: normal;
letter-spacing: 0.08em;
text-transform: uppercase;
color: var(--color-gray);
}
.docs-sections ul {
margin: 0;
padding: 0;
list-style: none;
}
.docs-sections li.depth-3 {
padding-left: 10px;
}
.docs-sections a {
display: block;
padding: 3px 0;
font-size: 0.9rem;
line-height: 1.35;
color: var(--color-gray);
text-decoration: none;
}
.docs-sections a:hover {
color: var(--color-link);
}
/* El markdown renderitzat ve estilat a assets/css/main.scss, sota .docs-markdown, perquè la
finestra de documentació (windows/DocumentationWindow.vue) se'l serveix igualment. */
/* 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. */
@media (min-width: 1440px) {
.docs {
justify-content: center;
}
.docs-main {
flex: 0 1 860px;
}
}
@media (max-width: 1200px) {
.docs-sections {
display: none;
}
}
@media (max-width: 900px) {
.docs {
flex-direction: column;
}
.docs-sidebar,
.docs-sections {
position: static;
height: auto;
width: 100%;
border-left: none;
border-right: none;
}
.docs-main {
padding: 20px 18px 40px 18px;
}
}
</style>

View File

@@ -24,6 +24,23 @@ const abilityStats = [
{ key: 'int', label: 'INT' }, { key: 'wis', label: 'WIS' }, { key: 'cha', label: 'CHA' } { key: 'int', label: 'INT' }, { key: 'wis', label: 'WIS' }, { key: 'cha', label: 'CHA' }
]; ];
// Les habilitats del 5e. Cada una té un cercle que s'encén quan el personatge hi és
// proficient, i la modificadora que tira és la de la característica que mana.
const skillList = [
{ key: 'acrobatics', ability: 'dex' }, { key: 'animalHandling', ability: 'wis' },
{ key: 'arcana', ability: 'int' }, { key: 'athletics', ability: 'str' },
{ key: 'deception', ability: 'cha' }, { key: 'history', ability: 'int' },
{ key: 'insight', ability: 'wis' }, { key: 'intimidation', ability: 'cha' },
{ key: 'investigation', ability: 'int' }, { key: 'medicine', ability: 'wis' },
{ key: 'nature', ability: 'int' }, { key: 'perception', ability: 'wis' },
{ key: 'performance', ability: 'cha' }, { key: 'persuasion', ability: 'cha' },
{ key: 'religion', ability: 'int' }, { key: 'sleightOfHand', ability: 'dex' },
{ key: 'stealth', ability: 'dex' }, { key: 'survival', ability: 'wis' }
];
// Les cinc monedes que un personatge porta al damunt.
const currencyUnits = ['pp', 'gp', 'ep', 'sp', 'cp'];
// Les pestanyes del lateral dret reparteixen la fitxa: característiques i combat, // Les pestanyes del lateral dret reparteixen la fitxa: característiques i combat,
// inventari, trets i conjurs. Són pestanyes de marcadors, no una pàgina nova. // inventari, trets i conjurs. Són pestanyes de marcadors, no una pàgina nova.
const tabs = [ const tabs = [
@@ -34,6 +51,22 @@ const tabs = [
]; ];
const activeTab = ref('abilities'); const activeTab = ref('abilities');
// Les pestanyes pengen del marc de la finestra, per fora del contingent (vegeu .sheet-tabs). La
// finestra es fa més estreta perquè el marge que la centra sigui prou ample per aguantar-les;
// per sota de 760px el marc les fa estar a dins i el marge deixa de fer falta.
const TAB_RAIL_WIDTH = 150;
// Les eines i els idiomes viatgen com a llista i el formulari els edita com un quadre
// de text: un nom per línia. Les comes també separen, que és com s'escriuen en una frase.
function proficiencyText(value) {
const names = Array.isArray(value) ? value : String(value ?? '').split(/[\n,]/);
return [...new Set(names.map((name) => String(name).trim()).filter(Boolean))].join('\n');
}
function proficiencyList(text) {
return [...new Set(String(text ?? '').split(/[\n,]/).map((name) => String(name).trim()).filter(Boolean))];
}
function normalizeActor(actor) { function normalizeActor(actor) {
return { return {
name: actor?.name ?? '', name: actor?.name ?? '',
@@ -44,9 +77,28 @@ function normalizeActor(actor) {
abilityScores: Object.fromEntries(abilityStats.map(({ key }) => [key, Number(actor?.abilityScores?.[key] ?? 10)])), abilityScores: Object.fromEntries(abilityStats.map(({ key }) => [key, Number(actor?.abilityScores?.[key] ?? 10)])),
armorClass: Number(actor?.armorClass ?? 10), armorClass: Number(actor?.armorClass ?? 10),
speed: Number(actor?.speed ?? 30), speed: Number(actor?.speed ?? 30),
// Les barres sota la imatge: `current` de `max`. Un personatge que encara no en té
// rep un dau de cop per nivell, que és el que D&D compta.
hitPoints: {
current: Number(actor?.hitPoints?.current ?? actor?.hitPoints?.max ?? 10),
max: Number(actor?.hitPoints?.max ?? actor?.hitPoints?.current ?? 10)
},
hitDice: {
current: Number(actor?.hitDice?.current ?? actor?.level ?? 1),
max: Number(actor?.hitDice?.max ?? actor?.level ?? 1)
},
proficiencies: actor?.proficiencies ?? '', proficiencies: actor?.proficiencies ?? '',
// El que el personatge sap fer i el que porta: les habilitats i les tirades de
// salvació són cercles que s'encenen, les eines i els idiomes són noms que el
// formulari edita com un text d'una línia per nom, i la moneda són cinc xifres.
skills: Object.fromEntries(skillList.map(({ key }) => [key, Boolean(actor?.skills?.[key])])),
savingThrows: Object.fromEntries(abilityStats.map(({ key }) => [key, Boolean(actor?.savingThrows?.[key])])),
tools: proficiencyText(actor?.tools),
languages: proficiencyText(actor?.languages),
currency: Object.fromEntries(currencyUnits.map((unit) => [unit, Number(actor?.currency?.[unit] ?? 0) || 0])),
inventory: (actor?.inventory ?? []).map((item) => ({ inventory: (actor?.inventory ?? []).map((item) => ({
name: item.name ?? '', quantity: Number(item.quantity ?? 1), weight: Number(item.weight ?? 0) name: item.name ?? '', quantity: Number(item.quantity ?? 1), weight: Number(item.weight ?? 0),
icon: item.icon ?? ''
})), })),
traits: actor?.traits ?? '', traits: actor?.traits ?? '',
spells: actor?.spells ?? '', spells: actor?.spells ?? '',
@@ -60,8 +112,11 @@ original.value = normalizeActor(props.data.actor);
onMounted(() => { onMounted(() => {
Top(wrapper); Top(wrapper);
SetupHandle(id, handle); SetupHandle(id, handle);
// Les pestanyes pengen del marc per fora del cos: com que la finestra es centra, el marge que
// li queda a la dreta és la meitat del que li sobra, i cal reservar-nos el doble.
const railRoom = window.innerWidth > 760 ? 2 * TAB_RAIL_WIDTH : 0;
SetSize(id, { SetSize(id, {
width: Math.max(320, Math.min(900, window.innerWidth - 24)), width: Math.max(320, Math.min(900, window.innerWidth - 24 - railRoom)),
height: Math.max(360, Math.min(700, window.innerHeight - 32)) height: Math.max(360, Math.min(700, window.innerHeight - 32))
}); });
ResetPosition(id, 'center'); ResetPosition(id, 'center');
@@ -79,21 +134,50 @@ onMounted(() => emitter.on('campaign-entry-updated', handleActorSync));
onBeforeUnmount(() => emitter.off('campaign-entry-updated', handleActorSync)); onBeforeUnmount(() => emitter.off('campaign-entry-updated', handleActorSync));
const proficiencyBonus = computed(() => Math.ceil(form.value.level / 4) + 1); const proficiencyBonus = computed(() => Math.ceil(form.value.level / 4) + 1);
// La iniciativa és el modificador de DESTÀ, que és el que D&D compta quan el personatge no
// porta cap do extra que l'augmenti.
const initiativeBonus = computed(() => abilityModifier(form.value.abilityScores.dex));
// Quina part del màxim representa la barra; buida (màxim 0) o per sobre, tot tallat.
function barPercent(current, max) {
return max > 0 ? Math.min(100, Math.max(0, ((Number(current) || 0) / max) * 100)) : 0;
}
const hitPointsPercent = computed(() => barPercent(form.value.hitPoints.current, form.value.hitPoints.max));
const hitDicePercent = computed(() => barPercent(form.value.hitDice.current, form.value.hitDice.max));
const carryingCapacity = computed(() => form.value.abilityScores.str * 15); const carryingCapacity = computed(() => form.value.abilityScores.str * 15);
const carriedWeight = computed(() => form.value.inventory.reduce((total, item) => total + (Number(item.quantity) || 0) * (Number(item.weight) || 0), 0)); const carriedWeight = computed(() => form.value.inventory.reduce((total, item) => total + (Number(item.quantity) || 0) * (Number(item.weight) || 0), 0));
const carryPercent = computed(() => Math.min(100, carryingCapacity.value ? (carriedWeight.value / carryingCapacity.value) * 100 : 0)); const carryPercent = computed(() => Math.min(100, carryingCapacity.value ? (carriedWeight.value / carryingCapacity.value) * 100 : 0));
function abilityModifier(score) { // `bonus` és el bonificador de proficiència, per a les habilitats i les tirades de
const modifier = Math.floor((Number(score) - 10) / 2); // salvació del personatge que hi està entrenat.
function abilityModifier(score, bonus = 0) {
const modifier = Math.floor((Number(score) - 10) / 2) + (Number(bonus) || 0);
return modifier >= 0 ? `+${modifier}` : String(modifier); return modifier >= 0 ? `+${modifier}` : String(modifier);
} }
const imageUrl = computed(() => { function skillModifier(skill) {
if (!form.value.image) return ''; return abilityModifier(form.value.abilityScores[skill.ability], form.value.skills[skill.key] ? proficiencyBonus.value : 0);
return /^(https?:|data:|\/\/)/i.test(form.value.image) }
? form.value.image
: `${getBaseUrl()}/public/${form.value.image}`; function savingThrowModifier(stat) {
}); return abilityModifier(form.value.abilityScores[stat.key], form.value.savingThrows[stat.key] ? proficiencyBonus.value : 0);
}
// El cercle d'una habilitat o d'una salvació: s'encén i s'apaga, i es desa amb tota la
// fitxa, com la resta del que s'edita.
function toggleProficiency(group, key) {
form.value[group][key] = !form.value[group][key];
}
// Una imatge pot ser una adreça sencera (la que Foundry dona a un objecte, per
// exemple) o un fitxer pujat aquí, que es serveix per `/api/public`.
function resolveImage(image) {
if (!image) return '';
return /^(https?:|data:|\/\/)/i.test(image)
? image
: `${getBaseUrl()}/public/${image}`;
}
const imageUrl = computed(() => resolveImage(form.value.image));
function pickPhoto() { function pickPhoto() {
photoInput.value?.click(); photoInput.value?.click();
@@ -157,6 +241,9 @@ async function saveSheet() {
const payload = { const payload = {
id: actorId, id: actorId,
...form.value, ...form.value,
// Les eines i els idiomes van a l'API com a llista, que és com està desats.
tools: proficiencyList(form.value.tools),
languages: proficiencyList(form.value.languages),
inventory: form.value.inventory.filter((item) => item.name.trim()) inventory: form.value.inventory.filter((item) => item.name.trim())
}; };
const response = await Server().post('/actor/update', payload); const response = await Server().post('/actor/update', payload);
@@ -179,6 +266,21 @@ async function saveSheet() {
<template> <template>
<div class="window-wrapper sheet-window" :id="'window-wrapper-' + id" ref="wrapper"> <div class="window-wrapper sheet-window" :id="'window-wrapper-' + id" ref="wrapper">
<WindowHandle :window="id" ref="handle" /> <WindowHandle :window="id" ref="handle" />
<!-- Pestilletes del marc de la finestra: pengen del cantó dret, per fora del
contingent, i no s'enrolen quan la fitxa desfila. -->
<nav class="sheet-tabs" role="tablist" aria-orientation="vertical">
<button
v-for="tab in tabs"
:key="tab.key"
class="sheet-tab"
:class="{ active: activeTab === tab.key }"
type="button"
role="tab"
:aria-selected="activeTab === tab.key"
@click="activeTab = tab.key"
>{{ $t(tab.label) }}</button>
</nav>
<div class="sheet-body"> <div class="sheet-body">
<header class="sheet-hero"> <header class="sheet-hero">
<div class="character-mark" aria-hidden="true">{{ form.name.slice(0, 1).toUpperCase() }}</div> <div class="character-mark" aria-hidden="true">{{ form.name.slice(0, 1).toUpperCase() }}</div>
@@ -217,123 +319,218 @@ async function saveSheet() {
<div v-if="error" class="sheet-error">{{ error }}</div> <div v-if="error" class="sheet-error">{{ error }}</div>
<!-- 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="sheet-layout">
<div class="sheet-content"> <div class="character-column">
<main v-show="activeTab === 'abilities'" class="sheet-grid"> <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')"> <button v-if="editing && !form.image" class="portrait-upload" type="button" :disabled="uploadingPhoto" @click="pickPhoto">
<button v-if="editing && !form.image" class="portrait-upload" type="button" :disabled="uploadingPhoto" @click="pickPhoto"> {{ uploadingPhoto ? $t('campaigns.character-sheet.uploading-photo') : $t('campaigns.character-sheet.upload-photo') }}
{{ uploadingPhoto ? $t('campaigns.character-sheet.uploading-photo') : $t('campaigns.character-sheet.upload-photo') }} </button>
<div v-if="editing && form.image" class="portrait-controls">
<button type="button" :disabled="uploadingPhoto" @click="pickPhoto">
{{ uploadingPhoto ? $t('campaigns.character-sheet.uploading-photo') : $t('campaigns.character-sheet.change-photo') }}
</button> </button>
<div v-if="editing && form.image" class="portrait-controls"> <button type="button" :disabled="uploadingPhoto" :aria-label="$t('campaigns.character-sheet.remove-photo')" @click="removePhoto">×</button>
<button type="button" :disabled="uploadingPhoto" @click="pickPhoto">
{{ uploadingPhoto ? $t('campaigns.character-sheet.uploading-photo') : $t('campaigns.character-sheet.change-photo') }}
</button>
<button type="button" :disabled="uploadingPhoto" :aria-label="$t('campaigns.character-sheet.remove-photo')" @click="removePhoto">×</button>
</div>
<input ref="photoInput" class="photo-input" type="file" accept="image/*" @change="onPhotoSelected">
</div> </div>
<input ref="photoInput" class="photo-input" type="file" accept="image/*" @change="onPhotoSelected">
</div>
<section class="sheet-panel abilities-panel"> <!-- El que es mira primer: classe d'armadura, velocitat i els bonificadors
<h2>{{ $t('campaigns.character-sheet.ability-scores') }}</h2> que acompanyen els cops, tot just sota la imatge. -->
<div class="ability-grid"> <section class="sheet-panel vitals-panel">
<div v-for="stat in abilityStats" :key="stat.key" class="ability-card"> <div class="vital-stats">
<span class="ability-label">{{ stat.label }}</span> <div class="vital-stat">
<input v-if="editing" v-model.number="form.abilityScores[stat.key]" type="number" min="1" max="30" :aria-label="stat.label"> <span>{{ $t('campaigns.character-sheet.armor-class') }}</span>
<strong v-else class="ability-score">{{ form.abilityScores[stat.key] }}</strong> <input v-if="editing" v-model.number="form.armorClass" type="number" min="0" :aria-label="$t('campaigns.character-sheet.armor-class')">
<span class="ability-modifier">{{ abilityModifier(form.abilityScores[stat.key]) }}</span> <strong v-else>{{ form.armorClass }}</strong>
</div>
</div> </div>
<div class="proficiency-badge"> <div class="vital-stat">
<span>{{ $t('campaigns.character-sheet.speed') }}</span>
<label v-if="editing" class="number-with-unit"><input v-model.number="form.speed" type="number" min="0" :aria-label="$t('campaigns.character-sheet.speed')"><small>ft</small></label>
<strong v-else>{{ form.speed }} <small>ft</small></strong>
</div>
<div class="vital-stat">
<span>{{ $t('campaigns.character-sheet.proficiency-bonus') }}</span> <span>{{ $t('campaigns.character-sheet.proficiency-bonus') }}</span>
<strong>+{{ proficiencyBonus }}</strong> <strong>+{{ proficiencyBonus }}</strong>
</div> </div>
</section> <div class="vital-stat">
<span>{{ $t('campaigns.character-sheet.initiative') }}</span>
<section class="sheet-panel combat-panel"> <strong>{{ initiativeBonus }}</strong>
<h2>{{ $t('campaigns.character-sheet.combat') }}</h2>
<div class="combat-stats">
<div class="combat-stat">
<span>{{ $t('campaigns.character-sheet.armor-class') }}</span>
<input v-if="editing" v-model.number="form.armorClass" type="number" min="0">
<strong v-else>{{ form.armorClass }}</strong>
</div>
<div class="combat-stat">
<span>{{ $t('campaigns.character-sheet.speed') }}</span>
<label v-if="editing" class="number-with-unit"><input v-model.number="form.speed" type="number" min="0"><small>ft</small></label>
<strong v-else>{{ form.speed }} <small>ft</small></strong>
</div>
</div> </div>
<h3>{{ $t('campaigns.character-sheet.proficiencies') }}</h3> </div>
<textarea v-if="editing" v-model="form.proficiencies" rows="5" :placeholder="$t('campaigns.character-sheet.proficiencies-placeholder')" />
<p v-else class="sheet-copy">{{ form.proficiencies || $t('campaigns.character-sheet.empty-proficiencies') }}</p>
</section>
</main>
<main v-show="activeTab === 'inventory'" class="sheet-tab-body"> <div class="vital-bar hit-points-bar">
<section class="sheet-panel inventory-panel"> <div class="vital-bar-head">
<div class="panel-title-row"> <span>{{ $t('campaigns.character-sheet.hit-points') }}</span>
<h2>{{ $t('campaigns.character-sheet.inventory') }}</h2> <strong v-if="!editing">{{ form.hitPoints.current }} / {{ form.hitPoints.max }}</strong>
<button v-if="editing" class="sheet-button secondary compact" type="button" @click="addInventoryItem">{{ $t('campaigns.character-sheet.add-item') }}</button> <label v-else class="vital-bar-inputs">
<input v-model.number="form.hitPoints.current" type="number" min="0" :aria-label="$t('campaigns.character-sheet.hit-points')">
<span>/</span>
<input v-model.number="form.hitPoints.max" type="number" min="0" :aria-label="$t('campaigns.character-sheet.max-hit-points')">
</label>
</div> </div>
<div class="weight-summary"> <div class="vital-bar-track"><div class="vital-bar-fill" :style="{ width: `${hitPointsPercent}%` }" /></div>
<span>{{ $t('campaigns.character-sheet.carried-weight') }}</span> </div>
<strong>{{ carriedWeight.toFixed(1) }} / {{ carryingCapacity }} lb</strong>
</div>
<div class="weight-track"><div class="weight-fill" :style="{ width: `${carryPercent}%` }" /></div>
<div class="inventory-table-wrap">
<table class="inventory-table">
<thead><tr>
<th>{{ $t('campaigns.character-sheet.item-name') }}</th>
<th>{{ $t('campaigns.character-sheet.quantity') }}</th>
<th>{{ $t('campaigns.character-sheet.weight-each') }}</th>
<th>{{ $t('campaigns.character-sheet.total-weight') }}</th>
<th v-if="editing"><span class="sr-only">{{ $t('campaigns.character-sheet.actions') }}</span></th>
</tr></thead>
<tbody>
<tr v-for="(item, index) in form.inventory" :key="index">
<td><input v-if="editing" v-model="item.name" :aria-label="$t('campaigns.character-sheet.item-name')"><span v-else>{{ item.name }}</span></td>
<td><input v-if="editing" v-model.number="item.quantity" type="number" min="1" :aria-label="$t('campaigns.character-sheet.quantity')"><span v-else>{{ item.quantity }}</span></td>
<td><input v-if="editing" v-model.number="item.weight" type="number" min="0" step="0.1" :aria-label="$t('campaigns.character-sheet.weight-each')"><span v-else>{{ Number(item.weight).toFixed(1) }} lb</span></td>
<td>{{ ((Number(item.quantity) || 0) * (Number(item.weight) || 0)).toFixed(1) }} lb</td>
<td v-if="editing"><button class="remove-item" type="button" @click="removeInventoryItem(index)">×</button></td>
</tr>
<tr v-if="form.inventory.length === 0"><td :colspan="editing ? 5 : 4" class="empty-inventory">{{ $t('campaigns.character-sheet.empty-inventory') }}</td></tr>
</tbody>
</table>
</div>
</section>
</main>
<main v-show="activeTab === 'traits'" class="sheet-tab-body"> <div class="vital-bar hit-dice-bar">
<section class="sheet-panel traits-panel"> <div class="vital-bar-head">
<h2>{{ $t('campaigns.character-sheet.traits') }}</h2> <span>{{ $t('campaigns.character-sheet.hit-dice') }}</span>
<textarea v-if="editing" v-model="form.traits" rows="12" :placeholder="$t('campaigns.character-sheet.traits-placeholder')" /> <strong v-if="!editing">{{ form.hitDice.current }} / {{ form.hitDice.max }}</strong>
<p v-else class="sheet-copy">{{ form.traits || $t('campaigns.character-sheet.empty-traits') }}</p> <label v-else class="vital-bar-inputs">
</section> <input v-model.number="form.hitDice.current" type="number" min="0" :aria-label="$t('campaigns.character-sheet.hit-dice')">
</main> <span>/</span>
<input v-model.number="form.hitDice.max" type="number" min="0" :aria-label="$t('campaigns.character-sheet.max-hit-dice')">
<main v-show="activeTab === 'spells'" class="sheet-tab-body"> </label>
<section class="sheet-panel spells-panel"> </div>
<h2>{{ $t('campaigns.character-sheet.spells') }}</h2> <div class="vital-bar-track"><div class="vital-bar-fill" :style="{ width: `${hitDicePercent}%` }" /></div>
<textarea v-if="editing" v-model="form.spells" rows="12" :placeholder="$t('campaigns.character-sheet.spells-placeholder')" /> </div>
<p v-else class="sheet-copy">{{ form.spells || $t('campaigns.character-sheet.empty-spells') }}</p> </section>
</section>
</main>
</div> </div>
<nav class="sheet-tabs" role="tablist" aria-orientation="vertical"> <main v-show="activeTab === 'abilities'" class="sheet-tab-body">
<button <section class="sheet-panel abilities-panel">
v-for="tab in tabs" <h2>{{ $t('campaigns.character-sheet.ability-scores') }}</h2>
:key="tab.key" <div class="ability-grid">
class="sheet-tab" <div v-for="stat in abilityStats" :key="stat.key" class="ability-card">
:class="{ active: activeTab === tab.key }" <span class="ability-label">{{ stat.label }}</span>
type="button" <input v-if="editing" v-model.number="form.abilityScores[stat.key]" type="number" min="1" max="30" :aria-label="stat.label">
role="tab" <strong v-else class="ability-score">{{ form.abilityScores[stat.key] }}</strong>
:aria-selected="activeTab === tab.key" <span class="ability-modifier">{{ abilityModifier(form.abilityScores[stat.key]) }}</span>
@click="activeTab = tab.key" </div>
>{{ $t(tab.label) }}</button> </div>
</nav>
<!-- Les tirades de salvació van just a sota de les característiques, que
són les que les manen: el cercle diu si el personatge hi està entrenat. -->
<h3>{{ $t('campaigns.character-sheet.saving-throws') }}</h3>
<div class="saving-throw-grid">
<button
v-for="stat in abilityStats"
:key="stat.key"
class="proficiency-row"
type="button"
role="switch"
:aria-checked="form.savingThrows[stat.key]"
:disabled="!editing"
@click="toggleProficiency('savingThrows', stat.key)"
>
<span class="proficiency-dot" :class="{ proficient: form.savingThrows[stat.key] }" aria-hidden="true" />
<span class="proficiency-name">{{ $t(`campaigns.character-sheet.abilities.${stat.key}`) }}</span>
<span class="proficiency-modifier">{{ savingThrowModifier(stat) }}</span>
</button>
</div>
</section>
<section class="sheet-panel skills-panel">
<h2>{{ $t('campaigns.character-sheet.skills') }}</h2>
<div class="skill-grid">
<button
v-for="skill in skillList"
:key="skill.key"
class="proficiency-row"
type="button"
role="switch"
:aria-checked="form.skills[skill.key]"
:disabled="!editing"
@click="toggleProficiency('skills', skill.key)"
>
<span class="proficiency-dot" :class="{ proficient: form.skills[skill.key] }" aria-hidden="true" />
<span class="proficiency-name">{{ $t(`campaigns.character-sheet.skill-names.${skill.key}`) }}</span>
<span class="proficiency-ability">{{ skill.ability.toUpperCase() }}</span>
<span class="proficiency-modifier">{{ skillModifier(skill) }}</span>
</button>
</div>
</section>
<section class="sheet-panel proficiencies-panel">
<h2>{{ $t('campaigns.character-sheet.proficiencies') }}</h2>
<textarea v-if="editing" v-model="form.proficiencies" rows="7" :placeholder="$t('campaigns.character-sheet.proficiencies-placeholder')" />
<p v-else class="sheet-copy">{{ form.proficiencies || $t('campaigns.character-sheet.empty-proficiencies') }}</p>
<!-- Les eines i els idiomes tenen llista pròpia; el text de dalt guarda
el que no en té, com les armadures i les armes. -->
<div class="proficiency-lists">
<div class="proficiency-list">
<h3>{{ $t('campaigns.character-sheet.tools') }}</h3>
<textarea v-if="editing" v-model="form.tools" rows="4" :placeholder="$t('campaigns.character-sheet.tools-placeholder')" />
<p v-else class="sheet-copy">{{ form.tools || $t('campaigns.character-sheet.empty-tools') }}</p>
</div>
<div class="proficiency-list">
<h3>{{ $t('campaigns.character-sheet.languages') }}</h3>
<textarea v-if="editing" v-model="form.languages" rows="4" :placeholder="$t('campaigns.character-sheet.languages-placeholder')" />
<p v-else class="sheet-copy">{{ form.languages || $t('campaigns.character-sheet.empty-languages') }}</p>
</div>
</div>
</section>
</main>
<main v-show="activeTab === 'inventory'" class="sheet-tab-body">
<section class="sheet-panel inventory-panel">
<div class="panel-title-row">
<h2>{{ $t('campaigns.character-sheet.inventory') }}</h2>
<button v-if="editing" class="sheet-button secondary compact" type="button" @click="addInventoryItem">{{ $t('campaigns.character-sheet.add-item') }}</button>
</div>
<div class="weight-summary">
<span>{{ $t('campaigns.character-sheet.carried-weight') }}</span>
<strong>{{ carriedWeight.toFixed(1) }} / {{ carryingCapacity }} lb</strong>
</div>
<div class="weight-track"><div class="weight-fill" :style="{ width: `${carryPercent}%` }" /></div>
<!-- La moneda que el personatge porta a sobre, en les cinc monedes del joc. -->
<h3>{{ $t('campaigns.character-sheet.currency') }}</h3>
<div class="currency-row">
<label v-for="unit in currencyUnits" :key="unit" class="currency-field">
<span>{{ $t(`campaigns.character-sheet.currency-units.${unit}`) }}</span>
<input v-if="editing" v-model.number="form.currency[unit]" type="number" min="0" :aria-label="$t(`campaigns.character-sheet.currency-units.${unit}`)">
<strong v-else>{{ form.currency[unit] }}</strong>
</label>
</div>
<div class="inventory-table-wrap">
<table class="inventory-table">
<thead><tr>
<th><span class="sr-only">{{ $t('campaigns.character-sheet.item-icon') }}</span></th>
<th class="item-name-cell">{{ $t('campaigns.character-sheet.item-name') }}</th>
<th>{{ $t('campaigns.character-sheet.quantity') }}</th>
<th>{{ $t('campaigns.character-sheet.weight-each') }}</th>
<th>{{ $t('campaigns.character-sheet.total-weight') }}</th>
<th v-if="editing"><span class="sr-only">{{ $t('campaigns.character-sheet.actions') }}</span></th>
</tr></thead>
<tbody>
<tr v-for="(item, index) in form.inventory" :key="index">
<td class="item-icon-cell">
<img v-if="item.icon" :src="resolveImage(item.icon)" :alt="$t('campaigns.character-sheet.item-icon')">
<span v-else class="item-icon-blank" aria-hidden="true" />
</td>
<td class="item-name-cell"><input v-if="editing" v-model="item.name" :aria-label="$t('campaigns.character-sheet.item-name')"><span v-else>{{ item.name }}</span></td>
<td><input v-if="editing" v-model.number="item.quantity" type="number" min="1" :aria-label="$t('campaigns.character-sheet.quantity')"><span v-else>{{ item.quantity }}</span></td>
<td><input v-if="editing" v-model.number="item.weight" type="number" min="0" step="0.1" :aria-label="$t('campaigns.character-sheet.weight-each')"><span v-else>{{ Number(item.weight).toFixed(1) }} lb</span></td>
<td>{{ ((Number(item.quantity) || 0) * (Number(item.weight) || 0)).toFixed(1) }} lb</td>
<td v-if="editing"><button class="remove-item" type="button" @click="removeInventoryItem(index)">×</button></td>
</tr>
<tr v-if="form.inventory.length === 0"><td :colspan="editing ? 6 : 5" class="empty-inventory">{{ $t('campaigns.character-sheet.empty-inventory') }}</td></tr>
</tbody>
</table>
</div>
</section>
</main>
<main v-show="activeTab === 'traits'" class="sheet-tab-body">
<section class="sheet-panel traits-panel">
<h2>{{ $t('campaigns.character-sheet.traits') }}</h2>
<textarea v-if="editing" v-model="form.traits" rows="12" :placeholder="$t('campaigns.character-sheet.traits-placeholder')" />
<p v-else class="sheet-copy">{{ form.traits || $t('campaigns.character-sheet.empty-traits') }}</p>
</section>
</main>
<main v-show="activeTab === 'spells'" class="sheet-tab-body">
<section class="sheet-panel spells-panel">
<h2>{{ $t('campaigns.character-sheet.spells') }}</h2>
<textarea v-if="editing" v-model="form.spells" rows="12" :placeholder="$t('campaigns.character-sheet.spells-placeholder')" />
<p v-else class="sheet-copy">{{ form.spells || $t('campaigns.character-sheet.empty-spells') }}</p>
</section>
</main>
</div> </div>
</div> </div>
</div> </div>
@@ -358,16 +555,18 @@ 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; 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-layout { display: flex; align-items: flex-start; gap: 10px; } de la pestanya oberta. */
.sheet-content { flex: 1 1 auto; min-width: 0; } .sheet-layout { display: grid; grid-template-columns: minmax(200px, 34%) minmax(0, 1fr); gap: 11px; align-items: start; }
.sheet-tab-body { display: block; } .sheet-tab-body { grid-column: 2; grid-row: 1; display: flex; flex-direction: column; gap: 11px; min-width: 0; }
.sheet-tabs { flex: 0 0 auto; display: flex; flex-direction: column; gap: 6px; position: sticky; top: 0; align-self: flex-start; } /* 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). */
.sheet-tabs { position: absolute; left: 100%; top: 34px; display: flex; flex-direction: column; align-items: flex-start; gap: 5px; padding-top: 6px; }
.sheet-tab { .sheet-tab {
text-align: left; text-align: left;
padding: 9px 14px 9px 11px; padding: 9px 14px 9px 11px;
border: 1px solid var(--color-border); border: 1px solid var(--color-border);
border-left-width: 3px; border-left: 0;
border-radius: 0 9px 9px 0; border-radius: 0 9px 9px 0;
background: var(--color-background-soft); background: var(--color-background-soft);
color: var(--color-text); color: var(--color-text);
@@ -378,11 +577,11 @@ async function saveSheet() {
transition: background .15s ease, border-color .15s ease, color .15s ease; transition: background .15s ease, border-color .15s ease, color .15s ease;
} }
.sheet-tab:hover { background: var(--color-button-hover); } .sheet-tab:hover { background: var(--color-button-hover); }
.sheet-tab.active { background: var(--color-background-light); color: var(--color-link); border-left-color: var(--color-link); box-shadow: 0 3px 12px var(--color-window-shadow); } .sheet-tab.active { background: var(--color-background-light); color: var(--color-link); border-color: var(--color-link); box-shadow: 0 3px 12px var(--color-window-shadow); }
.sheet-panel { min-width: 0; padding: 13px; border: 1px solid var(--color-border); border-radius: 10px; background: var(--color-background-light); box-shadow: 0 3px 12px var(--color-window-shadow); } .sheet-panel { min-width: 0; padding: 13px; border: 1px solid var(--color-border); border-radius: 10px; background: var(--color-background-light); box-shadow: 0 3px 12px var(--color-window-shadow); }
.sheet-panel h2 { margin: 0 0 12px; padding-bottom: 7px; border-bottom: 1px solid var(--color-border); font: 17px MrEavesRemake; letter-spacing: .03em; } .sheet-panel h2 { margin: 0 0 12px; padding-bottom: 7px; border-bottom: 1px solid var(--color-border); font: 17px MrEavesRemake; letter-spacing: .03em; }
.sheet-panel h3 { margin: 13px 0 7px; font: 14px MrEavesRemake; } .sheet-panel h3 { margin: 13px 0 7px; font: 14px MrEavesRemake; }
.sheet-portrait { grid-column: 1; grid-row: 1 / -1; position: relative; overflow: hidden; border: 1px solid var(--color-border); border-radius: 10px; background: var(--color-background-soft); } .sheet-portrait { position: relative; overflow: hidden; border: 1px solid var(--color-border); border-radius: 10px; background: var(--color-background-soft); }
.sheet-portrait.empty { display: grid; place-items: center; min-height: 220px; border-style: dashed; } .sheet-portrait.empty { display: grid; place-items: center; min-height: 220px; border-style: dashed; }
.sheet-portrait img { display: block; width: 100%; height: auto; } .sheet-portrait img { display: block; width: 100%; height: auto; }
.portrait-upload { border: 0; padding: 8px 10px; background: transparent; color: var(--color-link); font-size: 12px; cursor: pointer; } .portrait-upload { border: 0; padding: 8px 10px; background: transparent; color: var(--color-link); font-size: 12px; cursor: pointer; }
@@ -392,21 +591,46 @@ async function saveSheet() {
.portrait-controls button:hover { background: var(--color-button-hover); } .portrait-controls button:hover { background: var(--color-button-hover); }
.portrait-controls button:disabled { opacity: .55; cursor: wait; } .portrait-controls button:disabled { opacity: .55; cursor: wait; }
.photo-input { display: none; } .photo-input { display: none; }
.abilities-panel { grid-column: 2 / -1; grid-row: 1; } /* La columna de la fitxa: la imatge dalt i, just a sota, el que es consulta d'anada i
.combat-panel { grid-column: 2 / -1; grid-row: 2; } tornada — classe d'armadura, velocitat, bonificadors i les barres de cops. No penja de
cap pestanya: es queda al seu lloc mentre se'n canvia. */
.character-column { grid-column: 1; grid-row: 1; display: flex; flex-direction: column; gap: 11px; min-width: 0; }
.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; }
.ability-score { font: 25px MrEavesRemake; } .ability-score { font: 25px MrEavesRemake; }
.ability-modifier { min-width: 33px; text-align: center; padding: 2px 5px; border-radius: 999px; background: var(--color-background); font-size: 12px; } .ability-modifier { min-width: 33px; text-align: center; padding: 2px 5px; border-radius: 999px; background: var(--color-background); font-size: 12px; }
.ability-card input { width: 55px; text-align: center; font-size: 21px; } .ability-card input { width: 55px; text-align: center; font-size: 21px; }
.proficiency-badge { display: flex; justify-content: space-between; align-items: center; margin-top: 9px; padding: 8px; border-radius: 8px; background: var(--color-background-soft); font-size: 12px; } /* Les habilitats i les tirades de salvació: el cercle diu si el personatge hi està
.proficiency-badge strong { font-size: 15px; color: var(--color-link); } entrenat, al costat la característica que mana i la modificadora que tira. */
.combat-stats { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; } .saving-throw-grid { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 5px; }
.combat-stat { min-height: 72px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 5px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); } .skill-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 5px; }
.combat-stat > span { font-size: 11px; text-transform: uppercase; letter-spacing: .05em; opacity: .72; } .proficiency-row { display: flex; align-items: center; gap: 6px; min-width: 0; padding: 5px 7px; border: 1px solid var(--color-border); border-radius: 7px; background: var(--color-background-soft); color: var(--color-text); font: inherit; font-size: 12px; text-align: left; cursor: pointer; }
.combat-stat > strong { font: 25px MrEavesRemake; } .proficiency-row:hover:not(:disabled) { border-color: var(--color-link); }
.combat-stat small { font-size: 11px; opacity: .7; } .proficiency-row:disabled { cursor: default; }
.proficiency-dot { width: 14px; height: 14px; flex: 0 0 14px; border: 2px solid var(--color-border); border-radius: 50%; }
.proficiency-dot.proficient { border-color: var(--color-link); background: var(--color-link); box-shadow: inset 0 0 0 2px var(--color-background-soft); }
.proficiency-name { flex: 1; min-width: 0; overflow-wrap: anywhere; }
.proficiency-ability { font-size: 10px; letter-spacing: .06em; opacity: .6; }
.proficiency-modifier { font-size: 11px; opacity: .8; }
.proficiency-lists { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 11px; }
.vitals-panel { display: flex; flex-direction: column; gap: 11px; }
.vital-stats { display: grid; grid-template-columns: 1fr 1fr; gap: 7px; }
.vital-stat { min-height: 68px; display: flex; flex-direction: column; align-items: center; justify-content: center; gap: 4px; padding: 6px 4px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); text-align: center; }
.vital-stat > span { font-size: 10px; text-transform: uppercase; letter-spacing: .05em; opacity: .72; }
.vital-stat > strong { font: 25px MrEavesRemake; }
.vital-stat small { font-size: 11px; opacity: .7; }
.vital-stat input { width: 57px; text-align: center; }
/* Les dues barres: punts de cop i daus de cop, plenes fins on arriben. */
.vital-bar-head { display: flex; justify-content: space-between; align-items: center; gap: 8px; }
.vital-bar-head > span { font-size: 10px; text-transform: uppercase; letter-spacing: .05em; opacity: .72; }
.vital-bar-head > strong { font: 15px MrEavesRemake; white-space: nowrap; }
.vital-bar-inputs { display: flex; align-items: center; gap: 4px; }
.vital-bar-inputs input { width: 52px; text-align: center; }
.vital-bar-track { height: 8px; margin-top: 5px; overflow: hidden; border-radius: 999px; background: var(--color-background); }
.vital-bar-fill { height: 100%; border-radius: inherit; transition: width .2s ease; }
.hit-points-bar .vital-bar-fill { background: var(--color-red); }
.hit-dice-bar .vital-bar-fill { background: var(--color-link); }
.number-with-unit { display: flex; align-items: center; gap: 4px; } .number-with-unit { display: flex; align-items: center; gap: 4px; }
.number-with-unit input { width: 57px; } .number-with-unit input { width: 57px; }
.sheet-copy { min-height: 74px; margin: 0; white-space: pre-wrap; overflow-wrap: anywhere; font-size: 13px; line-height: 1.45; opacity: .85; } .sheet-copy { min-height: 74px; margin: 0; white-space: pre-wrap; overflow-wrap: anywhere; font-size: 13px; line-height: 1.45; opacity: .85; }
@@ -421,29 +645,42 @@ textarea { resize: vertical; width: 100%; min-height: 88px; font-size: 12px; }
.weight-track { height: 5px; margin-bottom: 10px; overflow: hidden; border-radius: 999px; background: var(--color-background-soft); } .weight-track { height: 5px; margin-bottom: 10px; overflow: hidden; border-radius: 999px; background: var(--color-background-soft); }
.weight-fill { height: 100%; border-radius: inherit; background: var(--color-link); transition: width .2s ease; } .weight-fill { height: 100%; border-radius: inherit; background: var(--color-link); transition: width .2s ease; }
.inventory-table-wrap { overflow-x: auto; } .inventory-table-wrap { overflow-x: auto; }
/* La moneda que el personatge porta a sobre, en les cinc del joc. */
.currency-row { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 7px; margin-bottom: 11px; }
.currency-field { display: flex; flex-direction: column; align-items: center; gap: 3px; padding: 6px 4px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); text-align: center; }
.currency-field > span { font-size: 10px; letter-spacing: .05em; opacity: .72; }
.currency-field > strong { font: 15px MrEavesRemake; }
.currency-field input { width: 58px; text-align: center; }
.inventory-table { width: 100%; border-collapse: collapse; font-size: 12px; } .inventory-table { width: 100%; border-collapse: collapse; font-size: 12px; }
.inventory-table th { padding: 6px 7px; text-align: left; font-weight: 600; opacity: .7; } .inventory-table th { padding: 6px 7px; text-align: left; font-weight: 600; opacity: .7; }
.inventory-table td { padding: 5px 7px; border-top: 1px solid var(--color-border); } .inventory-table td { padding: 5px 7px; border-top: 1px solid var(--color-border); }
.inventory-table td input { width: 100%; min-width: 54px; } .inventory-table td input { width: 100%; min-width: 54px; }
.inventory-table td:first-child input { min-width: 100px; } .inventory-table td.item-name-cell input { min-width: 100px; }
.inventory-table th:not(:first-child), .inventory-table td:not(:first-child) { text-align: center; } /* La icona de cada objecte obre la filera; el nom continua alineat a l'esquerra i la
quantitat i els pesos van al centre. */
.inventory-table .item-icon-cell { width: 40px; padding-right: 0; }
.item-icon-cell img { display: block; width: 26px; height: 26px; object-fit: contain; border-radius: 5px; }
.item-icon-blank { display: block; width: 26px; height: 26px; border: 1px dashed var(--color-border); border-radius: 5px; opacity: .35; }
.inventory-table th:not(:first-child):not(.item-name-cell), .inventory-table td:not(:first-child):not(.item-name-cell) { text-align: center; }
.empty-inventory { text-align: center !important; opacity: .65; } .empty-inventory { text-align: center !important; opacity: .65; }
.remove-item { width: 24px; height: 24px; border: 0; border-radius: 5px; background: transparent; color: var(--color-text); font-size: 20px; cursor: pointer; } .remove-item { width: 24px; height: 24px; border: 0; border-radius: 5px; background: transparent; color: var(--color-text); font-size: 20px; cursor: pointer; }
.remove-item:hover { background: var(--color-button-hover); } .remove-item:hover { background: var(--color-button-hover); }
.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; }
.sheet-portrait, .abilities-panel, .combat-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
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-tab { flex: 1 1 auto; text-align: center; border-left: 1px solid var(--color-border); border-radius: 8px 8px 0 0; }
} }
@media (max-width: 520px) { @media (max-width: 520px) {
.sheet-body { padding: 10px; } .sheet-body { padding: 10px; }
.sheet-hero { align-items: flex-start; flex-wrap: wrap; } .sheet-hero { align-items: flex-start; flex-wrap: wrap; }
.sheet-actions { margin-left: auto; } .sheet-actions { margin-left: auto; }
.ability-grid { grid-template-columns: repeat(3, minmax(0, 1fr)); } .ability-grid { grid-template-columns: repeat(3, minmax(0, 1fr)); }
.sheet-layout { flex-direction: column; } .skill-grid, .saving-throw-grid, .proficiency-lists { grid-template-columns: 1fr; }
.sheet-tabs { flex-direction: row; flex-wrap: wrap; order: -1; } .currency-row { grid-template-columns: repeat(3, minmax(0, 1fr)); }
.sheet-tab { flex: 1 1 auto; text-align: center; border-radius: 7px; border-left-width: 1px; border-top-width: 3px; }
.sheet-tab.active { border-left-color: var(--color-border); border-top-color: var(--color-link); }
} }
</style> </style>

View File

@@ -20,13 +20,13 @@ function initialForm() {
if (!editing) { if (!editing) {
return { return {
name: '', type: 'character', species: '', className: '', level: '', background: '', challengeRating: '', name: '', type: 'character', species: '', className: '', level: '', background: '', challengeRating: '',
category: 'adventuring-gear', rarity: 'common', quantity: 1, weight: '', properties: '', description: '' category: 'adventuring-gear', rarity: 'common', weight: '', properties: '', description: ''
}; };
} }
return { return {
name: editing.name ?? '', type: 'character', species: '', className: '', level: '', background: '', challengeRating: '', name: editing.name ?? '', type: 'character', species: '', className: '', level: '', background: '', challengeRating: '',
category: editing.category ?? 'adventuring-gear', rarity: editing.rarity ?? 'common', category: editing.category ?? 'adventuring-gear', rarity: editing.rarity ?? 'common',
quantity: editing.quantity ?? 1, weight: editing.weight ?? '', properties: editing.properties ?? '', weight: editing.weight ?? '', properties: editing.properties ?? '',
description: editing.description ?? '' description: editing.description ?? ''
}; };
} }
@@ -49,7 +49,7 @@ async function saveEntry() {
? { name: form.value.name.trim(), campaign: data.campaign } ? { name: form.value.name.trim(), campaign: data.campaign }
: { name: form.value.name.trim(), ...(editing ? { id: editing._id } : { campaign: data.campaign }) }; : { name: form.value.name.trim(), ...(editing ? { id: editing._id } : { campaign: data.campaign }) };
if (!isActor) { if (!isActor) {
for (const field of ['category', 'rarity', 'quantity', 'weight', 'properties', 'description']) { for (const field of ['category', 'rarity', 'weight', 'properties', 'description']) {
payload[field] = form.value[field]; payload[field] = form.value[field];
} }
} }
@@ -105,10 +105,6 @@ async function saveEntry() {
<option value="artifact">{{ $t('campaigns.item.rarities.artifact') }}</option> <option value="artifact">{{ $t('campaigns.item.rarities.artifact') }}</option>
</select> </select>
</label> </label>
<label class="form-field">
<span>{{ $t('campaigns.item.quantity') }}</span>
<input v-model.number="form.quantity" type="number" min="1" required>
</label>
<label class="form-field"> <label class="form-field">
<span>{{ $t('campaigns.item.weight') }}</span> <span>{{ $t('campaigns.item.weight') }}</span>
<input v-model="form.weight" type="number" min="0" step="0.1"> <input v-model="form.weight" type="number" min="0" step="0.1">

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,171 @@
<script setup>
import { computed, onBeforeUnmount, onMounted, ref } from 'vue';
import { useI18n } from 'vue-i18n';
import { SetupHandle, SetSize, ResetPosition, ClearWindow, Top, SetResizable, SetMinSize } from '@/services/Windows';
import WindowHandle from './partials/WindowHandle.vue';
import Server from '~/services/Server';
import { emitter } from '~/services/Emitter';
const props = defineProps(['data']);
const id = props.data.id;
const itemId = props.data.item?._id;
const campaign = props.data.campaign || '';
const ICON_ROOT = 'icons';
const handle = ref(null);
const wrapper = ref(null);
const loading = ref(false);
const error = ref('');
const applying = ref('');
// What the window is standing on: one folder of Foundry's icon library at a time.
const listing = ref({ dir: ICON_ROOT, parent: null, folders: [], files: [], next: null });
const { t } = useI18n();
onMounted(() => {
Top(wrapper);
SetupHandle(id, handle);
SetSize(id, { width: 560, height: 540 });
ResetPosition(id, 'center');
SetResizable(id, true);
SetMinSize(id, { width: 420, height: 340 });
Load(ICON_ROOT);
});
onBeforeUnmount(() => ClearWindow({ type: 'foundry_icons' }));
// One request per folder, and the icons inside it a page at a time: that library
// runs into the thousands, so the window only ever asks for what it shows.
async function Load(dir, offset = 0) {
if (loading.value) return;
if (!campaign) {
error.value = t('foundry.errors.icons-no-world-url');
return;
}
loading.value = true;
error.value = '';
try {
const params = new URLSearchParams({ campaign, dir });
if (offset) params.set('offset', String(offset));
const response = await Server().get(`/foundry/icons?${params.toString()}`);
if (response.data.status !== 'ok') {
error.value = t(response.data.msg || 'foundry.errors.icons-unavailable');
return;
}
const page = {
dir: response.data.dir || dir,
parent: response.data.parent ?? null,
folders: response.data.folders || [],
files: response.data.files || [],
next: response.data.next ?? null,
};
listing.value = offset
? { ...page, files: [...listing.value.files, ...page.files] }
: page;
} catch (requestError) {
// The route answers every real failure with an i18n key in `msg`, but
// axios rejects a non-2xx response, so this catch would otherwise blame
// the bridge for anything at all — a campaign without a world address,
// a folder that went missing. Read the reason off the response and say
// that instead (Syndria98/dragonroll#74).
error.value = t(requestError.response?.data?.msg || 'foundry.errors.icons-unavailable');
} finally {
loading.value = false;
}
}
const trail = computed(() => {
const parts = String(listing.value.dir || ICON_ROOT).split('/').filter(Boolean);
return parts.map((name, index) => ({ name, path: parts.slice(0, index + 1).join('/') }));
});
const empty = computed(() => !loading.value && !listing.value.folders.length && !listing.value.files.length);
function GoUp() {
Load(listing.value.parent || ICON_ROOT);
}
// The icon is stored as the url the browser loads it from, the same shape a synced
// Foundry item's icon has; the item window follows the event this leaves behind.
async function Choose(icon) {
if (applying.value) return;
applying.value = icon.path;
error.value = '';
try {
const response = await Server().post('/item/update', { id: itemId, image: icon.url });
if (response.data.status !== 'ok') {
error.value = t('campaigns.item.sheet.save-error');
return;
}
emitter.emit('campaign-entry-updated', { entityType: 'item', entry: response.data.item });
ClearWindow({ type: 'foundry_icons' });
ClearWindow({ type: 'item_icon_source' });
} catch (requestError) {
error.value = t('campaigns.item.sheet.save-error');
} finally {
applying.value = '';
}
}
</script>
<template>
<div class="window-wrapper foundry-icons-window" :id="'window-wrapper-' + id" ref="wrapper">
<WindowHandle :window="id" ref="handle" />
<div class="icons-body">
<nav class="icons-trail" :aria-label="$t('foundry.icons.path')">
<button class="trail-up" type="button" :disabled="loading || !listing.parent" :aria-label="$t('foundry.icons.up')" @click="GoUp">
<img class="icon" src="/icons/iconoir/regular/arrow-up.svg" alt="" aria-hidden="true">
</button>
<template v-for="crumb in trail" :key="crumb.path">
<span class="trail-separator" aria-hidden="true">/</span>
<button class="trail-crumb" type="button" :disabled="loading" @click="Load(crumb.path)">{{ crumb.name }}</button>
</template>
</nav>
<div v-if="error" class="icons-error">{{ error }}</div>
<p v-if="loading" class="icons-state">{{ $t('foundry.icons.loading') }}</p>
<p v-else-if="empty" class="icons-state">{{ $t('foundry.icons.empty') }}</p>
<div v-if="listing.folders.length" class="icon-tiles">
<button v-for="folder in listing.folders" :key="folder.path" class="icon-tile folder" type="button" :disabled="loading" @click="Load(folder.path)">
<img class="icon" src="/icons/iconoir/regular/folder.svg" alt="" aria-hidden="true">
<span class="tile-name">{{ folder.name }}</span>
</button>
</div>
<div v-if="listing.files.length" class="icon-tiles">
<button v-for="icon in listing.files" :key="icon.path" class="icon-tile" type="button"
:disabled="applying !== ''" :title="icon.name" @click="Choose(icon)">
<img class="tile-image" :src="icon.url" :alt="icon.name" loading="lazy">
<span class="tile-name">{{ icon.name }}</span>
</button>
</div>
<button v-if="listing.next" class="icons-more sheet-button" type="button" :disabled="loading" @click="Load(listing.dir, listing.next)">
{{ $t('foundry.icons.load-more') }}
</button>
</div>
</div>
</template>
<style scoped>
.foundry-icons-window { min-width: 0; min-height: 0; }
.icons-body { width: 100%; min-height: 0; flex: 1; overflow: auto; padding: 12px 14px 16px; box-sizing: border-box; display: flex; flex-direction: column; gap: 10px; }
.icons-trail { display: flex; align-items: center; flex-wrap: wrap; gap: 4px; position: sticky; top: 0; padding-bottom: 8px; background: var(--color-window-background); font-size: 12px; }
.trail-up, .trail-crumb { display: inline-flex; align-items: center; padding: 4px 7px; border: 1px solid var(--color-border); border-radius: 6px; background: var(--color-background-soft); color: var(--color-text); cursor: pointer; font-size: 12px; }
.trail-up:hover, .trail-crumb:hover { background: var(--color-button-hover); }
.trail-up:disabled, .trail-crumb:disabled { opacity: .5; cursor: wait; }
.trail-separator { opacity: .45; }
.icons-error { padding: 7px 10px; border-radius: 6px; color: var(--color-red); background: var(--color-background-soft); font-size: 12px; }
.icons-state { margin: 0; font-size: 12px; opacity: .7; }
.icon-tiles { display: grid; grid-template-columns: repeat(auto-fill, minmax(78px, 1fr)); gap: 8px; }
.icon-tile { display: flex; flex-direction: column; align-items: center; gap: 5px; padding: 8px 6px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); color: var(--color-text); cursor: pointer; }
.icon-tile:hover { background: var(--color-button-hover); border-color: var(--color-link); }
.icon-tile:disabled { opacity: .55; cursor: wait; }
.icon-tile.folder { justify-content: center; }
.icon-tile .icon { width: 22px; height: 22px; }
.tile-image { width: 40px; height: 40px; object-fit: contain; }
.tile-name { max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 10px; opacity: .75; }
.icons-more { align-self: center; border: 1px solid var(--color-border); border-radius: 7px; padding: 7px 12px; background: var(--color-background-soft); color: var(--color-text); cursor: pointer; white-space: nowrap; font-size: 13px; }
.icons-more:hover { background: var(--color-button-hover); }
.icons-more:disabled { opacity: .55; cursor: wait; }
</style>

View File

@@ -0,0 +1,128 @@
<script setup>
import { computed, onBeforeUnmount, onMounted, ref } from 'vue';
import { useI18n } from 'vue-i18n';
import { SetupHandle, SetSize, ResetPosition, ClearWindow, Top, CreateChildWindow } from '@/services/Windows';
import WindowHandle from './partials/WindowHandle.vue';
import Server, { getBaseUrl } from '~/services/Server';
import { emitter } from '~/services/Emitter';
const props = defineProps(['data']);
const id = props.data.id;
const item = props.data.item || {};
const itemId = item._id;
const campaign = props.data.campaign || '';
const handle = ref(null);
const wrapper = ref(null);
const error = ref('');
const uploading = ref(false);
const photoInput = ref(null);
const image = ref(item.image || '');
const { t } = useI18n();
onMounted(() => {
Top(wrapper);
SetupHandle(id, handle);
SetSize(id, { width: 430, height: 320 });
ResetPosition(id, 'center');
});
onBeforeUnmount(() => ClearWindow({ type: 'item_icon_source' }));
// An uploaded icon is a file of the backend's uploads folder and a Foundry one an
// absolute url of the world; both are drawn the way the item window draws them.
const imageUrl = computed(() => {
if (!image.value) return '';
return /^(https?:|data:|\/\/)/i.test(image.value)
? image.value
: `${getBaseUrl()}/public/${image.value}`;
});
function pickLocalIcon() {
photoInput.value?.click();
}
// The icon browser opens on top of this window, as its child: closing the chooser
// takes the browser with it, like every other child window here.
function openFoundryIcons() {
CreateChildWindow(id, 'foundry_icons', { item: { _id: itemId, name: item.name }, campaign });
}
async function onIconSelected(event) {
const file = event.target.files?.[0];
event.target.value = '';
if (!file || uploading.value) return;
uploading.value = true;
error.value = '';
try {
const formData = new FormData();
formData.append('image', file);
const response = await Server().post(`/item/upload-image?item=${itemId}`, formData, {
headers: { "Content-Type": "multipart/form-data" }
});
if (response.data.status !== 'ok') {
error.value = t('campaigns.item.sheet.upload-error');
return;
}
// The item window follows this event and shows the new icon.
emitter.emit('campaign-entry-updated', { entityType: 'item', entry: response.data.item });
ClearWindow({ id });
} catch (requestError) {
error.value = t('campaigns.item.sheet.upload-error');
} finally {
uploading.value = false;
}
}
</script>
<template>
<div class="window-wrapper icon-source-window" :id="'window-wrapper-' + id" ref="wrapper">
<WindowHandle :window="id" ref="handle" />
<div class="source-body">
<header class="source-hero">
<div class="source-icon" :class="{ empty: !image }">
<img v-if="imageUrl" :src="imageUrl" :alt="$t('campaigns.item.sheet.icon')">
<span v-else aria-hidden="true">{{ (item.name || '?').slice(0, 1).toUpperCase() }}</span>
</div>
<p class="source-intro">{{ $t('campaigns.item.icon-picker.intro') }}</p>
</header>
<div v-if="error" class="source-error">{{ error }}</div>
<div class="source-options">
<button class="source-option" type="button" :disabled="uploading" @click="pickLocalIcon">
<img class="icon" src="/icons/iconoir/regular/cloud-upload.svg" alt="" aria-hidden="true">
<span class="source-option-title">{{ uploading
? $t('campaigns.item.sheet.uploading')
: $t('campaigns.item.icon-picker.upload') }}</span>
<span class="source-option-hint">{{ $t('campaigns.item.icon-picker.upload-hint') }}</span>
</button>
<button class="source-option" type="button" @click="openFoundryIcons">
<img class="icon" src="/icons/iconoir/regular/media-image.svg" alt="" aria-hidden="true">
<span class="source-option-title">{{ $t('campaigns.item.icon-picker.foundry') }}</span>
<span class="source-option-hint">{{ $t('campaigns.item.icon-picker.foundry-hint') }}</span>
</button>
</div>
<input ref="photoInput" class="photo-input" type="file" accept="image/*" @change="onIconSelected">
</div>
</div>
</template>
<style scoped>
.icon-source-window { min-width: 0; min-height: 0; }
.source-body { width: 100%; min-height: 0; flex: 1; overflow: auto; padding: 14px 16px 16px; box-sizing: border-box; display: flex; flex-direction: column; gap: 12px; }
.source-hero { display: flex; align-items: center; gap: 13px; padding-bottom: 12px; border-bottom: 1px solid var(--color-border); }
.source-icon { width: 56px; height: 56px; flex: 0 0 56px; display: grid; place-items: center; overflow: hidden; border-radius: 10px; border: 1px solid var(--color-border); background: var(--color-background-soft); color: var(--color-link); font: 26px MrEavesRemake; }
.source-icon.empty { border-style: dashed; }
.source-icon img { width: 100%; height: 100%; object-fit: contain; }
.source-intro { margin: 0; font-size: 13px; opacity: .85; }
.source-error { padding: 7px 10px; border-radius: 6px; color: var(--color-red); background: var(--color-background-soft); font-size: 12px; }
.source-options { display: flex; flex-direction: column; gap: 10px; }
.source-option { display: grid; grid-template-columns: 26px 1fr; align-items: center; gap: 4px 10px; padding: 12px 14px; text-align: left; border: 1px solid var(--color-border); border-radius: 10px; background: var(--color-background-soft); color: var(--color-text); cursor: pointer; }
.source-option:hover { background: var(--color-button-hover); }
.source-option:disabled { opacity: .55; cursor: wait; }
.source-option .icon { width: 20px; height: 20px; grid-row: span 2; }
.source-option-title { font: 15px MrEavesRemake; }
.source-option-hint { font-size: 12px; opacity: .7; }
.photo-input { display: none; }
</style>

View File

@@ -1,9 +1,10 @@
<script setup> <script setup>
import { computed, onBeforeUnmount, onMounted, ref } from 'vue'; import { computed, onBeforeUnmount, onMounted, ref } from 'vue';
import { useI18n } from 'vue-i18n'; import { useI18n } from 'vue-i18n';
import { SetupHandle, SetSize, ResetPosition, ClearWindow, Top } from '@/services/Windows'; import { SetupHandle, SetSize, ResetPosition, ClearWindow, Top, CreateChildWindow } from '@/services/Windows';
import WindowHandle from './partials/WindowHandle.vue'; import WindowHandle from './partials/WindowHandle.vue';
import Server, { getBaseUrl } from '~/services/Server'; import Server, { getBaseUrl } from '~/services/Server';
import { useCampaignService } from '~/services/Campaign.js';
import { emitter } from '~/services/Emitter'; import { emitter } from '~/services/Emitter';
const props = defineProps(['data']); const props = defineProps(['data']);
@@ -12,9 +13,10 @@ const itemId = props.data.item?._id;
const handle = ref(null); const handle = ref(null);
const wrapper = ref(null); const wrapper = ref(null);
const error = ref(''); const error = ref('');
const uploadingIcon = ref(false); // Set while this window writes the item's icon, so a Foundry sync landing behind
const applyingFoundryIcon = ref(false); // the window does not rewrite the form under the change being made.
const photoInput = ref(null); const applyingIcon = ref(false);
const { Campaign } = useCampaignService();
const { t } = useI18n(); const { t } = useI18n();
function normalizeItem(item) { function normalizeItem(item) {
@@ -22,7 +24,6 @@ function normalizeItem(item) {
name: item?.name ?? '', name: item?.name ?? '',
category: item?.category ?? 'adventuring-gear', category: item?.category ?? 'adventuring-gear',
rarity: item?.rarity ?? 'common', rarity: item?.rarity ?? 'common',
quantity: Number(item?.quantity ?? 1),
weight: item?.weight ?? '', weight: item?.weight ?? '',
properties: item?.properties ?? '', properties: item?.properties ?? '',
description: item?.description ?? '', description: item?.description ?? '',
@@ -44,9 +45,10 @@ onMounted(() => {
onBeforeUnmount(() => ClearWindow({ type: 'item_sheet' })); onBeforeUnmount(() => ClearWindow({ type: 'item_sheet' }));
// The sidebar keeps this entry fresh (Foundry sync lands in the background); // The sidebar keeps this entry fresh (Foundry sync lands in the background);
// follow along unless the window is mid-icon-upload. // follow along unless this window is mid-icon-change. The icon windows leave
// their result here, on the same event.
function handleItemSync({ entityType, entry }) { function handleItemSync({ entityType, entry }) {
if (entityType !== 'item' || entry?._id !== itemId || uploadingIcon.value) return; if (entityType !== 'item' || entry?._id !== itemId || applyingIcon.value) return;
form.value = normalizeItem(entry); form.value = normalizeItem(entry);
} }
@@ -70,40 +72,22 @@ async function updateItem(payload) {
return true; return true;
} }
function pickIcon() { // Choosing an icon is a window of its own: upload one from this device, or browse
photoInput.value?.click(); // the icon library of the linked Foundry world. Both leave their result on the
// `campaign-entry-updated` event, which this window follows.
function chooseIcon() {
CreateChildWindow(id, 'item_icon_source', {
item: { _id: itemId, name: form.value.name, image: form.value.image },
campaign: Campaign.value?._id || ''
});
} }
async function onIconSelected(event) { // The world's own icon for this item: the module keeps it on the item, so this
const file = event.target.files?.[0]; // just switches back to it. Picking one of the world's other icons is what the
event.target.value = ''; // icon browser is for.
if (!file || uploadingIcon.value) return;
uploadingIcon.value = true;
error.value = '';
try {
const formData = new FormData();
formData.append('image', file);
const response = await Server().post(`/item/upload-image?item=${itemId}`, formData, {
headers: { "Content-Type": "multipart/form-data" }
});
if (response.data.status !== 'ok') {
error.value = t('campaigns.item.sheet.upload-error');
return;
}
form.value = normalizeItem(response.data.item);
emitter.emit('campaign-entry-updated', { entityType: 'item', entry: response.data.item });
} catch (requestError) {
error.value = t('campaigns.item.sheet.upload-error');
} finally {
uploadingIcon.value = false;
}
}
// "Fetch from Foundry's icons": the module keeps the world's own icon on the
// item, so this just switches back to it.
async function useFoundryIcon() { async function useFoundryIcon() {
if (!canUseFoundryIcon.value || applyingFoundryIcon.value) return; if (!canUseFoundryIcon.value || applyingIcon.value) return;
applyingFoundryIcon.value = true; applyingIcon.value = true;
error.value = ''; error.value = '';
try { try {
const done = await updateItem({ image: form.value.foundryImage }); const done = await updateItem({ image: form.value.foundryImage });
@@ -111,18 +95,21 @@ async function useFoundryIcon() {
} catch (requestError) { } catch (requestError) {
error.value = t('campaigns.item.sheet.save-error'); error.value = t('campaigns.item.sheet.save-error');
} finally { } finally {
applyingFoundryIcon.value = false; applyingIcon.value = false;
} }
} }
async function removeIcon() { async function removeIcon() {
if (!form.value.image) return; if (!form.value.image || applyingIcon.value) return;
applyingIcon.value = true;
error.value = ''; error.value = '';
try { try {
const done = await updateItem({ image: '' }); const done = await updateItem({ image: '' });
if (!done) error.value = t('campaigns.item.sheet.save-error'); if (!done) error.value = t('campaigns.item.sheet.save-error');
} catch (requestError) { } catch (requestError) {
error.value = t('campaigns.item.sheet.save-error'); error.value = t('campaigns.item.sheet.save-error');
} finally {
applyingIcon.value = false;
} }
} }
</script> </script>
@@ -132,10 +119,12 @@ async function removeIcon() {
<WindowHandle :window="id" ref="handle" /> <WindowHandle :window="id" ref="handle" />
<div class="item-body"> <div class="item-body">
<header class="item-hero"> <header class="item-hero">
<div class="item-icon" :class="{ empty: !form.image }"> <button class="item-icon" :class="{ empty: !form.image }" type="button"
:aria-label="$t(form.image ? 'campaigns.item.sheet.change-icon' : 'campaigns.item.sheet.choose-icon')"
@click="chooseIcon">
<img v-if="form.image" :src="imageUrl" :alt="$t('campaigns.item.sheet.icon')"> <img v-if="form.image" :src="imageUrl" :alt="$t('campaigns.item.sheet.icon')">
<span v-else aria-hidden="true">{{ form.name.slice(0, 1).toUpperCase() }}</span> <span v-else aria-hidden="true">{{ form.name.slice(0, 1).toUpperCase() }}</span>
</div> </button>
<div class="item-identity"> <div class="item-identity">
<h1>{{ form.name }}</h1> <h1>{{ form.name }}</h1>
<div class="item-tags"> <div class="item-tags">
@@ -149,23 +138,18 @@ async function removeIcon() {
<div v-if="error" class="item-error">{{ error }}</div> <div v-if="error" class="item-error">{{ error }}</div>
<div class="icon-controls"> <div class="icon-controls">
<button class="sheet-button" type="button" :disabled="uploadingIcon" @click="pickIcon"> <button class="sheet-button" type="button" @click="chooseIcon">
{{ uploadingIcon {{ form.image ? $t('campaigns.item.sheet.change-icon') : $t('campaigns.item.sheet.choose-icon') }}
? $t('campaigns.item.sheet.uploading')
: (form.image ? $t('campaigns.item.sheet.change-icon') : $t('campaigns.item.sheet.choose-icon')) }}
</button> </button>
<button v-if="canUseFoundryIcon" class="sheet-button secondary" type="button" :disabled="applyingFoundryIcon" @click="useFoundryIcon"> <button v-if="canUseFoundryIcon" class="sheet-button secondary" type="button" :disabled="applyingIcon" @click="useFoundryIcon">
{{ $t('campaigns.item.sheet.foundry-icon') }} {{ $t('campaigns.item.sheet.foundry-icon') }}
</button> </button>
<button v-if="form.image" class="sheet-button secondary" type="button" :disabled="uploadingIcon" :aria-label="$t('campaigns.item.sheet.remove-icon')" @click="removeIcon">×</button> <button v-if="form.image" class="sheet-button secondary" type="button" :disabled="applyingIcon" :aria-label="$t('campaigns.item.sheet.remove-icon')" @click="removeIcon">×</button>
<input ref="photoInput" class="photo-input" type="file" accept="image/*" @change="onIconSelected">
</div> </div>
<!-- Quantity is the actor inventory's business (Syndria98/dragonroll#63); the item
sheet only states what the item itself is. -->
<dl class="item-facts"> <dl class="item-facts">
<div class="item-fact">
<dt>{{ $t('campaigns.item.quantity') }}</dt>
<dd>{{ form.quantity }}</dd>
</div>
<div v-if="form.weight !== '' && form.weight !== undefined" class="item-fact"> <div v-if="form.weight !== '' && form.weight !== undefined" class="item-fact">
<dt>{{ $t('campaigns.item.weight') }}</dt> <dt>{{ $t('campaigns.item.weight') }}</dt>
<dd>{{ Number(form.weight).toFixed(1) }} lb</dd> <dd>{{ Number(form.weight).toFixed(1) }} lb</dd>
@@ -189,7 +173,8 @@ async function removeIcon() {
.item-window { min-width: 0; min-height: 0; } .item-window { min-width: 0; min-height: 0; }
.item-body { width: 100%; min-height: 0; flex: 1; overflow: auto; padding: 14px 16px 16px; box-sizing: border-box; } .item-body { width: 100%; min-height: 0; flex: 1; overflow: auto; padding: 14px 16px 16px; box-sizing: border-box; }
.item-hero { display: flex; align-items: center; gap: 13px; padding: 2px 2px 13px; margin-bottom: 11px; border-bottom: 1px solid var(--color-border); } .item-hero { display: flex; align-items: center; gap: 13px; padding: 2px 2px 13px; margin-bottom: 11px; border-bottom: 1px solid var(--color-border); }
.item-icon { width: 64px; height: 64px; flex: 0 0 64px; display: grid; place-items: center; overflow: hidden; border-radius: 10px; border: 1px solid var(--color-border); background: var(--color-background-soft); color: var(--color-link); font: 30px MrEavesRemake; } .item-icon { width: 64px; height: 64px; flex: 0 0 64px; display: grid; place-items: center; overflow: hidden; border-radius: 10px; border: 1px solid var(--color-border); background: var(--color-background-soft); color: var(--color-link); font: 30px MrEavesRemake; padding: 0; cursor: pointer; }
.item-icon:hover { border-color: var(--color-link); }
.item-icon.empty { border-style: dashed; } .item-icon.empty { border-style: dashed; }
.item-icon img { width: 100%; height: 100%; object-fit: contain; } .item-icon img { width: 100%; height: 100%; object-fit: contain; }
.item-identity { min-width: 0; } .item-identity { min-width: 0; }
@@ -202,7 +187,6 @@ async function removeIcon() {
.sheet-button { border: 1px solid var(--color-border); border-radius: 7px; padding: 7px 12px; background: var(--color-background-soft); color: var(--color-text); cursor: pointer; white-space: nowrap; font-size: 13px; } .sheet-button { border: 1px solid var(--color-border); border-radius: 7px; padding: 7px 12px; background: var(--color-background-soft); color: var(--color-text); cursor: pointer; white-space: nowrap; font-size: 13px; }
.sheet-button:hover { background: var(--color-button-hover); } .sheet-button:hover { background: var(--color-button-hover); }
.sheet-button:disabled { opacity: .55; cursor: wait; } .sheet-button:disabled { opacity: .55; cursor: wait; }
.photo-input { display: none; }
.item-facts { display: flex; flex-wrap: wrap; gap: 8px; margin: 0 0 13px; } .item-facts { display: flex; flex-wrap: wrap; gap: 8px; margin: 0 0 13px; }
.item-fact { flex: 1 1 120px; min-width: 0; padding: 9px 11px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); } .item-fact { flex: 1 1 120px; min-width: 0; padding: 9px 11px; border: 1px solid var(--color-border); border-radius: 8px; background: var(--color-background-soft); }
.item-fact dt { font-size: 11px; text-transform: uppercase; letter-spacing: .05em; opacity: .72; } .item-fact dt { font-size: 11px; text-transform: uppercase; letter-spacing: .05em; opacity: .72; }

View File

@@ -76,6 +76,7 @@ onMounted(() => {
<div class="vert bot"> <div class="vert bot">
<div class="button-container"> <div class="button-container">
<button class="btn-primary button-expand sound-click" v-on:click="CreateCampaignWindow" ref="campaignButton">{{ $t("main-menu.create-campaign") }}</button> <button class="btn-primary button-expand sound-click" v-on:click="CreateCampaignWindow" ref="campaignButton">{{ $t("main-menu.create-campaign") }}</button>
<a class="btn-primary button-expand docs-link" href="/docs">{{ $t("main-menu.documentation") }}</a>
</div> </div>
</div> </div>
</div> </div>
@@ -145,6 +146,24 @@ h2, h3 {
flex-direction: column; flex-direction: column;
} }
/* L'enllaç a la documentació és un `<a>` i els botons estan estilats per element, així
que li toca portar el mateix look. */
.docs-link {
display: block;
padding: 14px;
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-link:hover {
background-color: var(--color-button-hover);
}
p { p {
user-select: none; user-select: none;
} }

View File

@@ -0,0 +1,45 @@
# What is Dragonroll?
Dragonroll is a free and open-source helper for tabletop RPG campaigns. It keeps the things a group
carries around a table in one place — the campaign's notes, its characters, its items, its maps — and
lets the tools you already play with read and change them: Discord, Foundry VTT and Obsidian.
It is not a full virtual tabletop. There is no game loop, no combat tracker and no rule engine:
Dragonroll is the shared memory of a campaign, and the place its characters and items are written
down.
## What you get
- **Campaigns.** Every note, character, item and map belongs to one campaign, and each campaign has
its own colour, description and integrations. [Start one](/docs/your-first-campaign).
- **Notes in markdown.** The campaign's text lives in markdown notes, filed into folders that nest as
deep as you need. Notes can hold a [dice widget](/docs/notes-and-markdown) that rolls when you
look at it.
- **Characters and items.** Actors (characters, NPCs and creatures) have a sheet with ability scores,
combat stats, proficiencies, traits, spells and an inventory. Items have a category, a rarity and an
icon. See [characters and items](/docs/characters-and-items).
- **Maps.** Upload a map image with a grid, then pin notes onto the places they belong and stand your
characters on the grid as [tokens](/docs/maps).
- **Integrations.** Consult the campaign from [Discord](/docs/discord), keep a Foundry VTT world and
a campaign [in step](/docs/foundry), and write campaign notes in [Obsidian](/docs/obsidian).
## How it is put together
Three pieces work together, and you only ever see the first of them:
| Piece | What it does |
| --- | --- |
| The web app | What you open: campaigns, notes, characters, items, maps, and the documentation you are reading |
| The API | Stores everything the app shows and answers the integrations' requests |
| The integrations | The Discord bot, the Foundry VTT module and the Obsidian plugin |
You sign in to the app with one account, and everything you create belongs to you. Integrations never
hold a Dragonroll login: they ask you to authorize them for one campaign, which
[you can take back](/docs/connecting-a-service) at any time.
## Where to go next
- New here? [Create your first campaign](/docs/your-first-campaign).
- Writing the campaign down? [Notes and markdown](/docs/notes-and-markdown).
- Playing on a screen? [Maps, pins and tokens](/docs/maps).
- Connecting the tools you use? [Connecting a service](/docs/connecting-a-service).

View File

@@ -0,0 +1,67 @@
# Your first campaign
## Signing in
The very first time you open a Dragonroll server there is no account yet, so the app asks you to
create one: that first account becomes the server's **administrator**, which is the account that can
later create or remove the other accounts. Everyone else is invited to register by whoever runs the
server.
Sign in with your username or your email and your password. Sessions last 48 hours, after which the
app asks you again. Under your name in the main menu you can change your profile — your name, your
email and the avatar that shows up beside your characters.
## The main menu
The main menu is where you pick up where you left off:
- your campaigns, ready to open,
- **Create campaign** to add one,
- **Settings**, with your own appearance and language, and an *Administration* tab for
administrators to manage the other accounts,
- **Log out**.
## Creating a campaign
**Create campaign** asks for three things: a name, a short description and an accent colour. The
colour follows the campaign wherever it shows up, so a group that runs two campaigns can tell them
apart at a glance. Nothing else about a campaign is fixed: you can change the name, description and
colour later in its settings.
## The campaign workspace
Opening a campaign replaces the menu with its workspace.
| Part | What it holds |
| --- | --- |
| Top bar | The campaign's name, the search, **Settings** and **Exit** |
| Sidebar | The campaign's contents, in four sections: **Notes**, **Actors & Characters**, **Items** and **Maps** |
| Note column | The notes you have open, side by side, or the map you have anchored |
| Status bar | What the app is doing: saving, syncing, and errors when something fails |
The sidebar is the heart of it. Each of its sections lists the entries of that kind, and each entry
can stand in a folder: folders nest, so a campaign can be organised however the group thinks of it.
The sidebar itself collapses to give the notes room when you are showing a screen at the table.
## Finding things
The search in the top bar looks through the notes, characters, items and maps of the campaign you are
in, and opens whatever you pick from the results. **Cmd+K** (or **Ctrl+K**) puts the cursor in it.
## Campaign settings
**Settings** in the top bar has two tabs:
- **Basic** — the campaign's name and colour.
- **Integrations** — which external services are connected to this campaign and how to
[connect one](/docs/connecting-a-service), plus the address of the Foundry VTT instance when the
campaign reads icons from a linked world.
**Exit** leaves the campaign and returns to the main menu. Nothing is lost: the notes you had open and
the campaign you were in are remembered for the next time you open the app.
## Next
- Write the campaign down in [notes and markdown](/docs/notes-and-markdown).
- Write its characters and items on [sheets](/docs/characters-and-items).
- Put it on a [map](/docs/maps).

View File

@@ -0,0 +1,89 @@
# Notes and markdown
Notes are where a campaign is written down: sessions, NPCs, the lore of a city, the ritual the party
found in a dungeon. They are plain markdown, so anything you already know from README files and
Obsidian works as it is.
## Opening and editing a note
Clicking a note in the sidebar opens it in the note column, where you can have several open side by
side. A note opens in **display mode**, showing its formatted markdown. Press **Cmd+E** (**Ctrl+E**)
to edit its source, and **Cmd+S** (**Ctrl+S**) to save it; a dot in the note's title bar reminds you
that there is something to save. The cross in the title bar closes the note — it does not delete it.
## Folders
The sidebar's sections hold notes in folders, and folders hold folders, so a campaign can be nested as
deep as it needs. Right-clicking gives the commands:
| Right-click on… | You get |
| --- | --- |
| a note | Open, Rename, a colour, the folder to move it to, Delete |
| a folder | New note in it, Rename, a colour, Delete folder |
Dragging a note onto a folder moves it there, and dropping it at the bottom of the list takes it back
to the root. Colouring a note or a folder tints its row in the sidebar, which is a quick way to mark
what matters.
Deleting a folder does not delete your notes: the notes it held move up to its parent folder, its
sub-folders move up with them, and only the empty folders go away.
## Markdown
Headings, **bold**, *italic*, lists, quotes, tables, code and links all work:
```markdown
## The Wreck of the Salt Gull
- [ ] Burn the manifest
- [x] Ask the harbourmaster
| Cargo | Worth |
| --- | --- |
| Salted fish | 20 gp |
```
Clicking a heading **folds** the section under it — handy when you are reading a long note on a
projector and only want the part you are talking about. Sub-headings fold with their parent.
## Rolling dice in a note
A note can hold a dice widget: a button that rolls and shows the result right there, so the book of a
spell does not need a second app next to it.
Write `@roll` and the expression in square brackets to drop it in the middle of a sentence:
```markdown
The goblin attacks with @roll[1d20+4].
```
Or in a block of its own, between `@roll` and `@end`, when the roll is worth showing on its own line:
```markdown
@roll
8d6
@end
```
Either way the widget shows the expression as a button: press it and the dice land, with every die and
the total spelled out. Press it again to roll again. Only the expression itself goes between `@roll`
and `@end` — write the note about the roll next to the widget, not inside it.
The expression understands:
| Written | Meaning |
| --- | --- |
| `d20`, `1d20` | one die; the number in front is how many, so `4d6` |
| `d20adv`, `d20dis` | roll twice and keep the higher / the lower |
| `4d6kh1`, `4d6kl1` | keep the highest / lowest one of four (any number after `kh` / `kl`) |
| `+`, `-`, `*`, `/` | arithmetic; `2d6+3`, `1d8/2` |
| `( )` | grouping, as in `(1d8+4)*2` |
| `-3` | a negative number |
Division rounds down, the way damage does. Spaces between the parts of an expression do not matter, but
a modifier belongs right after the dice: write `4d6kh1`, not `4d6 kh 1`.
## Next
- Put the people and things of your notes on [sheets](/docs/characters-and-items).
- Pin a note onto a spot on a [map](/docs/maps).

View File

@@ -0,0 +1,50 @@
# Characters and items
The **Actors & Characters** and **Items** sections of the sidebar hold the people and things of a
campaign as entries of their own, with a sheet each. They can be written by hand, and they are also
what a linked [Foundry VTT](/docs/foundry) world keeps itself in step with.
## Actors
An actor is anyone the campaign can point at: a **Character**, an **NPC** or a **Creature**. Creating
one asks for the few fields that identify it — type, species, class, level, background, and a challenge
rating for the monsters — and the rest is filled in on its sheet.
Opening an actor opens its **character sheet**, in tabs:
| Tab | What it holds |
| --- | --- |
| Ability Scores | Strength, Dexterity, Constitution, Intelligence, Wisdom, Charisma, and the proficiency bonus. Under them the six saving throws and the eighteen skills, each with a circle that stands lit when the character is proficient with it, next to the modifier it rolls. The proficiencies follow: the character's tools, its languages, and whatever else it is proficient with as text |
| Inventory | What it carries: every item with its icon, quantity and weight each, the total carried weight added up, and the coins the character holds |
| Traits | Features, traits and other details, as text |
| Spells | The spells it knows, one per line |
Toggling a skill, a saving throw, or writing a tool or a language is done like everything else on the
sheet: **Edit**, change it, **Save sheet**.
Combat lives above the tabs: armor class, speed, initiative, current and maximum hit points, and hit
dice. The photo at the top of the sheet is what shows up next to the character everywhere else —
including in [Discord](/docs/discord), where players can read the sheet of the character they hold.
**Edit** turns the sheet into fields you can change; **Save sheet** writes them back. Characters are
filed in folders like notes are, so a campaign can keep its party, its villains and its bestiary
apart.
## Items
An item is anything the campaign names: a weapon, a potion, a piece of treasure. Its sheet holds a
name, a description, a **category** (weapon, armor, shield, adventuring gear, magic item, consumable,
tool, treasure, other), a **rarity** from common to artifact, a weight in pounds, and its properties
("finesse, versatile").
The rarity colours the item's row in the sidebar — common white, uncommon green, rare blue, very rare
purple, legendary orange — so what is worth something stands out while you scroll.
Every item can have an icon. Upload an image, or pick one out of the icon library your linked Foundry
world ships with, browsing its folders one at a time.
## Characters on the table
Drag an actor out of the sidebar and drop it on a map and it stands there as a
[token](/docs/maps), sized to the map's grid. Drag a note instead and it is filed into whatever folder
you drop it on.

View File

@@ -0,0 +1,51 @@
# Maps, pins and tokens
A map is a picture of a place — a dungeon floor, a town, a combat encounter — with a grid laid over
it. On top of the picture you can pin the notes that belong to a spot and stand the campaign's
characters on its cells.
## Creating a map
**Maps → New map** asks for an image and the grid that goes with it:
| Setting | What it is |
| --- | --- |
| Map image | A photo or scan of the map. Uploading a new one replaces it, and leaving it empty keeps the current image |
| Grid size (px) | How wide one grid cell is in the image, in image pixels |
| Offset X / Offset Y | Where the grid starts in the image, so the grid can be lined up with the drawing |
| Scale | How much distance one cell stands for, like 5 feet |
The grid size, offsets and scale are what let the app turn a point on the screen into a cell of the
map, so a token stands where it should and pins stay put when you zoom.
## Looking at a map
Clicking a map in the sidebar anchors it in the place the open notes occupy, and **Open in window**
puts it in a window of its own, which you can drag next to the notes. Once a map is on screen:
- scroll to zoom towards the cursor, or use the zoom buttons and **Fit to window**,
- drag to pan,
- **Show grid** turns the grid overlay on and off. The grid is drawn over the image, so its lines stay
crisp whatever the zoom.
## Pinning notes
Right-click anywhere on a map and pick **Pin a note here**, then choose the note: a marker appears on
that spot, and clicking the marker opens the note. A pinned note can be read straight off the map
without hunting for it in the sidebar, which is what makes a town map usable at the table.
**Remove pin** takes the marker off; the note itself is untouched. Deleting a note that is pinned drops
its pins.
## Tokens
Drag an actor from the sidebar onto a map and it stands there as a token: it snaps to the centre of the
cell you dropped it on and is sized by that cell, so a huge creature can be given more than one cell by
sizing it up on the map's settings.
Once a token is on the map you can drag it to another cell, step it across the grid one cell at a time
with the **arrow keys**, and take it off with **Delete**. Double-clicking a token opens the sheet of
the actor it stands for, and **Enter** does the same on a token focused with the keyboard.
Tokens belong to the map, not to the actor: the same character can stand on several maps, and taking a
token off does not remove the character from the campaign.

View File

@@ -0,0 +1,51 @@
# Connecting a service
Dragonroll talks to three services: [Discord](/docs/discord), [Foundry VTT](/docs/foundry) and
[Obsidian](/docs/obsidian). They all connect the same way, and none of them is given your Dragonroll
password.
## How a connection works
A service asks Dragonroll for a **sign-up link** and shows it to you. You open that link in your
browser, sign in if you are not signed in already, and pick which of your campaigns the service may
use. Only then does the service get its own credential, which lets it read and change that one
campaign and nothing else.
| You see | What it means |
| --- | --- |
| A link in Discord, in the Foundry module or in the Obsidian plugin | The service is waiting for you to pick a campaign |
| A campaign picker in your browser | Sign in and choose the campaign, and the service is connected |
| "Connected" in the service | It picked up its credential and can start working |
The link is short-lived — it expires after ten minutes — and can only be used once. If you close it
without choosing, ask the service for a new one. If a service loses the credential it was given, it
asks for a new link too: nothing is kept that would let it back in.
## What a connection allows
What a service may do is decided by the campaign you pick, so check the name before you confirm. The
screen tells you which service is asking, and what it wants:
- a **Discord server** reads the campaign's characters, so whoever is in that server can read them,
- a **Foundry world** keeps its actors and items in step with the campaign, which means it writes into
it, and Dragonroll writes into it,
- **Obsidian** reads the campaign's notes and pushes the ones you tell it to.
A campaign holds one link per service: linking a second Foundry world, or a second Discord server,
replaces the one it had. Authorizing a service with a different Dragonroll account replaces who the
service answers to.
## Seeing and undoing a connection
Open the campaign and look at **Settings → Integrations**. It lists the three services and, for each
one, whether it is connected, what is connected to it, and which Dragonroll account authorized it.
**Unlink** ends it. The service loses access the next time it asks — nothing it already wrote into the
campaign is deleted, and nothing about your campaign changes. To use the service again, start a new
link from its own side.
## Next
- [Discord](/docs/discord) — read characters and campaigns from a server.
- [Foundry VTT](/docs/foundry) — keep a world and a campaign in step.
- [Obsidian](/docs/obsidian) — write campaign notes in your vault.

View File

@@ -0,0 +1,62 @@
# Discord
The Dragonroll Discord bot lets a server read the characters of a campaign without anyone leaving
Discord: the roster, a character's sheet with its portrait, and who plays whom. It is a read-only bot —
it never changes your campaign.
## Connecting a server
1. Invite the bot to the server with the `bot` and `applications.commands` scopes.
2. A Discord **administrator** runs `/dragonroll connect`. The bot answers with a *Sign in to
Dragonroll* button.
3. Whoever opens it signs in to the Dragonroll account that owns the campaign and picks that campaign.
The server is now linked to it, and the bot says so.
4. From then on anybody in the server can look the campaign's characters up.
The authorization link lasts ten minutes and works once. A campaign is linked to one Discord server at
a time, and a server to one campaign; authorizing the server with a different Dragonroll account takes
over the connection.
## Commands
| Command | Who | What it does |
| --- | --- | --- |
| `/characters [type]` | everybody | Lists the characters of the campaign this server is linked to. `type` narrows the list to **Characters**, **NPCs** or **Creatures**. Every character a player has claimed shows up next to that player. |
| `/character name [public]` | everybody | Shows one actor's sheet: its portrait, description, race, class and level, background, armor class and speed, ability scores, proficiencies, traits, spells and inventory. Start typing a name and Discord offers the campaign's roster. Set `public` to `true` to show the sheet to the whole channel instead of only to you. |
| `/dragonroll connect` | administrators | Asks Dragonroll for the sign-up link that connects this server, and confirms here once somebody has authorized it. |
| `/dragonroll link campaign:` | administrators | Moves this server to another campaign of the connected Dragonroll account. Type part of a name to filter the choices. |
| `/dragonroll unlink` | administrators | Removes this server's campaign link. The campaign is untouched; the commands simply have nothing to read until one is linked again. |
| `/dragonroll status` | everybody | Shows which campaign this server reads, and which character your Discord account holds on it. |
| `/dragonroll refresh` | everybody | Asks Dragonroll again where the connection stands, and shows what it answered. |
| `/dragonroll assign character:` | everybody | Links a character of the campaign to your Discord account, so the bot knows it is yours and `/characters` says so. You can take a character nobody holds; a character somebody else holds can only be moved by an administrator. |
| `/dragonroll unassign [character]` | everybody | Drops a character link. Without the option you give up your own character; naming somebody else's takes it off them, which only an administrator can do. |
Replies are private: only you see them, so a player can look up their character in a busy channel. The
one exception is `/character` with `public:true`, which posts the sheet where everyone can read it — for
the villain the party is talking to, or the magic item they just found.
## Characters and their players
`/dragonroll assign` is how a player says *this one is mine*:
- each account holds one character, so claiming a second one frees the first,
- a free character can be taken by anybody,
- a character somebody holds can only be taken or freed by a server administrator,
- the pairing shows up in `/characters` and in `/dragonroll status`, which is what lets the table see
who is playing whom.
Assigning a character does not hide anything: the bot is read-only and every member of the server can
already read the campaign's characters with `/character`.
## When something goes wrong
| The bot says | What is going on |
| --- | --- |
| "Connect a Dragonroll account first with /dragonroll connect." | Nobody has authorized this server yet, or the authorization expired before anyone opened it. |
| "Only Discord server administrators can connect Dragonroll or change this campaign link." | The command changes the server's connection, so it needs the Discord Administrator permission. |
| "The bot API secret is missing or does not match the backend." | Whoever runs the bot has to set the same `DRAGONROLL_DISCORD_BOT_SECRET` in the bot and in the Dragonroll backend. |
| "This server does not have a linked campaign." | The link was removed; an administrator has to pick a campaign with `/dragonroll link`. |
Character portraits are read from Dragonroll's public upload folder, so the bot needs to be able to
reach the server Dragonroll runs on. Whoever hosts the bot finds its setup in `discord-bot/README.md`
in the source repository.

View File

@@ -0,0 +1,114 @@
# Foundry VTT
The Foundry integration keeps a Dragonroll campaign and a Foundry world in step: the world's
characters and item directory arrive in the campaign, and what you change in Dragonroll goes back to
the world.
There are two separate parts, and you only need the first of them:
| Part | What it is |
| --- | --- |
| The **Dragonroll Foundry API** module | Installed in the world. Links it to a campaign and keeps its actors and items synced. Runs in the game client. |
| The optional **snapshot bridge** | A small process on the Foundry host that publishes a read-only snapshot of the world for Dragonroll to browse. Only for reading world data over the API. |
Character and item sync works without the bridge.
## Installing the module
Foundry VTT v12 to v14. Copy the `dragonroll-foundry` folder into
`{Foundry user data}/Data/modules/dragonroll-foundry/`, restart Foundry, and enable **Dragonroll
Foundry API** in the world's module settings.
The module's own settings hold two things you set: the **Dragonroll Endpoint** — the address of your
Dragonroll server, `https://dragonroll.aranroig.com` by default — and **Dragonroll Auto-sync**, which
is on.
## Linking a world
Open the world with a GM account. The module asks Dragonroll for a sign-up link and prints it in a
notification: open it, sign in, and pick the campaign this world belongs to. **Dragonroll Pairing
Status** in the module settings always says where things stand — waiting for a link, connected to a
named campaign, or why a link could not be used.
Worth knowing:
- The link expires after ten minutes and works once. If it goes unused, reload the world to get a new
one.
- A world links to one campaign, and a campaign to one Foundry world: linking a second world replaces
the first.
- The link, the sync token it hands back and the pairing status are all **client** settings: the
browser that completed the link is the one that syncs. Another browser on the same world reads as not
paired until it links too.
- **Dragonroll Pairing Status** is written by the module. It is not a field to fill in.
- The campaign shows the linked world's title and system under **Settings → Integrations**, where
**Unlink** ends the pairing.
## What syncs
| In Foundry | In the campaign |
| --- | --- |
| Character, NPC and creature actors | Actors with the same sheet: abilities, saving throws, skills, combat stats, proficiencies, tools, languages, traits, spells, carried gear with its icons, coins, portrait |
| The world's **item directory** (the items tab) | The campaign's item list, with category, rarity, quantity, weight, properties and description |
| The folders grouping that item directory | Item folders with the same names and nesting |
| A folder's colour | The campaign's folder colour — and the other way round, what you colour in Dragonroll lands on the world's folder |
The item list is the world's item directory and nothing else. The gear a character carries is that
character's inventory: it travels with the character and stays on its sheet, so a sword a fighter owns
does not turn up in the campaign's item list. Spells, classes, subclasses, backgrounds, feats and
species are not gear and are not imported.
An actor or item keeps the Dragonroll id it was given in a `dragonroll-foundry.actorId` /
`dragonroll-foundry.itemId` flag, and that is what makes the two sides recognise each other. A world
item that carries no flag is matched by name, so a hand-written item in Dragonroll is adopted instead of
doubled, and renaming it in either place does not resurrect a duplicate.
Changes flow both ways as they happen, and Dragonroll's own edits are applied back in Foundry within a
few seconds. A **full** snapshot — the one taken when the world links, or forced from the actor
directory — is the only thing that prunes: it is the only moment either side can see the whole list and
notice what is gone. Live edits never delete anything.
## Auto-sync, and sending one actor on purpose
**Dragonroll Auto-sync** is what keeps the two in step: actors and world items you create, change or
delete are sent to the campaign, and both sides reconcile every few seconds. Turning it off stops all
of it — nothing is sent, and Dragonroll stops rewriting your Foundry documents, so the campaign keeps
whatever it already holds. Turn it back on and both sides reconcile again, including the edits queued
while it was off.
To send one character across right now, or to cross over while autosync is off, right-click the actor
(or several) in the Foundry actor directory and pick **Dragonroll: Force Sync**. Those actors, with the
gear inside them, are pushed immediately. It only upserts: it never prunes the campaign's other actors.
Actors Dragonroll does not import — anything that is not a character, NPC or creature — are refused with
a notification saying so.
## Foundry's icons in Dragonroll
With a world linked, Dragonroll's item icon browser can page through the icon library that world ships
with, one folder at a time. If it says the world has no address, set it under **Settings → Integrations
→ Foundry VTT URL** in the campaign.
## The optional snapshot bridge
The bridge is a small Node.js (18 or newer) process that runs beside Foundry. A GM client publishes the
world's actor and item snapshot to it, and Dragonroll reads that snapshot back through its own API, so
a server can ask what a world holds without touching the game. It is read-only, it keeps nothing across
restarts, and character sync does not depend on it.
It needs its own tokens — separate ones for publishing and for reading — and an origin allow-list for
the Foundry client:
| Variable | What it is |
| --- | --- |
| `DRAGONROLL_FOUNDRY_PUSH_TOKEN` | The token the Foundry client publishes with; the backend's `FOUNDRY_API_PUSH_TOKEN` must match it |
| `DRAGONROLL_FOUNDRY_READ_TOKEN` | The token reads with; the backend's `FOUNDRY_API_TOKEN` must match it |
| `DRAGONROLL_FOUNDRY_ALLOWED_ORIGINS` | The browser origins allowed to publish, comma separated |
| `DRAGONROLL_FOUNDRY_HOST` / `DRAGONROLL_FOUNDRY_PORT` | Where the bridge listens; `0.0.0.0:8787` by default |
| `DRAGONROLL_FOUNDRY_DATA_PATH` | The Foundry Data directory, which lets the bridge list the core `icons/` library |
The backend points at it with `FOUNDRY_API_URL` (and `FOUNDRY_API_CLIENT_URL` when the Foundry clients
reach it under a different address than the backend does). Once it is set up, Dragonroll answers
`GET /api/foundry/world`, `/actors`, `/characters`, `/items`, one of each by id, an actor's embedded
items, and `/icons` — all for a signed-in Dragonroll user, and all read-only.
`dragonroll-foundry/README.md` in the source repository documents the bridge, its routes and its
heartbeat in full.

View File

@@ -0,0 +1,77 @@
# Obsidian
The **Dragonroll Sync** plugin moves campaign notes between a Dragonroll campaign and an Obsidian
vault: import the campaign so you can read and write it with your own notes, and push the note you are
working on back to the campaign.
It is an explicit, you-ask-for-it workflow. Nothing happens in the background, and the plugin never
deletes a note.
## Installing
Copy `main.js` and `manifest.json` into your vault:
```text
<vault>/.obsidian/plugins/dragonroll-sync/
```
Then enable **Dragonroll Sync** under Settings → Community plugins. It is plain JavaScript, so there is
nothing to build, and it runs on desktop and mobile alike.
## Connecting
Under **Settings → Community plugins → Dragonroll Sync**:
1. Set the **Dragonroll API URL** — `https://dragonroll.aranroig.com/api` by default, or your own
server, such as `http://localhost:5000/api`.
2. **Sign in** with your Dragonroll username or email and your password. The password is used once to
sign in and is not saved; what the plugin keeps is the session token, in this vault, and it expires
after 48 hours like any other Dragonroll session.
3. Pick the **campaign**. Every import and push works against that campaign.
## Commands
Both are in Obsidian's command palette:
| Command | What it does |
| --- | --- |
| **Import or refresh campaign notes** | Brings every note of the campaign into `Dragonroll/<Campaign>/`, folders and nesting included, and updates the ones already there. Imported notes keep their place in the campaign's folder tree. |
| **Push active note to Dragonroll** | Sends the note you are in to the campaign: a new root note if it is not linked yet, or an update of the note it is linked to. |
## How a note knows where it belongs
An imported note carries three properties in its frontmatter:
```yaml
---
dragonrollId: 665f1c…
dragonrollCampaign: 665f0a…
dragonrollTitle: The Salt Gull
---
```
They are what ties the file to its note in the campaign: they survive renames, and they are stripped
from the markdown the plugin sends back, so they never show up in Dragonroll. Pushing a brand new local
note adds them too, which is how the next push updates the same note instead of creating a copy.
Renaming the note's title in Dragonroll renames the imported file on the next import; renaming the file
in Obsidian renames the note in Dragonroll on the next push.
## Your edits are not overwritten
The plugin remembers how a note looked the last time it was imported or pushed, and uses that as the
baseline:
| Since the last sync | What the import does |
| --- | --- |
| Only the campaign's copy changed | The local file is updated |
| Only your local file changed | Your file is kept as it is, and reported for you to look at |
| Both changed | Your file is kept as it is, and reported for you to look at |
| Neither changed | Nothing is touched |
So a note you were rewriting in Obsidian is never quietly replaced: the plugin leaves it alone and tells
you it is waiting. Pushing is the deliberate direction — it writes the active note's current title and
content into Dragonroll.
A note that is linked to a different campaign cannot be pushed while another campaign is selected:
switch the campaign in the plugin settings first.

View File

@@ -0,0 +1,9 @@
<script setup>
// L'aplicació de finestres no té rutes pròpies: qualsevol adreça que no sigui la
// documentació l'obre, i /link/authorize se n'encarrega dins d'AppShell.
import AppShell from '~/components/views/AppShell.vue';
</script>
<template>
<AppShell></AppShell>
</template>

View File

@@ -0,0 +1,8 @@
<script setup>
// `/docs/<slug>`, amb el slug del fitxer de markdown (mira ~/services/Docs.js).
import DocsView from '~/components/views/DocsView.vue';
</script>
<template>
<DocsView></DocsView>
</template>

View File

@@ -0,0 +1,7 @@
<script setup>
import DocsView from '~/components/views/DocsView.vue';
</script>
<template>
<DocsView></DocsView>
</template>

View File

@@ -0,0 +1,7 @@
<script setup>
import AppShell from '~/components/views/AppShell.vue';
</script>
<template>
<AppShell></AppShell>
</template>

View File

@@ -0,0 +1,114 @@
import { Marked } from "marked";
import { CreateHeadingSlugger, HeadingsFromMarkdown, TitleFromMarkdown } from "./DocsMarkdown";
/*
The documentation served at /docs is markdown files under app/content/docs, so writing a page means
adding a file. The layout of a page's path says everything the sidebar needs:
app/content/docs/<group>/<NN>-<page>.md
The folder is the sidebar group and its own number orders the groups, the number in front of the file
orders the pages inside its group, and the rest of the file name is the page's slug (`02-discord.md`
is `/docs/discord`). A page's title is its first heading, and the first page of the first group is
served at `/docs` itself.
A group's label is looked up under `docs.groups.<folder>` in the locale files of
`i18n/locales/en/docs.json` and its siblings, so a new group needs that label in every locale.
*/
const markdownFiles = import.meta.glob("../content/docs/*/*.md", { query: "?raw", eager: true, import: "default" });
const Numbered = /^(\d+)-/;
const WithoutNumber = (name) => name.replace(Numbered, "");
// A name without a number in front sorts after every numbered one in its folder.
const OrderOf = (name) => {
const numbered = Numbered.exec(name);
return numbered ? Number(numbered[1]) : Number.MAX_SAFE_INTEGER;
};
const pages = Object.entries(markdownFiles)
.map(([file, source]) => {
const [folder, filename] = file.split("/").slice(-2);
const markdown = String(source ?? "");
return {
group: WithoutNumber(folder),
groupOrder: OrderOf(folder),
slug: WithoutNumber(filename).replace(/\.md$/, ""),
order: OrderOf(filename),
title: TitleFromMarkdown(markdown),
headings: HeadingsFromMarkdown(markdown),
markdown,
};
})
.sort((left, right) =>
left.groupOrder - right.groupOrder || left.order - right.order || left.slug.localeCompare(right.slug)
);
// `/docs` is the first page of the documentation, the rest hang under it by their slug.
function GetDocsHref(slug) {
return pages.length && slug === pages[0].slug ? "/docs" : `/docs/${slug}`;
}
function GetDocsFirstSlug() {
return pages.length ? pages[0].slug : "";
}
// The sidebar: one entry per group folder, in reading order, holding its pages.
function GetDocsNav() {
const nav = [];
for (const page of pages) {
let group = nav.find((entry) => entry.key === page.group);
if (!group) {
group = { key: page.group, pages: [] };
nav.push(group);
}
group.pages.push({ slug: page.slug, title: page.title, href: GetDocsHref(page.slug) });
}
return nav;
}
const marked = new Marked();
// Every heading gets the anchor the sidebar and the "on this page" list link to. The slugger is
// replaced at the start of a parse so each page numbers its repeated headings on its own: marked
// parses one document at a time and does it synchronously, so no other parse can cut in.
let slugHeadings = CreateHeadingSlugger();
marked.use({
renderer: {
heading({ tokens, depth }) {
const content = this.parser.parseInline(tokens);
return `<h${depth} id="${slugHeadings(content)}">${content}</h${depth}>`;
},
},
});
function RenderDocsMarkdown(markdown) {
slugHeadings = CreateHeadingSlugger();
return String(marked.parse(markdown || ""));
}
// What the /docs page shows: a rendered page with the headings it holds and whichever pages come
// before and after it, or null when nothing is published under that slug.
function GetDocsPage(slug) {
const index = pages.findIndex((page) => page.slug === slug);
if (index === -1) return null;
const page = pages[index];
const neighbours = (page) => (page ? { slug: page.slug, title: page.title, href: GetDocsHref(page.slug) } : null);
return {
slug: page.slug,
group: page.group,
title: page.title,
// The page's own h1 is in the body already; the list is for its sections.
headings: page.headings.filter((heading) => heading.depth > 1 && heading.depth <= 3),
html: RenderDocsMarkdown(page.markdown),
previous: neighbours(pages[index - 1]),
next: neighbours(pages[index + 1]),
};
}
export { GetDocsFirstSlug, GetDocsHref, GetDocsNav, GetDocsPage, RenderDocsMarkdown };

View File

@@ -0,0 +1,90 @@
/*
String helpers for the documentation under /docs: the words a heading shows, the anchor it gets, and
the headings the sidebar lists. They import nothing at all, not even marked, because the repository
root installs no dependencies and `tests/docs.test.js` loads this file straight from source.
*/
// What marked escapes, back to the character it stands for: an anchor has to be the same whether it
// was written as `'` or arrived as `&#39;`.
const Entities = {
amp: "&",
lt: "<",
gt: ">",
quot: '"',
apos: "'",
nbsp: " ",
"#39": "'",
"#x27": "'",
};
function DecodeEntities(value) {
return value.replace(/&(#?[a-z0-9]+);/gi, (entity, body) => (Entities[body.toLowerCase()] ?? ""));
}
// A heading's anchor is built from its markdown source when the sidebar is built, and from the HTML
// marked has rendered when the page is. This drops everything the two forms disagree on — the tags
// marked adds, the entities it escapes, and the characters markdown uses for emphasis and links — so
// both keep the same words and land on the same anchor.
function HeadingText(value) {
return DecodeEntities(
String(value ?? "")
.replace(/<[^>]*>/g, "") // <code>, <em>, <a> … around the heading's words
.replace(/!?\[([^\]]*)\]\([^)]*\)/g, "$1") // a link keeps the label it shows, not its target
.replace(/[*_`~]/g, "") // emphasis
).trim();
}
// Lower case letters, numbers and dashes: what a url fragment and a query selector both accept.
function Slugify(value) {
return HeadingText(value)
.toLowerCase()
.replace(/[^a-z0-9]+/g, "-")
.replace(/^-+|-+$/g, "");
}
// Two headings with the same words cannot share an anchor: the second becomes `words-1`, the third
// `words-2`. The sidebar and the renderer both walk a page's headings in document order, so the
// numbers they hand out are the same.
function CreateHeadingSlugger() {
const seen = new Map();
return (value) => {
const base = Slugify(value) || "section";
const times = seen.get(base) || 0;
seen.set(base, times + 1);
return times === 0 ? base : `${base}-${times}`;
};
}
// The headings of a markdown document, in order, each with the anchor its renderer will give it:
// `{ depth: 2, text: "Link a world", slug: "link-a-world" }`. Lines inside a fenced code block are
// skipped — a `# comment` there is shell, not a heading.
function HeadingsFromMarkdown(source) {
const slug = CreateHeadingSlugger();
const headings = [];
let inFence = false;
for (const line of String(source ?? "").split(/\r?\n/)) {
if (/^ {0,3}(```|~~~)/.test(line)) {
inFence = !inFence;
continue;
}
if (inFence) continue;
const heading = /^ {0,3}(#{1,6})\s+(.*?)\s*#*\s*$/.exec(line);
if (!heading) continue;
const text = HeadingText(heading[2]);
headings.push({ depth: heading[1].length, text, slug: slug(text) });
}
return headings;
}
// A documentation page's title is its first heading.
function TitleFromMarkdown(source) {
const [first] = HeadingsFromMarkdown(source);
return first ? first.text : "";
}
export { CreateHeadingSlugger, HeadingsFromMarkdown, HeadingText, Slugify, TitleFromMarkdown };

View File

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

View File

@@ -88,6 +88,21 @@ const defWindows = {
close: () => ClearWindow({type: 'item_sheet'}), close: () => ClearWindow({type: 'item_sheet'}),
movable: true movable: true
}, },
item_icon_source: {
title: 'windows.icon-source',
component: () => import('~/components/windows/ItemIconSourceWindow.vue'),
close: () => ClearWindow({ type: 'item_icon_source' }),
movable: true
},
foundry_icons: {
title: 'windows.foundry-icons',
component: () => import('~/components/windows/FoundryIconPickerWindow.vue'),
// Back closes the icon browser and leaves the chooser it was opened from,
// which is still open behind it.
back: () => ClearWindow({ type: 'foundry_icons' }),
close: () => ClearWindow({ type: 'foundry_icons' }),
movable: true
},
create_map: { create_map: {
title: 'windows.create-map', title: 'windows.create-map',
component: () => import('~/components/windows/CreateMapWindow.vue'), component: () => import('~/components/windows/CreateMapWindow.vue'),
@@ -105,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

@@ -49,6 +49,11 @@
"rename": "Canvia el nom", "color": "Color", "default": "Per defecte", "delete": "Suprimeix la carpeta", "rename": "Canvia el nom", "color": "Color", "default": "Per defecte", "delete": "Suprimeix la carpeta",
"move-to": "Mou a carpeta...", "root": "Arrel" "move-to": "Mou a carpeta...", "root": "Arrel"
}, },
"foundry-import": {
"run": "Força la importació des del Foundry",
"done": "Importat del Foundry: {imported} nous, {updated} actualitzats.",
"error": "No s'ha pogut importar des del món del Foundry vinculat."
},
"states": { "states": {
"loading": "Carregant...", "loading-notes": "Carregant notes...", "empty-notes": "Encara no hi ha notes en aquesta campanya.", "loading": "Carregant...", "loading-notes": "Carregant notes...", "empty-notes": "Encara no hi ha notes en aquesta campanya.",
"empty-actors": "Encara no hi ha actors ni personatges.", "empty-items": "Encara no hi ha objectes en aquesta campanya.", "empty-actors": "Encara no hi ha actors ni personatges.", "empty-items": "Encara no hi ha objectes en aquesta campanya.",
@@ -65,14 +70,19 @@
}, },
"item": { "item": {
"new": "Objecte nou", "edit": "Edita l'objecte", "foundry-sync-note": "Els canvis en aquest objecte també s'apliquen al món del Foundry vinculat.", "new": "Objecte nou", "edit": "Edita l'objecte", "foundry-sync-note": "Els canvis en aquest objecte també s'apliquen al món del Foundry vinculat.",
"category": "Categoria", "rarity": "Raresa", "quantity": "Quantitat", "category": "Categoria", "rarity": "Raresa",
"quantity-short": "Quant.", "weight": "Pes (lb)", "properties": "Propietats", "properties-placeholder": "Per exemple, versàtil, subtil", "weight": "Pes (lb)", "properties": "Propietats", "properties-placeholder": "Per exemple, versàtil, subtil",
"sheet": { "sheet": {
"icon": "Icona de l'objecte", "choose-icon": "Tria la teva pròpia icona", "change-icon": "Canvia la icona", "icon": "Icona de l'objecte", "choose-icon": "Tria la teva pròpia icona", "change-icon": "Canvia la icona",
"uploading": "Pujant...", "upload-error": "No s'ha pogut pujar aquesta icona.", "uploading": "Pujant...", "upload-error": "No s'ha pogut pujar aquesta icona.",
"foundry-icon": "Fes servir la icona del Foundry", "remove-icon": "Treu la icona", "save-error": "No s'ha pogut desar aquest objecte.", "foundry-icon": "Fes servir la icona del Foundry", "remove-icon": "Treu la icona", "save-error": "No s'ha pogut desar aquest objecte.",
"no-description": "Sense descripció afegida." "no-description": "Sense descripció afegida."
}, },
"icon-picker": {
"intro": "D'on ha de sortir la icona d'aquest objecte?",
"upload": "Pujar una icona", "upload-hint": "Tria una imatge d'aquest dispositiu.",
"foundry": "Carregar del Foundry", "foundry-hint": "Recorre les icones que inclou el teu món del Foundry."
},
"categories": { "categories": {
"weapon": "Arma", "armor": "Armadura", "shield": "Escut", "adventuring-gear": "Equip d'aventura", "weapon": "Arma", "armor": "Armadura", "shield": "Escut", "adventuring-gear": "Equip d'aventura",
"magic-item": "Objecte màgic", "consumable": "Consumible", "tool": "Eina", "treasure": "Tresor", "other": "Altre" "magic-item": "Objecte màgic", "consumable": "Consumible", "tool": "Eina", "treasure": "Tresor", "other": "Altre"
@@ -101,6 +111,16 @@
"drop-hint": "Deixa anar per posar l'actor en aquest mapa", "drop-hint": "Deixa anar per posar l'actor en aquest mapa",
"open": "Obre la fitxa de personatge", "remove": "Treu la fitxa", "open": "Obre la fitxa de personatge", "remove": "Treu la fitxa",
"error": "No s'han pogut canviar les fitxes d'aquest mapa." "error": "No s'han pogut canviar les fitxes d'aquest mapa."
},
"walls": {
"edit": "Edita murs",
"hint": "Arrossega sobre el mapa per dibuixar un mur · arrossega'n els extrems per canviar-lo, el cos per moure'l",
"wall": "Mur",
"sight-block": "Bloqueja la vista", "sight-open": "Permet la vista",
"move-block": "Bloqueja el moviment", "move-open": "Permet el moviment",
"door": "Porta", "door-none": "No és porta", "door-closed": "Porta tancada", "door-open": "Porta oberta",
"remove": "Treu el mur",
"error": "No s'han pogut guardar els murs d'aquest mapa."
} }
}, },
"character-sheet": { "character-sheet": {
@@ -108,11 +128,24 @@
"tabs": { "abilities": "Característiques", "inventory": "Inventari", "traits": "Trets", "spells": "Conjurs" }, "tabs": { "abilities": "Característiques", "inventory": "Inventari", "traits": "Trets", "spells": "Conjurs" },
"level": "Nivell", "species": "Espècie", "unset-species": "Espècie sense definir", "edit": "Edita la fitxa", "cancel": "Cancel·la", "level": "Nivell", "species": "Espècie", "unset-species": "Espècie sense definir", "edit": "Edita la fitxa", "cancel": "Cancel·la",
"saving": "Desant...", "save": "Desa la fitxa", "save-error": "No s'ha pogut desar aquesta fitxa de personatge.", "photo": "Foto", "upload-photo": "Pujar foto", "change-photo": "Canviar foto", "remove-photo": "Treure foto", "uploading-photo": "Pujant...", "photo-error": "No s'ha pogut pujar aquesta foto.", "ability-scores": "Característiques", "proficiency-bonus": "Bonificador de competència", "saving": "Desant...", "save": "Desa la fitxa", "save-error": "No s'ha pogut desar aquesta fitxa de personatge.", "photo": "Foto", "upload-photo": "Pujar foto", "change-photo": "Canviar foto", "remove-photo": "Treure foto", "uploading-photo": "Pujant...", "photo-error": "No s'ha pogut pujar aquesta foto.", "ability-scores": "Característiques", "proficiency-bonus": "Bonificador de competència",
"combat": "Combat", "armor-class": "Classe d'armadura", "speed": "Velocitat", "proficiencies": "Competències", "combat": "Combat", "armor-class": "Classe d'armadura", "speed": "Velocitat", "initiative": "Iniciativa",
"proficiencies-placeholder": "Afegeix salvacions, habilitats, armadures, armes, eines i idiomes...", "empty-proficiencies": "No hi ha competències afegides.", "hit-points": "Punts de cop", "max-hit-points": "Punts de cop màxims", "hit-dice": "Daus de cop", "max-hit-dice": "Daus de cop màxims", "proficiencies": "Competències",
"proficiencies-placeholder": "Afegeix armadures, armes i qualsevol altra competència del personatge...", "empty-proficiencies": "No hi ha competències afegides.",
"saving-throws": "Tirades de salvació", "skills": "Habilitats",
"abilities": { "str": "Força", "dex": "Destresa", "con": "Constitució", "int": "Intel·ligència", "wis": "Saviesa", "cha": "Carisma" },
"skill-names": {
"acrobatics": "Acrobàcies", "animalHandling": "Tracte amb els animals", "arcana": "Arcan", "athletics": "Atletisme",
"deception": "Engany", "history": "Història", "insight": "Penetració", "intimidation": "Intimidació",
"investigation": "Investigació", "medicine": "Medicina", "nature": "Naturalesa", "perception": "Percepció",
"performance": "Actuació", "persuasion": "Persuasió", "religion": "Religió", "sleightOfHand": "Jocs de mans",
"stealth": "Furtivitat", "survival": "Supervivència"
},
"tools": "Eines", "tools-placeholder": "Escriu les eines, una per línia...", "empty-tools": "Cap competència amb eines.",
"languages": "Idiomes", "languages-placeholder": "Escriu els idiomes, un per línia...", "empty-languages": "Cap idioma.",
"traits": "Trets", "traits-placeholder": "Afegeix trets, capacitats i altres detalls...", "empty-traits": "No hi ha trets afegits.", "traits": "Trets", "traits-placeholder": "Afegeix trets, capacitats i altres detalls...", "empty-traits": "No hi ha trets afegits.",
"spells": "Conjurs", "spells-placeholder": "Escriu els conjurs, un per línia...", "empty-spells": "No hi ha conjurs afegits.", "spells": "Conjurs", "spells-placeholder": "Escriu els conjurs, un per línia...", "empty-spells": "No hi ha conjurs afegits.",
"inventory": "Inventari", "add-item": "Afegeix un objecte", "carried-weight": "Pes transportat", "item-name": "Objecte", "inventory": "Inventari", "add-item": "Afegeix un objecte", "carried-weight": "Pes transportat", "item-name": "Objecte",
"quantity": "Quant.", "weight-each": "Unitat (lb)", "total-weight": "Total (lb)", "actions": "Accions", "empty-inventory": "L'inventari és buit." "quantity": "Quant.", "weight-each": "Unitat (lb)", "total-weight": "Total (lb)", "actions": "Accions", "empty-inventory": "L'inventari és buit.",
"currency": "Monedes", "currency-units": { "pp": "PP", "gp": "GP", "ep": "EP", "sp": "SP", "cp": "CP" }, "item-icon": "Icona"
} }
} }

View File

@@ -0,0 +1,15 @@
{
"title": "Documentació",
"contents": "Contingut",
"on-this-page": "En aquesta pàgina",
"open-app": "Obrir Dragonroll",
"previous": "Anterior",
"next": "Següent",
"not-found": "No hi ha cap pàgina de la documentació que es digui «{page}».",
"back-to-docs": "Tornar a la documentació",
"groups": {
"getting-started": "Primers passos",
"using-dragonroll": "Fer servir Dragonroll",
"integrations": "Integracions"
}
}

View File

@@ -3,6 +3,19 @@
"link-expired": "El codi d'enllaç de Foundry no és vàlid, ha caducat o ja s'ha utilitzat.", "link-expired": "El codi d'enllaç de Foundry no és vàlid, ha caducat o ja s'ha utilitzat.",
"world-already-linked": "Aquest món de Foundry ja està enllaçat amb una altra campanya.", "world-already-linked": "Aquest món de Foundry ja està enllaçat amb una altra campanya.",
"actor-already-synced": "Un altre actor d'aquesta campanya ja està sincronitzat amb aquell actor del Foundry.", "actor-already-synced": "Un altre actor d'aquesta campanya ja està sincronitzat amb aquell actor del Foundry.",
"item-already-synced": "Un altre objecte d'aquesta campanya ja està sincronitzat amb aquell objecte del Foundry." "item-already-synced": "Un altre objecte d'aquesta campanya ja està sincronitzat amb aquell objecte del Foundry.",
"scene-already-synced": "Un altre mapa d'aquesta campanya ja està sincronitzat amb aquella escena del Foundry.",
"icons-unavailable": "Les icones del Foundry no són disponibles: el seu bridge no està configurat o ara mateix no hi arriba.",
"icons-no-world-url": "Aquesta campanya no té adreça del món del Foundry. Definiu-la als ajustos de la campanya, a la pestanya d'integracions.",
"import-not-linked": "Aquesta campanya no té cap món del Foundry vinculat. Connecteu-ne un als ajustos de la campanya, a la pestanya d'integracions.",
"import-unavailable": "Les dades del Foundry no són disponibles: el seu bridge no està configurat, ara mateix no hi arriba o el seu món encara no ha publicat res.",
"import-world-mismatch": "El bridge del Foundry està mostrant un món diferent del que aquesta campanya té vinculat."
},
"icons": {
"path": "Carpeta d'icones",
"up": "Una carpeta amunt",
"loading": "Carregant icones...",
"empty": "No hi ha icones per triar en aquesta carpeta.",
"load-more": "Carregar més icones"
} }
} }

View File

@@ -2,6 +2,7 @@
"main-menu": "Menú principal", "main-menu": "Menú principal",
"edit-profile": "Editar perfil", "edit-profile": "Editar perfil",
"create-campaign": "Crear campanya", "create-campaign": "Crear campanya",
"documentation": "Documentació",
"log-out": "Tanca la sessió", "log-out": "Tanca la sessió",
"settings": "Configuració", "settings": "Configuració",
"exit": "Sortir" "exit": "Sortir"

View File

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

View File

@@ -53,6 +53,11 @@
"rename": "Rename", "color": "Color", "default": "Default", "delete": "Delete folder", "rename": "Rename", "color": "Color", "default": "Default", "delete": "Delete folder",
"move-to": "Move to folder...", "root": "Root" "move-to": "Move to folder...", "root": "Root"
}, },
"foundry-import": {
"run": "Force import from Foundry",
"done": "Imported from Foundry: {imported} new, {updated} updated.",
"error": "Unable to import from the linked Foundry world."
},
"states": { "states": {
"loading": "Loading...", "loading-notes": "Loading notes...", "empty-notes": "No notes in this campaign yet.", "loading": "Loading...", "loading-notes": "Loading notes...", "empty-notes": "No notes in this campaign yet.",
"empty-actors": "No actors or characters yet.", "empty-items": "No items in this campaign yet.", "empty-actors": "No actors or characters yet.", "empty-items": "No items in this campaign yet.",
@@ -69,14 +74,19 @@
}, },
"item": { "item": {
"new": "New item", "edit": "Edit item", "foundry-sync-note": "Changes to this item are also applied in the linked Foundry world.", "new": "New item", "edit": "Edit item", "foundry-sync-note": "Changes to this item are also applied in the linked Foundry world.",
"category": "Category", "rarity": "Rarity", "quantity": "Quantity", "category": "Category", "rarity": "Rarity",
"quantity-short": "Qty", "weight": "Weight (lb)", "properties": "Properties", "properties-placeholder": "For example, versatile, finesse", "weight": "Weight (lb)", "properties": "Properties", "properties-placeholder": "For example, versatile, finesse",
"sheet": { "sheet": {
"icon": "Item icon", "choose-icon": "Choose your own icon", "change-icon": "Change icon", "icon": "Item icon", "choose-icon": "Choose your own icon", "change-icon": "Change icon",
"uploading": "Uploading...", "upload-error": "Unable to upload this icon.", "uploading": "Uploading...", "upload-error": "Unable to upload this icon.",
"foundry-icon": "Use Foundry icon", "remove-icon": "Remove icon", "save-error": "Unable to save this item.", "foundry-icon": "Use Foundry icon", "remove-icon": "Remove icon", "save-error": "Unable to save this item.",
"no-description": "No description added." "no-description": "No description added."
}, },
"icon-picker": {
"intro": "Where should this item's icon come from?",
"upload": "Upload icon", "upload-hint": "Choose an image from this device.",
"foundry": "Load from Foundry", "foundry-hint": "Browse the icons your Foundry world ships with."
},
"categories": { "categories": {
"weapon": "Weapon", "armor": "Armor", "shield": "Shield", "adventuring-gear": "Adventuring gear", "weapon": "Weapon", "armor": "Armor", "shield": "Shield", "adventuring-gear": "Adventuring gear",
"magic-item": "Magic item", "consumable": "Consumable", "tool": "Tool", "treasure": "Treasure", "other": "Other" "magic-item": "Magic item", "consumable": "Consumable", "tool": "Tool", "treasure": "Treasure", "other": "Other"
@@ -105,6 +115,16 @@
"drop-hint": "Drop to place the actor on this map", "drop-hint": "Drop to place the actor on this map",
"open": "Open character sheet", "remove": "Remove token", "open": "Open character sheet", "remove": "Remove token",
"error": "Unable to change the tokens of this map." "error": "Unable to change the tokens of this map."
},
"walls": {
"edit": "Edit walls",
"hint": "Drag on the map to draw a wall · drag its ends to retype it, its body to move it",
"wall": "Wall",
"sight-block": "Block sight", "sight-open": "Let sight through",
"move-block": "Block movement", "move-open": "Let movement through",
"door": "Door", "door-none": "Not a door", "door-closed": "Closed door", "door-open": "Open door",
"remove": "Remove wall",
"error": "Unable to save the walls of this map."
} }
}, },
"character-sheet": { "character-sheet": {
@@ -114,11 +134,24 @@
"saving": "Saving...", "save": "Save sheet", "save-error": "Unable to save this character sheet.", "saving": "Saving...", "save": "Save sheet", "save-error": "Unable to save this character sheet.",
"photo": "Photo", "upload-photo": "Upload photo", "change-photo": "Change photo", "remove-photo": "Remove photo", "photo": "Photo", "upload-photo": "Upload photo", "change-photo": "Change photo", "remove-photo": "Remove photo",
"uploading-photo": "Uploading...", "photo-error": "Unable to upload this photo.", "ability-scores": "Ability Scores", "proficiency-bonus": "Proficiency Bonus", "uploading-photo": "Uploading...", "photo-error": "Unable to upload this photo.", "ability-scores": "Ability Scores", "proficiency-bonus": "Proficiency Bonus",
"combat": "Combat", "armor-class": "Armor Class", "speed": "Speed", "proficiencies": "Proficiencies", "combat": "Combat", "armor-class": "Armor Class", "speed": "Speed", "initiative": "Initiative",
"proficiencies-placeholder": "Add saving throws, skills, armor, weapons, tools, and languages...", "empty-proficiencies": "No proficiencies added.", "hit-points": "Hit Points", "max-hit-points": "Maximum hit points", "hit-dice": "Hit Dice", "max-hit-dice": "Maximum hit dice", "proficiencies": "Proficiencies",
"proficiencies-placeholder": "Add armor, weapons, and anything else the character is proficient with...", "empty-proficiencies": "No proficiencies added.",
"saving-throws": "Saving Throws", "skills": "Skills",
"abilities": { "str": "Strength", "dex": "Dexterity", "con": "Constitution", "int": "Intelligence", "wis": "Wisdom", "cha": "Charisma" },
"skill-names": {
"acrobatics": "Acrobatics", "animalHandling": "Animal Handling", "arcana": "Arcana", "athletics": "Athletics",
"deception": "Deception", "history": "History", "insight": "Insight", "intimidation": "Intimidation",
"investigation": "Investigation", "medicine": "Medicine", "nature": "Nature", "perception": "Perception",
"performance": "Performance", "persuasion": "Persuasion", "religion": "Religion", "sleightOfHand": "Sleight of Hand",
"stealth": "Stealth", "survival": "Survival"
},
"tools": "Tools", "tools-placeholder": "List tools, one per line...", "empty-tools": "No tool proficiencies.",
"languages": "Languages", "languages-placeholder": "List languages, one per line...", "empty-languages": "No languages.",
"traits": "Traits", "traits-placeholder": "Add features, traits, and other character details...", "empty-traits": "No traits added.", "traits": "Traits", "traits-placeholder": "Add features, traits, and other character details...", "empty-traits": "No traits added.",
"spells": "Spells", "spells-placeholder": "List spells, one per line...", "empty-spells": "No spells added.", "spells": "Spells", "spells-placeholder": "List spells, one per line...", "empty-spells": "No spells added.",
"inventory": "Inventory", "add-item": "Add item", "carried-weight": "Carried weight", "item-name": "Item", "inventory": "Inventory", "add-item": "Add item", "carried-weight": "Carried weight", "item-name": "Item",
"quantity": "Qty", "weight-each": "Each (lb)", "total-weight": "Total (lb)", "actions": "Actions", "empty-inventory": "Inventory is empty." "quantity": "Qty", "weight-each": "Each (lb)", "total-weight": "Total (lb)", "actions": "Actions", "empty-inventory": "Inventory is empty.",
"currency": "Currency", "currency-units": { "pp": "PP", "gp": "GP", "ep": "EP", "sp": "SP", "cp": "CP" }, "item-icon": "Icon"
} }
} }

View File

@@ -0,0 +1,15 @@
{
"title": "Documentation",
"contents": "Contents",
"on-this-page": "On this page",
"open-app": "Open Dragonroll",
"previous": "Previous",
"next": "Next",
"not-found": "There is no documentation page called “{page}”.",
"back-to-docs": "Back to the documentation",
"groups": {
"getting-started": "Getting started",
"using-dragonroll": "Using Dragonroll",
"integrations": "Integrations"
}
}

View File

@@ -3,6 +3,19 @@
"link-expired": "This Foundry pairing code is invalid, expired, or already used.", "link-expired": "This Foundry pairing code is invalid, expired, or already used.",
"world-already-linked": "This Foundry world is already linked to another campaign.", "world-already-linked": "This Foundry world is already linked to another campaign.",
"actor-already-synced": "Another actor in this campaign is already synced with that Foundry actor.", "actor-already-synced": "Another actor in this campaign is already synced with that Foundry actor.",
"item-already-synced": "Another item in this campaign is already synced with that Foundry item." "item-already-synced": "Another item in this campaign is already synced with that Foundry item.",
"scene-already-synced": "Another map in this campaign is already synced with that Foundry scene.",
"icons-unavailable": "Foundry's icons are not available: its bridge is not set up, or it cannot be reached right now.",
"icons-no-world-url": "This campaign has no Foundry world address. Set it under campaign settings, in the Integrations tab.",
"import-not-linked": "This campaign has no Foundry world linked to it. Connect one under campaign settings, in the Integrations tab.",
"import-unavailable": "Foundry's data is not available: its bridge is not set up, it cannot be reached right now, or its world has not published anything yet.",
"import-world-mismatch": "The Foundry bridge is showing another world than the one this campaign is linked to."
},
"icons": {
"path": "Icon folder",
"up": "One folder up",
"loading": "Loading icons...",
"empty": "No icons to pick in this folder.",
"load-more": "Load more icons"
} }
} }

View File

@@ -2,6 +2,7 @@
"main-menu": "Main menu", "main-menu": "Main menu",
"edit-profile": "Edit profile", "edit-profile": "Edit profile",
"create-campaign": "Create Campaign", "create-campaign": "Create Campaign",
"documentation": "Documentation",
"log-out": "Log out", "log-out": "Log out",
"settings": "Settings", "settings": "Settings",
"exit": "Exit" "exit": "Exit"

View File

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

View File

@@ -49,6 +49,11 @@
"rename": "Renombrar", "color": "Color", "default": "Por defecto", "delete": "Eliminar carpeta", "rename": "Renombrar", "color": "Color", "default": "Por defecto", "delete": "Eliminar carpeta",
"move-to": "Mover a carpeta...", "root": "Raíz" "move-to": "Mover a carpeta...", "root": "Raíz"
}, },
"foundry-import": {
"run": "Forzar importación desde Foundry",
"done": "Importado desde Foundry: {imported} nuevos, {updated} actualizados.",
"error": "No se ha podido importar desde el mundo de Foundry vinculado."
},
"states": { "states": {
"loading": "Cargando...", "loading-notes": "Cargando notas...", "empty-notes": "Aún no hay notas en esta campaña.", "loading": "Cargando...", "loading-notes": "Cargando notas...", "empty-notes": "Aún no hay notas en esta campaña.",
"empty-actors": "Aún no hay actores ni personajes.", "empty-items": "Aún no hay objetos en esta campaña.", "empty-actors": "Aún no hay actores ni personajes.", "empty-items": "Aún no hay objetos en esta campaña.",
@@ -65,14 +70,19 @@
}, },
"item": { "item": {
"new": "Nuevo objeto", "edit": "Editar objeto", "foundry-sync-note": "Los cambios en este objeto también se aplican al mundo de Foundry vinculado.", "new": "Nuevo objeto", "edit": "Editar objeto", "foundry-sync-note": "Los cambios en este objeto también se aplican al mundo de Foundry vinculado.",
"category": "Categoría", "rarity": "Rareza", "quantity": "Cantidad", "category": "Categoría", "rarity": "Rareza",
"quantity-short": "Cant.", "weight": "Peso (lb)", "properties": "Propiedades", "properties-placeholder": "Por ejemplo, versátil, sutil", "weight": "Peso (lb)", "properties": "Propiedades", "properties-placeholder": "Por ejemplo, versátil, sutil",
"sheet": { "sheet": {
"icon": "Icono del objeto", "choose-icon": "Elegir tu propio icono", "change-icon": "Cambiar icono", "icon": "Icono del objeto", "choose-icon": "Elegir tu propio icono", "change-icon": "Cambiar icono",
"uploading": "Subiendo...", "upload-error": "No se pudo subir este icono.", "uploading": "Subiendo...", "upload-error": "No se pudo subir este icono.",
"foundry-icon": "Usar el icono de Foundry", "remove-icon": "Quitar el icono", "save-error": "No se pudo guardar este objeto.", "foundry-icon": "Usar el icono de Foundry", "remove-icon": "Quitar el icono", "save-error": "No se pudo guardar este objeto.",
"no-description": "Sin descripción añadida." "no-description": "Sin descripción añadida."
}, },
"icon-picker": {
"intro": "¿De dónde debe salir el icono de este objeto?",
"upload": "Subir icono", "upload-hint": "Elige una imagen de este dispositivo.",
"foundry": "Cargar desde Foundry", "foundry-hint": "Recorre los iconos que incluye tu mundo de Foundry."
},
"categories": { "categories": {
"weapon": "Arma", "armor": "Armadura", "shield": "Escudo", "adventuring-gear": "Equipo de aventura", "weapon": "Arma", "armor": "Armadura", "shield": "Escudo", "adventuring-gear": "Equipo de aventura",
"magic-item": "Objeto mágico", "consumable": "Consumible", "tool": "Herramienta", "treasure": "Tesoro", "other": "Otro" "magic-item": "Objeto mágico", "consumable": "Consumible", "tool": "Herramienta", "treasure": "Tesoro", "other": "Otro"
@@ -101,6 +111,16 @@
"drop-hint": "Suelta para colocar al actor en este mapa", "drop-hint": "Suelta para colocar al actor en este mapa",
"open": "Abrir hoja de personaje", "remove": "Quitar la ficha", "open": "Abrir hoja de personaje", "remove": "Quitar la ficha",
"error": "No se pudieron cambiar las fichas de este mapa." "error": "No se pudieron cambiar las fichas de este mapa."
},
"walls": {
"edit": "Editar muros",
"hint": "Arrastra sobre el mapa para dibujar un muro · arrastra sus extremos para cambiarlo, su cuerpo para moverlo",
"wall": "Muro",
"sight-block": "Bloquear la visión", "sight-open": "Permitir la visión",
"move-block": "Bloquear el movimiento", "move-open": "Permitir el movimiento",
"door": "Puerta", "door-none": "No es puerta", "door-closed": "Puerta cerrada", "door-open": "Puerta abierta",
"remove": "Quitar muro",
"error": "No se pudieron guardar los muros de este mapa."
} }
}, },
"character-sheet": { "character-sheet": {
@@ -108,11 +128,24 @@
"tabs": { "abilities": "Características", "inventory": "Inventario", "traits": "Rasgos", "spells": "Conjuros" }, "tabs": { "abilities": "Características", "inventory": "Inventario", "traits": "Rasgos", "spells": "Conjuros" },
"level": "Nivel", "species": "Especie", "unset-species": "Especie sin definir", "edit": "Editar hoja", "cancel": "Cancelar", "level": "Nivel", "species": "Especie", "unset-species": "Especie sin definir", "edit": "Editar hoja", "cancel": "Cancelar",
"saving": "Guardando...", "save": "Guardar hoja", "save-error": "No se pudo guardar esta hoja de personaje.", "photo": "Foto", "upload-photo": "Subir foto", "change-photo": "Cambiar foto", "remove-photo": "Quitar foto", "uploading-photo": "Subiendo...", "photo-error": "No se pudo subir esta foto.", "ability-scores": "Características", "proficiency-bonus": "Bonificador por competencia", "saving": "Guardando...", "save": "Guardar hoja", "save-error": "No se pudo guardar esta hoja de personaje.", "photo": "Foto", "upload-photo": "Subir foto", "change-photo": "Cambiar foto", "remove-photo": "Quitar foto", "uploading-photo": "Subiendo...", "photo-error": "No se pudo subir esta foto.", "ability-scores": "Características", "proficiency-bonus": "Bonificador por competencia",
"combat": "Combate", "armor-class": "Clase de armadura", "speed": "Velocidad", "proficiencies": "Competencias", "combat": "Combate", "armor-class": "Clase de armadura", "speed": "Velocidad", "initiative": "Iniciativa",
"proficiencies-placeholder": "Añade salvaciones, habilidades, armaduras, armas, herramientas e idiomas...", "empty-proficiencies": "No hay competencias añadidas.", "hit-points": "Puntos de golpe", "max-hit-points": "Puntos de golpe máximos", "hit-dice": "Dados de golpe", "max-hit-dice": "Dados de golpe máximos", "proficiencies": "Competencias",
"proficiencies-placeholder": "Añade armaduras, armas y cualquier otra competencia del personaje...", "empty-proficiencies": "No hay competencias añadidas.",
"saving-throws": "Tiradas de salvación", "skills": "Habilidades",
"abilities": { "str": "Fuerza", "dex": "Destreza", "con": "Constitución", "int": "Inteligencia", "wis": "Sabiduría", "cha": "Carisma" },
"skill-names": {
"acrobatics": "Acrobacias", "animalHandling": "Trato con animales", "arcana": "Arcano", "athletics": "Atletismo",
"deception": "Engaño", "history": "Historia", "insight": "Perspicacia", "intimidation": "Intimidación",
"investigation": "Investigación", "medicine": "Medicina", "nature": "Naturaleza", "perception": "Percepción",
"performance": "Interpretación", "persuasion": "Persuasión", "religion": "Religión", "sleightOfHand": "Manualidades",
"stealth": "Sigilo", "survival": "Supervivencia"
},
"tools": "Herramientas", "tools-placeholder": "Escribe las herramientas, una por línea...", "empty-tools": "Sin competencias con herramientas.",
"languages": "Idiomas", "languages-placeholder": "Escribe los idiomas, uno por línea...", "empty-languages": "Sin idiomas.",
"traits": "Rasgos", "traits-placeholder": "Añade rasgos, capacidades y otros detalles...", "empty-traits": "No hay rasgos añadidos.", "traits": "Rasgos", "traits-placeholder": "Añade rasgos, capacidades y otros detalles...", "empty-traits": "No hay rasgos añadidos.",
"spells": "Conjuros", "spells-placeholder": "Escribe los conjuros, uno por línea...", "empty-spells": "No hay conjuros añadidos.", "spells": "Conjuros", "spells-placeholder": "Escribe los conjuros, uno por línea...", "empty-spells": "No hay conjuros añadidos.",
"inventory": "Inventario", "add-item": "Añadir objeto", "carried-weight": "Peso transportado", "item-name": "Objeto", "inventory": "Inventario", "add-item": "Añadir objeto", "carried-weight": "Peso transportado", "item-name": "Objeto",
"quantity": "Cant.", "weight-each": "Unidad (lb)", "total-weight": "Total (lb)", "actions": "Acciones", "empty-inventory": "El inventario está vacío." "quantity": "Cant.", "weight-each": "Unidad (lb)", "total-weight": "Total (lb)", "actions": "Acciones", "empty-inventory": "El inventario está vacío.",
"currency": "Monedas", "currency-units": { "pp": "PP", "gp": "GP", "ep": "EP", "sp": "SP", "cp": "CP" }, "item-icon": "Icono"
} }
} }

View File

@@ -0,0 +1,15 @@
{
"title": "Documentación",
"contents": "Contenido",
"on-this-page": "En esta página",
"open-app": "Abrir Dragonroll",
"previous": "Anterior",
"next": "Siguiente",
"not-found": "No hay ninguna página de la documentación que se llame «{page}».",
"back-to-docs": "Volver a la documentación",
"groups": {
"getting-started": "Primeros pasos",
"using-dragonroll": "Usar Dragonroll",
"integrations": "Integraciones"
}
}

View File

@@ -3,6 +3,19 @@
"link-expired": "El código de vinculación de Foundry no es válido, ha caducado o ya se ha usado.", "link-expired": "El código de vinculación de Foundry no es válido, ha caducado o ya se ha usado.",
"world-already-linked": "Este mundo de Foundry ya está vinculado a otra campaña.", "world-already-linked": "Este mundo de Foundry ya está vinculado a otra campaña.",
"actor-already-synced": "Otro actor de esta campaña ya está sincronizado con ese actor de Foundry.", "actor-already-synced": "Otro actor de esta campaña ya está sincronizado con ese actor de Foundry.",
"item-already-synced": "Otro objeto de esta campaña ya está sincronizado con ese objeto de Foundry." "item-already-synced": "Otro objeto de esta campaña ya está sincronizado con ese objeto de Foundry.",
"scene-already-synced": "Otro mapa de esta campaña ya está sincronizado con esa escena de Foundry.",
"icons-unavailable": "Los iconos de Foundry no están disponibles: su bridge no está configurado o no es accesible ahora.",
"icons-no-world-url": "Esta campaña no tiene dirección del mundo de Foundry. Defínala en los ajustes de la campaña, en la pestaña de integraciones.",
"import-not-linked": "Esta campaña no tiene ningún mundo de Foundry vinculado. Conecte uno en los ajustes de la campaña, en la pestaña de integraciones.",
"import-unavailable": "Los datos de Foundry no están disponibles: su bridge no está configurado, no es accesible ahora o su mundo todavía no ha publicado nada.",
"import-world-mismatch": "El bridge de Foundry está mostrando un mundo distinto del que esta campaña tiene vinculado."
},
"icons": {
"path": "Carpeta de iconos",
"up": "Una carpeta arriba",
"loading": "Cargando iconos...",
"empty": "No hay iconos para elegir en esta carpeta.",
"load-more": "Cargar más iconos"
} }
} }

View File

@@ -2,6 +2,7 @@
"main-menu": "Menú principal", "main-menu": "Menú principal",
"edit-profile": "Editar perfil", "edit-profile": "Editar perfil",
"create-campaign": "Crear campanya", "create-campaign": "Crear campanya",
"documentation": "Documentación",
"log-out": "Cerrar sesión", "log-out": "Cerrar sesión",
"settings": "Configuración", "settings": "Configuración",
"exit": "Salir" "exit": "Salir"

View File

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

View File

@@ -0,0 +1,574 @@
// Tests for Syndria98/dragonroll#83, the things the character sheet did not hold:
// * the eighteen skills down the ability scores tab, each with a circle that stands lit
// when the character is proficient with it, and the six saving throws beside them,
// * proficiencies with tools and with languages,
// * the coins a character carries and the icon of each item it carries,
// * and traits that reach the campaign from the linked Foundry world.
//
// The window is a `.vue` file and the repository root installs no dependencies for it, so
// its template, styles and plain functions are read out of the source the way
// tests/character-sheet-tabs.test.js and tests/character-sheet-portrait-column.test.js
// read them. The Foundry mapper is plain CommonJS and is required for real; the actor
// route runs in a stubbed `require` against fake models, like tests/foundry-force-import.test.js.
// The Foundry module goes into a `node:vm` context with stubbed globals, like
// tests/foundry-sync-toggle.test.js, so what its actor snapshot carries 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 MODULE_ID = "dragonroll-foundry";
const sheetSource = read("frontend", "app", "components", "windows", "CharacterSheetWindow.vue");
const script = /<script setup>([\s\S]*?)<\/script>/.exec(sheetSource)?.[1] ?? "";
const template = /<template>([\s\S]*)<\/template>/.exec(sheetSource)?.[1] ?? "";
const actorModelSource = read("backend", "src", "models", "Actor.js");
// `fromSource` hands back one top-level declaration as a value, like the other character
// sheet tests do it.
function fromSource(source, pattern, locals = {}) {
const declaration = pattern.exec(source)?.[0];
assert.ok(declaration, `expected ${pattern} in the source`);
const name = /(?:const|function)\s+(\w+)/.exec(declaration)[1];
return new Function(...Object.keys(locals), `${declaration}\n;return ${name};`)(...Object.values(locals));
}
const abilityStats = fromSource(script, /const abilityStats = \[[\s\S]*?\];/);
const skillList = fromSource(script, /const skillList = \[[\s\S]*?\];/);
const currencyUnits = fromSource(script, /const currencyUnits = \[[\s\S]*?\];/);
const proficiencyText = fromSource(script, /function proficiencyText\(value\) \{[\s\S]*?\n\}/);
const proficiencyList = fromSource(script, /function proficiencyList\(text\) \{[\s\S]*?\n\}/);
const normalizeActor = fromSource(script, /function normalizeActor\(actor\) \{[\s\S]*?\n\}/, {
abilityStats, skillList, currencyUnits, proficiencyText
});
const skillKeys = skillList.map(({ key }) => key);
// --- The sheet: skills and saving throws on the ability scores tab -----------------
test("the sheet knows the eighteen skills, each under the ability that manages it", () => {
assert.deepEqual(skillKeys, [
"acrobatics", "animalHandling", "arcana", "athletics", "deception", "history", "insight",
"intimidation", "investigation", "medicine", "nature", "perception", "performance",
"persuasion", "religion", "sleightOfHand", "stealth", "survival"
]);
assert.deepEqual(
skillList.map(({ ability }) => ability),
["dex", "wis", "int", "str", "cha", "int", "wis", "cha", "int", "wis", "int", "wis", "cha", "cha", "int", "dex", "dex", "wis"],
"each skill stands with the ability D&D counts for it"
);
});
test("every skill stands with a circle that toggles whether the character is proficient", () => {
const panel = /<section class="sheet-panel skills-panel">([\s\S]*?)<\/section>/.exec(template)?.[1] ?? "";
assert.match(panel, /campaigns\.character-sheet\.skills/, "the panel is named for the skills");
assert.match(panel, /v-for="skill in skillList"/);
assert.match(panel, /:aria-checked="form\.skills\[skill\.key\]"/, "the circle says what it holds");
assert.match(panel, /@click="toggleProficiency\('skills', skill\.key\)"/);
assert.match(panel, /class="proficiency-dot"/);
assert.match(panel, /\{ proficient: form\.skills\[skill\.key\] \}/, "the circle stands lit for a proficiency");
assert.match(panel, /campaigns\.character-sheet\.skill-names\.\$\{skill\.key\}/, "the skill is called by its name");
assert.match(panel, /\{\{ skillModifier\(skill\) \}\}/, "and it shows the modifier the character rolls with it");
const toggle = /function toggleProficiency\(group, key\) \{[\s\S]*?\n\}/.exec(script)?.[0];
assert.match(toggle, /form\.value\[group\]\[key\] = !form\.value\[group\]\[key\]/, "the circle flips the toggle");
// The toggles belong to an edit in progress, like every other field of the sheet.
assert.match(panel, /:disabled="!editing"/);
});
test("the six saving throws ride with the ability scores", () => {
const abilities = /<section class="sheet-panel abilities-panel">([\s\S]*?)<\/section>/.exec(template)?.[1] ?? "";
assert.match(abilities, /campaigns\.character-sheet\.saving-throws/);
assert.match(abilities, /v-for="stat in abilityStats"/, "one save per ability score");
assert.match(abilities, /:aria-checked="form\.savingThrows\[stat\.key\]"/);
assert.match(abilities, /@click="toggleProficiency\('savingThrows', stat\.key\)"/);
assert.match(abilities, /\{\{ savingThrowModifier\(stat\) \}\}/);
// The ability scores themselves are untouched, and the saves stand under them.
assert.match(abilities, /v-model\.number="form\.abilityScores\[stat\.key\]"/);
assert.ok(
abilities.indexOf("ability-grid") < abilities.indexOf("saving-throw-grid"),
"the saving throws follow the scores they come from"
);
});
test("a skill's form entry starts off, and the world's toggles carry over", () => {
const fresh = normalizeActor({});
assert.deepEqual(fresh.skills.acrobatics, false);
assert.deepEqual(fresh.savingThrows.str, false);
assert.deepEqual(Object.keys(fresh.skills).length, 18, "every skill stands in the form, toggled or not");
assert.deepEqual(Object.keys(fresh.savingThrows).sort(), ["cha", "con", "dex", "int", "str", "wis"]);
const trained = normalizeActor({ skills: { stealth: true }, savingThrows: { con: true } });
assert.equal(trained.skills.stealth, true);
assert.equal(trained.savingThrows.con, true);
});
// --- Tools and languages ----------------------------------------------------------
test("tools and languages have a list of their own under the proficiencies", () => {
const panel = /<section class="sheet-panel proficiencies-panel">([\s\S]*?)<\/section>/.exec(template)?.[1] ?? "";
for (const [key, field] of [["tools", "form.tools"], ["languages", "form.languages"]]) {
assert.match(panel, new RegExp(`campaigns\\.character-sheet\\.${key}`), `the ${key} are named`);
assert.match(panel, new RegExp(`v-model="${field}"`), `the ${key} are edited as text`);
assert.match(panel, new RegExp(`\\{\\{ ${field} \\|\\| \\$t\\('campaigns\\.character-sheet\\.empty-${key}'\\) \\}\\}`));
}
// The free text keeps what has no list of its own, so it no longer asks for these.
const placeholder = /"proficiencies-placeholder": "([^"]+)"/.exec(read("frontend", "i18n", "locales", "en", "campaigns.json"))[1];
assert.doesNotMatch(placeholder, /skills|saving throws|tools|languages/i, "the text field does not ask for what has its own list");
});
test("the tools and languages lists travel as a list and edit as one name per line", () => {
assert.deepEqual(normalizeActor({ tools: ["Thieves tools", "Dice set"] }).tools, "Thieves tools\nDice set");
assert.deepEqual(normalizeActor({ languages: [] }).languages, "");
assert.deepEqual(
normalizeActor({ tools: [" Thieves tools ", "Thieves tools", "", "Dice set"] }).tools,
"Thieves tools\nDice set",
"blanks, spaces and repeats are not kept"
);
assert.deepEqual(proficiencyList("Thieves tools\nDice set"), ["Thieves tools", "Dice set"]);
assert.deepEqual(proficiencyList("Common, Elvish, Common"), ["Common", "Elvish"], "a comma separates too");
assert.deepEqual(proficiencyList(""), []);
assert.deepEqual(proficiencyList(proficiencyText(["Cartographer's supplies"])), ["Cartographer's supplies"]);
});
// --- Currency and item icons on the inventory tab ---------------------------------
test("the inventory shows the coins the character carries", () => {
assert.deepEqual(currencyUnits, ["pp", "gp", "ep", "sp", "cp"]);
const panel = /<main v-show="activeTab === 'inventory'"[\s\S]*?<\/main>/.exec(template)?.[0] ?? "";
assert.match(panel, /campaigns\.character-sheet\.currency/);
assert.match(panel, /v-for="unit in currencyUnits"/);
assert.match(panel, /v-model\.number="form\.currency\[unit\]"/, "each coin can be counted in");
assert.match(panel, /\{\{ form\.currency\[unit\] \}\}/, "and reads back outside of editing");
assert.deepEqual(normalizeActor({}).currency, { pp: 0, gp: 0, ep: 0, sp: 0, cp: 0 });
assert.deepEqual(normalizeActor({ currency: { gp: 12, cp: "40" } }).currency, { pp: 0, gp: 12, ep: 0, sp: 0, cp: 40 });
});
test("every inventory row opens with the item's icon", () => {
const panel = /<main v-show="activeTab === 'inventory'"[\s\S]*?<\/main>/.exec(template)?.[0] ?? "";
const iconCell = /<td class="item-icon-cell">([\s\S]*?)<\/td>/.exec(panel)?.[1] ?? "";
assert.match(iconCell, /v-if="item\.icon"/);
assert.match(iconCell, /:src="resolveImage\(item\.icon\)"/, "a world's own icon and an upload both resolve");
assert.match(iconCell, /item-icon-blank/, "and a row without one leaves the place marked");
// The icon comes first, and the name it stands in front of keeps reading left.
const firstCells = /<tr v-for="\(item, index\) in form\.inventory" :key="index">([\s\S]*?)<\/td>\s*([\s\S]*?)<\/td>/.exec(panel);
assert.match(firstCells[1], /item-icon-cell/);
assert.match(firstCells[2], /item-name-cell/);
const aligns = /\.inventory-table th:not\(:first-child\):not\(\.item-name-cell\)/.exec(sheetSource)?.[0];
assert.ok(aligns, "the name column is let go of the centred columns");
assert.equal(normalizeActor({ inventory: [{ name: "Torch" }] }).inventory[0].icon, "");
assert.equal(
normalizeActor({ inventory: [{ name: "Torch", icon: "http://vtt.test/icons/torch.svg" }] }).inventory[0].icon,
"http://vtt.test/icons/torch.svg"
);
});
// --- The model and the route ------------------------------------------------------
test("the Actor model holds the skills, the saves, the tools, the languages and the coins", () => {
for (const key of skillKeys) {
assert.match(actorModelSource, new RegExp(`${key}: \\{ type: Boolean, default: false \\}`), `${key} is a toggle`);
}
for (const key of ["str", "dex", "con", "int", "wis", "cha"]) {
assert.ok(
new RegExp(`savingThrows: \\{[\\s\\S]*?${key}: \\{ type: Boolean, default: false \\}`).test(actorModelSource),
`the ${key} saving throw stands in the model`
);
}
assert.match(actorModelSource, /tools: \[\{ type: String, trim: true \}\]/);
assert.match(actorModelSource, /languages: \[\{ type: String, trim: true \}\]/);
for (const unit of currencyUnits) {
assert.ok(
new RegExp(`currency: \\{[\\s\\S]*?${unit}: \\{ type: Number, min: 0, default: 0 \\}`).test(actorModelSource),
`${unit} counts among the coins`
);
}
assert.match(actorModelSource, /icon: \{ type: String, default: '' \}/, "a carried item keeps its icon");
});
// The actor update route with every require stubbed, the way
// tests/foundry-force-import.test.js runs the import route.
function loadActorRoute(actor) {
const routes = new Map();
const router = {
get: (route, ...handlers) => routes.set(`GET ${route}`, handlers),
post: (route, ...handlers) => routes.set(`POST ${route}`, handlers),
};
const requireStub = (id) => {
if (id === "express") return { Router: () => router };
if (id === "../services/storage") return { single: () => (req, res, next) => next() };
if (id === "../models/Campaign") {
return { findOne: () => ({ lean: () => Promise.resolve({ _id: "campaign-1" }) }) };
}
if (id === "../models/Actor") return { findById: async () => actor };
if (id === "../models/Folder") return { belongsToSection: async () => true };
if (id === "../models/Map") return { updateMany: async () => ({}) };
throw new Error(`require("${id}") is not stubbed`);
};
const moduleStub = { exports: {} };
vm.compileFunction(read("backend", "src", "routes", "actor.js"), ["require", "module", "exports"])(
requireStub, moduleStub, moduleStub.exports
);
async function update(body, user = { id: "user-1" }) {
const handlers = routes.get("POST /update");
assert.ok(handlers, "POST /update is not mounted");
let payload = null;
await handlers[handlers.length - 1]({ body, user }, { json: (sent) => { payload = sent; } });
return payload;
}
return { update };
}
test("the actor update writes the skills, the saves, the tools, the languages and the coins", async () => {
const actor = { _id: "actor-1", campaign: "campaign-1", save: async () => {} };
const route = loadActorRoute(actor);
const response = await route.update({
id: "actor-1",
skills: { acrobatics: true, stealth: false },
savingThrows: { con: true },
tools: [" Thieves tools ", "Thieves tools", "", "Dice set"],
languages: ["Elvish", "Undercommon"],
currency: { gp: 12, cp: 40 },
inventory: [{ name: "Torch", quantity: 2, weight: 0.5, icon: "icons/torch.svg" }],
});
assert.equal(response.status, "ok");
assert.deepEqual(actor.skills, { acrobatics: true, stealth: false });
assert.deepEqual(actor.savingThrows, { con: true });
assert.deepEqual(actor.tools, ["Thieves tools", "Dice set"], "blanks and repeats are written out of the lists");
assert.deepEqual(actor.languages, ["Elvish", "Undercommon"]);
assert.deepEqual(actor.currency, { gp: 12, cp: 40 });
assert.deepEqual(actor.inventory, [{ name: "Torch", quantity: 2, weight: 0.5, icon: "icons/torch.svg" }]);
});
test("an update that says nothing about them leaves the toggles and lists where they are", async () => {
const actor = {
_id: "actor-1",
campaign: "campaign-1",
skills: { acrobatics: true },
tools: ["Disguise kit"],
currency: { gp: 3 },
save: async () => {},
};
const route = loadActorRoute(actor);
const response = await route.update({ id: "actor-1", name: "Thalia" });
assert.equal(response.status, "ok");
assert.equal(actor.name, "Thalia");
assert.deepEqual(actor.skills, { acrobatics: true });
assert.deepEqual(actor.tools, ["Disguise kit"]);
assert.deepEqual(actor.currency, { gp: 3 });
});
// --- The Foundry world fills them in ---------------------------------------------
const { foundryActorToCharacter } = require(path.join(__dirname, "..", "backend", "src", "services", "actor-foundry.js"));
test("a world's skill and saving throw proficiencies arrive toggled", () => {
const character = foundryActorToCharacter({
name: "Thalia",
system: {
skills: { acr: { value: 1 }, stl: { value: 0 }, prc: { value: 2 }, arc: { value: ["exp"] }, his: { value: [] } },
savingThrows: { str: { value: 1 }, dex: { value: 0 }, con: { prof: { value: 2 } } },
},
});
assert.deepEqual(character.skills, {
acrobatics: true, stealth: false, arcana: true, history: false, perception: true,
});
assert.deepEqual(character.savingThrows, { str: true, dex: false, con: true });
});
test("an older world holding its saves under the abilities is read the same way", () => {
const character = foundryActorToCharacter({
name: "Thalia",
system: { abilities: { str: { save: 0 }, dex: { save: 1 } }, saves: { con: { proficient: true } } },
});
assert.deepEqual(character.savingThrows, { str: false, dex: true, con: true });
});
test("a world that says nothing about skills or saves leaves what the campaign toggled", () => {
const character = foundryActorToCharacter({ name: "Thalia", system: { abilities: { str: { value: 16 } } } });
assert.ok(!("skills" in character), "no skills to report is not the same as none proficient");
assert.ok(!("savingThrows" in character));
assert.ok(!("currency" in character));
assert.ok(!("tools" in character), "and neither are the tool and language lists");
assert.ok(!("languages" in character));
});
test("the tools and languages the module names come over as they are named", () => {
const character = foundryActorToCharacter({
name: "Thalia",
system: { traits: { tool: { value: ["xyz12abc345def67"] }, languages: { value: ["aB3cD9eF1gH2iJ4k"] } } },
dragonroll: { tools: ["Thieves' tools", "Dice set"], languages: ["Elvish", "Deep Speech"] },
});
assert.deepEqual(character.tools, ["Thieves' tools", "Dice set"]);
assert.deepEqual(character.languages, ["Elvish", "Deep Speech"]);
});
test("without the module's names the proficiency keys are read off the actor", () => {
const character = foundryActorToCharacter({
name: "Thalia",
system: {
traits: {
tool: { value: ["thieves", "alchemist"], custom: "Dice set, Playing cards" },
languages: { value: ["common", "aB3cD9eF1gH2iJ4k"], custom: "Thieves' cant" },
},
},
});
assert.deepEqual(character.tools, ["thieves", "alchemist", "Dice set", "Playing cards"]);
assert.deepEqual(
character.languages,
["common", "Thieves' cant"],
"a language the sheet cannot name is dropped rather than shown as a document id"
);
const none = foundryActorToCharacter({ name: "Thalia", system: { traits: { tool: { value: [] } } } });
assert.deepEqual(none.tools, [], "a world with no tool proficiency says so");
assert.ok(!("languages" in none), "and says nothing at all about the ones it does not list");
});
test("the coins of the world are the coins of the campaign", () => {
const character = foundryActorToCharacter({ name: "Thalia", system: { currency: { pp: 1, gp: 25, sp: -3 } } });
assert.deepEqual(character.currency, { pp: 1, gp: 25, ep: 0, sp: 0, cp: 0 }, "and never a debt");
});
test("a carried item brings its own icon", () => {
const character = foundryActorToCharacter({
name: "Thalia",
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 } },
],
});
assert.deepEqual(character.inventory, [
{ name: "Longsword", quantity: 1, weight: 3, icon: "http://vtt.test/icons/sword.svg" },
{ name: "Rope", quantity: 2, weight: 0, icon: "" },
]);
});
// --- The traits tab syncs --------------------------------------------------------
test("the world's own traits reach the campaign", () => {
const fromText = foundryActorToCharacter({ name: "Thalia", system: { details: { trait: "Spellcaster.<br>Light sleeper." } } });
assert.equal(fromText.traits, "Spellcaster.\nLight sleeper.");
const fromFeatures = foundryActorToCharacter({
name: "Thalia",
system: {},
items: [
{ name: "Darkvision", type: "feat", system: { featType: "trs", description: { value: "<p>See in the dark.</p>" } } },
{ name: "Brave", type: "feat", system: { featType: ["tr"], description: { value: "Advantage on saves." } } },
{ name: "Alert", type: "feat", system: { featType: "feat", description: { value: "Never surprised." } } },
],
});
assert.equal(fromFeatures.traits, "Darkvision\nSee in the dark.\n\nBrave\nAdvantage on saves.");
});
test("the world leads the traits tab, and what the campaign wrote fills in when it has none", () => {
// The module carries whatever the campaign shows for the traits back to the world on
// its flag, and the actor's own traits lead from there: a world keeps its traits in
// step the same way it keeps its proficiencies in step, while a character the world
// says nothing about keeps what the campaign wrote for it.
const fromWorld = foundryActorToCharacter({
name: "Thalia",
system: { details: { trait: "The world's own traits" } },
flags: { [MODULE_ID]: { traits: "What the campaign typed" } },
});
assert.equal(fromWorld.traits, "The world's own traits");
const fromCampaign = foundryActorToCharacter({
name: "Thalia",
system: {},
flags: { [MODULE_ID]: { traits: "What the campaign typed" } },
});
assert.equal(fromCampaign.traits, "What the campaign typed");
});
test("an actor that holds no traits does not clear what the campaign has", () => {
const character = foundryActorToCharacter({ name: "Thalia", system: {}, items: [], flags: {} });
assert.ok(!("traits" in character), "a live edit that knows nothing about traits leaves the tab as it is");
});
// --- The module sends the names a sheet outside Foundry can read -----------------
function makeWorld({ actor, config = {}, worldItems = [] }) {
const state = { hooks: new Map(), requests: [], timers: new Map(), nextTimerId: 1 };
const documents = [actor];
const settingsStore = { autoSync: true, syncToken: "sync-token-1", dragonrollApiUrl: "http://backend.test:5000" };
const sandbox = {
console: { log() {}, info() {}, warn() {}, error() {} },
URL,
CONFIG: 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) => { const id = state.nextTimerId++; state.timers.set(id, { fn }); return id; },
clearTimeout: (id) => state.timers.delete(id),
setInterval: () => 0,
clearInterval: () => {},
fetch: async (url, options = {}) => {
state.requests.push({ href: String(url), body: options.body ? JSON.parse(options.body) : null });
return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [] }) };
},
Actor: { async create() { return null; } },
Item: { async create() { return null; } },
};
sandbox.game = {
user: { isGM: true },
world: { id: "world-1", title: "Test World" },
system: { id: "dnd5e" },
modules: { get: () => ({}) },
actors: { contents: documents, get: (id) => documents.find((document) => document.id === id) },
items: { contents: worldItems, get: (id) => worldItems.find((document) => document.id === id) },
folders: { contents: [], get: () => null },
settings: {
register(module, key, definition) {
if (!(key in settingsStore)) settingsStore[key] = definition.default;
},
get(module, key) { return settingsStore[key]; },
async set(module, key, value) { settingsStore[key] = value; },
},
};
vm.createContext(sandbox);
vm.runInContext(read("dragonroll-foundry", "scripts", "api.js"), sandbox);
const drain = async () => { await new Promise((resolve) => setImmediate(resolve)); };
state.fire = async (name, ...args) => {
for (const handler of state.hooks.get(name) || []) await handler(...args);
await drain();
};
state.runTimers = async () => {
for (let round = 0; round < 6; round += 1) {
const due = [...state.timers.values()];
state.timers.clear();
for (const timer of due) await timer.fn();
await drain();
}
};
// Only the pushes of an actor count here: the world start sends one, and what an
// actor changed sends the next.
state.actorPushes = () => state.requests
.filter((request) => request.href.includes("foundry/sync/snapshot"))
.map((request) => request.body.actors[0]);
return state;
}
function makeStubActor(id, name, system = {}, items = []) {
return {
id,
name,
type: "character",
documentName: "Actor",
img: "icons/svg/mystery-man.svg",
system,
flags: {},
items: { contents: items },
getFlag(module, key) { return this.flags?.[module]?.[key]; },
async update(data) { return data; },
toObject() { return { _id: this.id, name: this.name, type: this.type, img: this.img, flags: this.flags, system: this.system }; },
};
}
// A world document of its own — a language since the third release of the system —
// plain enough to serialize like any other item of the world.
function makeWorldItem(id, name) {
return {
id,
name,
type: "loot",
documentName: "Item",
parent: null,
folder: null,
flags: {},
system: {},
getFlag() { return undefined; },
toObject() { return { _id: this.id, name: this.name, type: this.type, flags: this.flags, system: this.system }; },
};
}
async function pushAfterEdit(actor, options) {
const world = makeWorld(options);
await world.fire("init");
await world.fire("ready");
await world.runTimers();
await world.fire("updateActor", actor);
await world.runTimers();
return world.actorPushes().at(-1);
}
test("the actor snapshot names the world's tools and languages", async () => {
const actor = makeStubActor("actor-1", "Thalia", {
traits: {
tool: { value: ["thieves"], custom: "Dice set" },
languages: { value: ["common", "lang-1"] },
},
});
const sent = await pushAfterEdit(actor, {
config: {
DND5E: {
tools: { thieves: { label: "Thieves' tools" } },
languages: { common: { name: "Common" } },
},
},
worldItems: [makeWorldItem("lang-1", "Deep Speech")],
});
assert.equal(sent._id, "actor-1", "the actor the world edited is the one that was sent");
assert.deepEqual(sent.dragonroll.tools, ["Thieves' tools", "Dice set"]);
assert.deepEqual(sent.dragonroll.languages, ["Common", "Deep Speech"]);
});
test("an actor listing no tools or languages says nothing about them", async () => {
const actor = makeStubActor("actor-1", "Grunt", { details: { level: 1 } });
const sent = await pushAfterEdit(actor, { config: { DND5E: { tools: { thieves: { label: "Thieves' tools" } } } } });
assert.equal(sent.dragonroll, undefined, "no dragonroll block is what tells the campaign nothing was said");
});
// --- Every locale says it ------------------------------------------------------
test("every locale names the skills, the saving throws, the tools, the languages and the coins", () => {
for (const locale of ["en", "es", "ca"]) {
const sheet = JSON.parse(read("frontend", "i18n", "locales", locale, "campaigns.json"))["character-sheet"];
for (const key of ["skills", "saving-throws", "tools", "languages", "currency", "item-icon"]) {
assert.ok(sheet[key], `${locale} is missing campaigns.character-sheet.${key}`);
}
for (const [group, keys] of [["abilities", ["str", "dex", "con", "int", "wis", "cha"]], ["skill-names", skillKeys], ["currency-units", currencyUnits]]) {
for (const key of keys) {
assert.ok(sheet[group]?.[key], `${locale} is missing campaigns.character-sheet.${group}.${key}`);
}
}
assert.deepEqual(Object.keys(sheet["skill-names"]).sort(), [...skillKeys].sort(), `${locale} names every skill the sheet lists`);
assert.notEqual(sheet["skill-names"].acrobatics, "acrobatics", `${locale} spells the skill out, not its key`);
}
});

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

@@ -0,0 +1,176 @@
// Tests for Syndria98/dragonroll#64, the second round of modifications to the character sheet:
// * the tab rail hangs off the border of the window instead of standing inside the sheet body,
// * the armor class, the speed, the proficiency bonus and the initiative bonus stand under the
// portrait, together with the hit points and the hit dice, both drawn as bars.
//
// The window is a `.vue` file and the repository root installs no dependencies for it, so its
// template and styles are read out of the source the way tests/character-sheet-tabs.test.js reads
// them. The plain functions the sheet and the route work out their numbers with are lifted out of
// those sources and called, the way tests/map-viewer.test.js runs a service it cannot import.
//
// 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 script = /<script setup>([\s\S]*?)<\/script>/.exec(sheetSource)?.[1] ?? "";
const template = /<template>([\s\S]*)<\/template>/.exec(sheetSource)?.[1] ?? "";
const actorModelSource = read("backend", "src", "models", "Actor.js");
const actorRouteSource = read("backend", "src", "routes", "actor.js");
// `fromSource` hands back one top-level declaration as a value. Imports and refs are module scope
// the test does not have, so the few names a declaration reads are passed in as arguments. The
// declaration runs in this realm, so the objects it builds compare with the ones the test builds.
function fromSource(source, pattern, locals = {}) {
const declaration = pattern.exec(source)?.[0];
assert.ok(declaration, `expected ${pattern} in the source`);
const name = /(?:const|function)\s+(\w+)/.exec(declaration)[1];
return new Function(...Object.keys(locals), `${declaration}\n;return ${name};`)(...Object.values(locals));
}
const abilityStats = fromSource(script, /const abilityStats = \[[\s\S]*?\];/);
// #83 put the skills, the saving throws, the tools, the languages and the coins into the
// sheet form, so reading that form out of the source reads their names along with it.
const skillList = fromSource(script, /const skillList = \[[\s\S]*?\];/);
const currencyUnits = fromSource(script, /const currencyUnits = \[[\s\S]*?\];/);
const proficiencyText = fromSource(script, /function proficiencyText\(value\) \{[\s\S]*?\n\}/);
const normalizeActor = fromSource(script, /function normalizeActor\(actor\) \{[\s\S]*?\n\}/, { abilityStats, skillList, currencyUnits, proficiencyText });
const barPercent = fromSource(script, /function barPercent\(current, max\) \{[\s\S]*?\n\}/);
const barPool = fromSource(actorRouteSource, /function barPool\(existing, value\) \{[\s\S]*?\n\}/);
// The column that stands beside every tab: the portrait with everything under it.
function portraitColumn() {
const start = template.indexOf('<div class="character-column">');
const end = template.indexOf('<section class="sheet-panel abilities-panel">');
assert.ok(start !== -1 && end > start, "expected a character column ahead of the ability scores");
return template.slice(start, end);
}
test("the tab rail hangs off the border of the window, outside the sheet body", () => {
const rail = /\.sheet-tabs\s*\{[^}]*\}/.exec(sheetSource)?.[0] ?? "";
assert.match(rail, /position:\s*absolute/, "the rail is mounted on the window frame");
assert.match(rail, /left:\s*100%/, "it starts at the right border and reaches outwards");
assert.ok(
template.indexOf('<nav class="sheet-tabs"') < template.indexOf('<div class="sheet-body">'),
"the rail is a child of the window, ahead of the body it hangs beside"
);
const body = /\.sheet-body\s*\{[^}]*\}/.exec(sheetSource)?.[0] ?? "";
assert.match(body, /overflow:\s*auto/, "the sheet body scrolls on its own, the rail stays put");
});
test("the armor class, the speed and both bonuses stand under the portrait", () => {
const column = portraitColumn();
assert.ok(column.includes('class="sheet-portrait"'), "the portrait opens the column");
assert.ok(column.includes('class="sheet-panel vitals-panel"'), "the readouts follow the image");
assert.ok(
column.indexOf('class="sheet-portrait"') < column.indexOf("vitals-panel"),
"the readouts stand under the image, not above it"
);
for (const key of ["armor-class", "speed", "proficiency-bonus", "initiative"]) {
assert.ok(
column.includes(`campaigns.character-sheet.${key}`),
`the ${key} belongs under the image`
);
}
// Gone from where they were: the combat panel is nothing but proficiencies left over, and the
// ability scores panel keeps the six scores only.
assert.doesNotMatch(template, /combat-panel/, "the combat panel went with the combat stats");
const abilities = template
.slice(template.indexOf('<section class="sheet-panel abilities-panel">'))
.split("</section>")[0];
assert.doesNotMatch(abilities, /proficiency-bonus/, "the proficiency bonus moved down the column");
assert.match(abilities, /campaigns\.character-sheet\.ability-scores/);
});
test("the hit points and the hit dice stand as bars under the portrait", () => {
const column = portraitColumn();
assert.match(column, /class="vital-bar hit-points-bar"/);
assert.match(column, /class="vital-bar hit-dice-bar"/);
for (const pool of ["hitPoints", "hitDice"]) {
assert.match(column, new RegExp(`v-model\\.number="form\\.${pool}\\.current"`), `${pool} is editable`);
assert.match(column, new RegExp(`v-model\\.number="form\\.${pool}\\.max"`), `${pool} has a maximum to set`);
assert.match(
column,
new RegExp(`\\{\\{ form\\.${pool}\\.current \\}\\} / \\{\\{ form\\.${pool}\\.max \\}\\}`),
`${pool} reads current of max outside of editing`
);
}
// Each bar fills what its own maximum allows, and each is painted its own colour.
assert.match(column, /:style="\{ width: `\$\{hitPointsPercent\}%` \}"/);
assert.match(column, /:style="\{ width: `\$\{hitDicePercent\}%` \}"/);
assert.match(sheetSource, /\.hit-points-bar \.vital-bar-fill\s*\{[^}]*var\(--color-red\)/);
assert.match(sheetSource, /\.hit-dice-bar \.vital-bar-fill\s*\{[^}]*var\(--color-link\)/);
});
test("a bar fills what its maximum allows, no more and no less", () => {
assert.equal(barPercent(5, 10), 50);
assert.equal(barPercent(12, 10), 100, "healed past the maximum does not overflow the track");
assert.equal(barPercent(-3, 10), 0, "nothing left stands empty");
assert.equal(barPercent(4, 0), 0, "a maximum of nothing is no bar either");
assert.equal(barPercent("", 10), 0, "an input cleared mid-edit is read as nothing");
});
test("the initiative bonus is the modifier of dexterity", () => {
assert.match(
script,
/const initiativeBonus = computed\(\(\) => abilityModifier\(form\.value\.abilityScores\.dex\)\)/,
"D&D counts initiative as the dexterity modifier while the character carries no extra bonus"
);
// #83 gave the helper an optional proficiency bonus, for the skills and the saving
// throws the character is proficient with; the bare modifier is unchanged.
const abilityModifier = fromSource(script, /function abilityModifier\(score[^{]*\) \{[\s\S]*?\n\}/);
assert.equal(abilityModifier(16), "+3");
assert.equal(abilityModifier(10), "+0", "the sheet writes a flat modifier with its sign, as the ability cards do");
assert.equal(abilityModifier(9), "-1");
assert.equal(abilityModifier(16, 3), "+6", "a proficient skill adds the proficiency bonus to its modifier");
assert.equal(abilityModifier(8, 2), "+1", "and one below 10 counts its own negative modifier first");
});
test("an actor carries its pools, and one without them starts on its level", () => {
assert.deepEqual(normalizeActor({ level: 3 }).hitPoints, { current: 10, max: 10 });
assert.deepEqual(normalizeActor({ level: 3 }).hitDice, { current: 3, max: 3 }, "one die per level");
const wounded = normalizeActor({
level: 5,
hitPoints: { current: 4, max: 44 },
hitDice: { current: 2, max: 5 }
});
assert.deepEqual(wounded.hitPoints, { current: 4, max: 44 });
assert.deepEqual(wounded.hitDice, { current: 2, max: 5 });
});
test("the Actor model stores both pools as current of a maximum", () => {
for (const pool of ["hitPoints", "hitDice"]) {
assert.match(
actorModelSource,
new RegExp(`${pool}:\\s*\\{\\s*current:\\s*\\{\\s*type:\\s*Number[^}]*\\},\\s*max:\\s*\\{\\s*type:\\s*Number[^}]*\\}`),
`${pool} holds a current and a maximum`
);
}
});
test("the actor update takes both pools and never lets one pass its maximum", () => {
assert.match(actorRouteSource, /const \{[^}]*hitPoints[^}]*hitDice[^}]*\} = req\.body;/, "the update reads them off the body");
assert.match(actorRouteSource, /if \(hitPoints !== undefined\) actor\.hitPoints = barPool\(actor\.hitPoints, hitPoints\)/);
assert.match(actorRouteSource, /if \(hitDice !== undefined\) actor\.hitDice = barPool\(actor\.hitDice, hitDice\)/);
assert.deepEqual(barPool({ current: 5, max: 20 }, { current: 8, max: 30 }), { current: 8, max: 30 });
assert.deepEqual(barPool({ current: 5, max: 20 }, { current: 40 }), { current: 20, max: 20 }, "a current over its maximum stops at the maximum");
assert.deepEqual(barPool({ current: 5, max: 20 }, { max: 4 }), { current: 4, max: 4 }, "a maximum lowered below the current pulls it down");
assert.deepEqual(barPool({ current: 5, max: 20 }, { current: 12 }), { current: 12, max: 20 }, "half a pair keeps the half it did not send");
assert.deepEqual(barPool({ current: 5, max: 20 }, { current: -2, max: 20 }), { current: 0, max: 20 });
});
test("every locale names the readouts that moved under the portrait", () => {
for (const locale of ["en", "es", "ca"]) {
const sheet = JSON.parse(read("frontend", "i18n", "locales", locale, "campaigns.json"))["character-sheet"];
for (const key of ["initiative", "hit-points", "max-hit-points", "hit-dice", "max-hit-dice"]) {
assert.ok(sheet[key], `${locale} is missing campaigns.character-sheet.${key}`);
}
}
});

View File

@@ -37,9 +37,10 @@ test("the tabs sit on the right as a vertical bookmark rail", () => {
assert.match(template, /v-for="tab in tabs"[\s\S]*?:aria-selected="activeTab === tab\.key"/); assert.match(template, /v-for="tab in tabs"[\s\S]*?:aria-selected="activeTab === tab\.key"/);
const rail = /\.sheet-tabs\s*\{[^}]*\}/.exec(sheetSource)?.[0] ?? ""; const rail = /\.sheet-tabs\s*\{[^}]*\}/.exec(sheetSource)?.[0] ?? "";
assert.match(rail, /flex-direction:\s*column/, "the bookmarks stack down the right edge"); assert.match(rail, /flex-direction:\s*column/, "the bookmarks stack down the right edge");
// content column and rail sit side by side, the rail hugging the right // #64 moved the rail out of the content: it hangs off the window border itself, so it is not
assert.match(sheetSource, /\.sheet-layout\s*\{[^}]*display:\s*flex[^}]*\}/, "content and rail share a row"); // swept along when the sheet scrolls (see tests/character-sheet-portrait-column.test.js).
assert.match(sheetSource, /\.sheet-content\s*\{[^}]*flex:\s*1[^}]*\}/, "the content takes the room, the rail stays slim"); assert.match(rail, /position:\s*absolute/, "the rail is mounted on the window frame");
assert.match(rail, /left:\s*100%/, "the rail stands outside the window's right border");
}); });
// Each tab shows only its own panels; the rest are hidden with v-show so an in-progress edit is // Each tab shows only its own panels; the rest are hidden with v-show so an in-progress edit is
@@ -52,9 +53,8 @@ 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 combat-panel"/, "combat rides 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"]) {
assert.doesNotMatch(abilities, new RegExp(other)); assert.doesNotMatch(abilities, new RegExp(other));
} }
@@ -62,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,522 @@
// 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"));
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

@@ -0,0 +1,290 @@
// Tests for linking the characters of a campaign to the Discord players of the server it is
// linked to (Syndria98/dragonroll#72): each player holds one character, anybody claims a free
// one for themselves, and only a server administrator moves or frees one somebody else holds.
//
// Same set-up as tests/map-tokens.test.js, which the repository root runs without installing
// anything: the express router of routes/discord.js is loaded into `node:vm` with its models
// stubbed, and the last checks read the sources of the bot, whose command wiring is what has
// to stay right.
//
// Run with `npm test` from the repository root, or `node --test tests/`.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const fs = require("node:fs");
const path = require("node:path");
const vm = require("node:vm");
function readRepoFile(...parts) {
return fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
}
// A mongoose query answers whatever `await query` and `query.lean()` answer with, and lets `select()`
// and `sort()` sit in between.
function mongooseQuery(value) {
const result = {
select: () => result,
sort: () => result,
lean: () => Promise.resolve(value),
then: (onFulfilled, onRejected) => Promise.resolve(value).then(onFulfilled, onRejected),
};
return result;
}
const GUILD_ID = "12345678901234567";
const PLAYER = "1111111111111111111";
const OTHER_PLAYER = "2222222222222222222";
// The pieces of a filter the routes build against actors: the campaign, the player holding the
// character, and plain or `$ne` ids.
function actorMatches(actor, filter = {}) {
if (filter.campaign !== undefined && String(actor.campaign) !== String(filter.campaign)) return false;
if (filter.discordUserId !== undefined && String(actor.discordUserId ?? null) !== String(filter.discordUserId ?? null)) return false;
if (filter._id !== undefined) {
if (filter._id && typeof filter._id === "object" && filter._id.$ne !== undefined) {
if (String(actor._id) === String(filter._id.$ne)) return false;
} else if (String(actor._id) !== String(filter._id)) return false;
}
return true;
}
// Loads routes/discord.js over a store of actors, a guild link and the campaign that guild holds.
function loadDiscordRoutes({ guildLink = { guildId: GUILD_ID, dragonrollUser: "user-1" }, campaign = { _id: "campaign-1", name: "Katlum" }, actors = [] } = {}) {
const store = actors.map((actor) => ({ campaign: "campaign-1", discordUserId: null, save: async () => {}, ...actor }));
const routes = new Map();
const router = {
get: (route, ...handlers) => routes.set(`GET ${route}`, handlers),
post: (route, ...handlers) => routes.set(`POST ${route}`, handlers),
delete: () => {},
};
const requireStub = (id) => {
if (id === "express") return { Router: () => router };
if (id === "../models/Actor") return {
findOne: (filter) => {
const actor = store.find((candidate) => actorMatches(candidate, filter));
return mongooseQuery(actor ?? null);
},
find: (filter) => mongooseQuery(store.filter((candidate) => actorMatches(candidate, filter))
.slice()
.sort((a, b) => String(a.name).localeCompare(String(b.name)))),
updateMany: async (filter, update) => {
let modifiedCount = 0;
for (const actor of store) {
if (!actorMatches(actor, filter)) continue;
if (update.$set && "discordUserId" in update.$set) actor.discordUserId = update.$set.discordUserId;
modifiedCount += 1;
}
return { modifiedCount };
},
};
if (id === "../models/Campaign") return { findOne: () => mongooseQuery(campaign) };
if (id === "../models/DiscordGuildLink") return { findOne: () => mongooseQuery(guildLink) };
if (id === "../models/ServiceLinkRequest") return {};
if (id === "../models/User") return {};
if (id === "../services/service-links") return { requireDiscordBot: (req, res, next) => next(), NOTIFICATION_WINDOW_MS: 1 };
throw new Error(`require("${id}") is not stubbed`);
};
const moduleStub = { exports: {} };
vm.compileFunction(readRepoFile("backend", "src", "routes", "discord.js"), ["require", "module", "exports"])(
requireStub, moduleStub, moduleStub.exports
);
async function call(route, { body = {}, params = {} } = {}) {
const handlers = routes.get(route);
assert.ok(handlers, `${route} is not mounted`);
const res = { payload: null, json(payload) { this.payload = payload; } };
// The last handler of the chain, skipping the bot-secret gate the harness stands behind.
await handlers[handlers.length - 1]({ body, params: { guildId: GUILD_ID, ...params } }, res);
return res.payload;
}
function actor(id) {
return store.find((candidate) => candidate._id === id);
}
return { call, actor };
}
const ASSIGN = "POST /bot/guild/:guildId/actors/assign";
const UNASSIGN = "POST /bot/guild/:guildId/actors/unassign";
function assignmentRouteTests() {
test("assigning links one campaign character to a Discord player", async () => {
const api = loadDiscordRoutes({ actors: [{ _id: "actor-1", name: "Katlum" }] });
const response = await api.call(ASSIGN, { body: { actorId: "actor-1", discordUserId: PLAYER } });
assert.equal(response.status, "ok");
assert.deepEqual(response.actor, { id: "actor-1", name: "Katlum", discordUserId: PLAYER });
assert.equal(api.actor("actor-1").discordUserId, PLAYER);
assert.equal(response.previous, null);
});
test("a player never holds two characters: taking a second one frees the first", async () => {
const api = loadDiscordRoutes({
actors: [
{ _id: "actor-1", name: "Katlum", discordUserId: PLAYER },
{ _id: "actor-2", name: "Solus" }
]
});
const response = await api.call(ASSIGN, { body: { actorId: "actor-2", discordUserId: PLAYER } });
assert.equal(response.status, "ok");
assert.equal(api.actor("actor-1").discordUserId, null);
assert.equal(api.actor("actor-2").discordUserId, PLAYER);
assert.deepEqual(response.previous, { id: "actor-1", name: "Katlum" });
});
test("a player cannot take a character another player already holds", async () => {
const api = loadDiscordRoutes({
actors: [{ _id: "actor-1", name: "Katlum", discordUserId: OTHER_PLAYER }]
});
const response = await api.call(ASSIGN, { body: { actorId: "actor-1", discordUserId: PLAYER } });
assert.equal(response.msg, "discord.errors.actor-held");
assert.equal(api.actor("actor-1").discordUserId, OTHER_PLAYER);
});
test("a server administrator moves a held character to themselves", async () => {
const api = loadDiscordRoutes({
actors: [
{ _id: "actor-1", name: "Katlum", discordUserId: OTHER_PLAYER },
{ _id: "actor-2", name: "Solus", discordUserId: PLAYER }
]
});
const response = await api.call(ASSIGN, { body: { actorId: "actor-1", discordUserId: PLAYER, admin: true } });
assert.equal(response.status, "ok");
assert.equal(api.actor("actor-1").discordUserId, PLAYER);
assert.equal(api.actor("actor-2").discordUserId, null);
});
test("unassigning without a character frees the one linked to the player", async () => {
const api = loadDiscordRoutes({
actors: [
{ _id: "actor-1", name: "Katlum", discordUserId: PLAYER },
{ _id: "actor-2", name: "Silang", discordUserId: OTHER_PLAYER }
]
});
const response = await api.call(UNASSIGN, { body: { discordUserId: PLAYER } });
assert.equal(response.status, "ok");
assert.deepEqual(response.actor, { id: "actor-1", name: "Katlum" });
assert.equal(response.wasYours, true);
assert.equal(api.actor("actor-1").discordUserId, null);
assert.equal(api.actor("actor-2").discordUserId, OTHER_PLAYER);
});
test("a player cannot unassign a character held by somebody else", async () => {
const api = loadDiscordRoutes({
actors: [{ _id: "actor-1", name: "Katlum", discordUserId: OTHER_PLAYER }]
});
const response = await api.call(UNASSIGN, { body: { actorId: "actor-1", discordUserId: PLAYER } });
assert.equal(response.msg, "discord.errors.actor-held");
assert.equal(api.actor("actor-1").discordUserId, OTHER_PLAYER);
});
test("a server administrator frees anybody's character", async () => {
const api = loadDiscordRoutes({
actors: [{ _id: "actor-1", name: "Katlum", discordUserId: OTHER_PLAYER }]
});
const response = await api.call(UNASSIGN, { body: { actorId: "actor-1", discordUserId: PLAYER, admin: true } });
assert.equal(response.status, "ok");
assert.equal(response.wasYours, false);
assert.equal(api.actor("actor-1").discordUserId, null);
});
}
function assignmentGuardTests() {
test("linking needs a guild with a connected account and a linked campaign", async () => {
const connected = loadDiscordRoutes({ actors: [{ _id: "actor-1", name: "Katlum" }] });
assert.equal((await connected.call(ASSIGN, { body: { actorId: "actor-1", discordUserId: PLAYER } })).status, "ok");
const notLinked = loadDiscordRoutes({ guildLink: null });
assert.equal((await notLinked.call(ASSIGN, { body: { actorId: "actor-1", discordUserId: PLAYER } })).msg, "discord.errors.not-connected");
assert.equal((await notLinked.call(UNASSIGN, { body: { discordUserId: PLAYER } })).msg, "discord.errors.not-connected");
const noCampaign = loadDiscordRoutes({ campaign: null });
assert.equal((await noCampaign.call(ASSIGN, { body: { actorId: "actor-1", discordUserId: PLAYER } })).msg, "errors.notfound");
});
test("linking needs a whole player and one of the campaign's own characters", async () => {
const api = loadDiscordRoutes({ actors: [{ _id: "actor-1", name: "Katlum", campaign: "campaign-1" }] });
assert.equal((await api.call(ASSIGN, { body: { discordUserId: PLAYER } })).msg, "errors.missing-data");
assert.equal((await api.call(ASSIGN, { body: { actorId: "actor-1" } })).msg, "errors.missing-data");
assert.equal((await api.call(ASSIGN, { body: { actorId: "actor-1", discordUserId: "bob" } })).msg, "errors.missing-data");
assert.equal((await api.call(UNASSIGN, { body: {} })).msg, "errors.missing-data");
const otherCampaign = loadDiscordRoutes({ actors: [{ _id: "actor-9", name: "Stranger", campaign: "campaign-2" }] });
assert.equal((await otherCampaign.call(ASSIGN, { body: { actorId: "actor-9", discordUserId: PLAYER } })).msg, "errors.notfound");
});
test("the bot roster carries the player linked to each character", async () => {
const api = loadDiscordRoutes({
actors: [
{ _id: "actor-1", name: "Katlum", discordUserId: PLAYER },
{ _id: "actor-2", name: "Solus" }
]
});
const response = await api.call("GET /bot/guild/:guildId/actors");
assert.equal(response.status, "ok");
assert.deepEqual(response.actors.map((actor) => actor.discordUserId), [PLAYER, null]);
});
}
function botWiringTests() {
const commands = readRepoFile("discord-bot", "src", "commands.js");
const api = readRepoFile("discord-bot", "src", "dragonroll-api.js");
const bot = readRepoFile("discord-bot", "src", "index.js");
test("the dragonroll command carries assign and unassign with a character choice", () => {
assert.match(commands, /setName\('assign'\)[\s\S]*setName\('character'\)[\s\S]*setRequired\(true\)[\s\S]*setAutocomplete\(true\)/);
assert.match(commands, /setName\('unassign'\)[\s\S]*setName\('character'\)[\s\S]*setAutocomplete\(true\)/);
// The unassign character is optional, so a player can free their own without naming it.
const unassign = /setName\('unassign'\)([\s\S]*)$/.exec(commands)?.[1] ?? "";
assert.doesNotMatch(unassign, /setRequired\(true\)/);
});
test("the bot client calls the new routes and answers the new subcommands", () => {
assert.match(api, /\/actors\/assign/);
assert.match(api, /\/actors\/unassign/);
assert.match(bot, /\['assign', 'unassign'\]\.includes\(subcommand\)/);
assert.match(bot, /dragonroll\.assignActor\(guildId/);
assert.match(bot, /dragonroll\.unassignActor\(guildId/);
});
test("the character choices autocomplete both new subcommands", () => {
const autocomplete = /if \(interaction\.commandName === 'dragonroll'\) \{([\s\S]*?)\n \}\n/.exec(bot)?.[1] ?? "";
assert.match(autocomplete, /\['assign', 'unassign'\]\.includes\(subcommand\)/);
assert.match(autocomplete, /respondActorChoices\(interaction, guildId\)/);
});
test("the roster shows the player and the status card shows your character", () => {
assert.match(bot, /actor\.discordUserId \? ` 🎮 <@\$\{actor\.discordUserId\}>`/);
assert.match(bot, /name: 'Your character'/);
});
test("the actor model holds one Discord player per character and per campaign", () => {
const model = readRepoFile("backend", "src", "models", "Actor.js");
assert.match(model, /discordUserId: \{ type: String, default: null \}/);
assert.match(model, /\{ campaign: 1, discordUserId: 1 \},\s*\{ unique: true, partialFilterExpression: \{ discordUserId: \{ \$type: 'string' \} \} \}/);
});
}
assignmentRouteTests();
assignmentGuardTests();
botWiringTests();

564
tests/docs.test.js Normal file
View File

@@ -0,0 +1,564 @@
// Tests for the documentation under /docs (Syndria98/dragonroll#79): the markdown pages are the
// documentation, so what has to stay right is (1) the pages are well formed — a title, a slug, a
// 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
// checked against the sources that define it: the slash commands of discord-bot/src/commands.js and
// 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, 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
// is loaded straight from source, the way the other tests load the frontend services; it imports
// nothing, so the repository root's no-dependencies rule holds. `Docs.js` itself is not loaded: it
// reads the markdown through `import.meta.glob`, which only Vite can answer.
//
// 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");
function readRepoFile(...parts) {
return fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8");
}
function loadDocsMarkdown() {
const source = readRepoFile("frontend", "app", "services", "DocsMarkdown.js");
return vm.compileFunction(source.replace("export {", "return {") , [], {
parsingContext: vm.createContext({}),
})();
}
const docs = loadDocsMarkdown();
// The documentation pages, as the folder layout defines them.
const docsRoot = path.join(__dirname, "..", "frontend", "app", "content", "docs");
const docPages = fs.readdirSync(docsRoot, { withFileTypes: true })
.filter((entry) => entry.isDirectory())
.sort((left, right) => left.name.localeCompare(right.name))
.flatMap((group) => fs.readdirSync(path.join(docsRoot, group.name))
.filter((file) => file.endsWith(".md"))
.sort()
.map((file) => ({
group: group.name.replace(/^\d+-/, ""),
slug: file.replace(/^\d+-/, "").replace(/\.md$/, ""),
markdown: fs.readFileSync(path.join(docsRoot, group.name, file), "utf8"),
}))
);
const slugs = new Set(docPages.map((page) => page.slug));
const groups = [...new Set(docPages.map((page) => page.group))];
const pageAbout = (slug) => docPages.find((page) => page.slug === slug);
// --- The heading helpers the sidebar and the anchors are built from ---
test("a heading's slug comes out of its words, whatever form they arrive in", () => {
assert.equal(docs.Slugify("Link a world"), "link-a-world");
assert.equal(docs.Slugify(" Auto-sync, and one actor "), "auto-sync-and-one-actor");
assert.equal(docs.Slugify("Dragonroll: Force Sync!"), "dragonroll-force-sync");
});
test("the anchor built from a heading's markdown is the one built from its HTML", () => {
// The sidebar slugs the markdown source and the renderer slugs what marked produced, so the two
// have to land on the same anchor for a sidebar link to land on its section.
const pairs = [
["**Link** a `world`", "<strong>Link</strong> a <code>world</code>"],
["Commands & characters", "Commands &amp; characters"],
["[Foundry](/docs/foundry) worlds", '<a href="/docs/foundry">Foundry</a> worlds'],
["It's here", "It&#39;s here"],
];
for (const [markdown, html] of pairs) {
assert.equal(docs.Slugify(markdown), docs.Slugify(html), `slug of ${markdown}`);
}
});
test("repeated headings get distinct anchors, in the order they are written", () => {
const slug = docs.CreateHeadingSlugger();
assert.equal(slug("Setup"), "setup");
assert.equal(slug("setup"), "setup-1");
assert.equal(slug("Setup"), "setup-2");
});
test("the headings of a page are listed in order, with their anchors", () => {
const headings = docs.HeadingsFromMarkdown([
"# Connecting a service",
"",
"## How a connection works",
"text",
"### What it allows",
"```sh",
"# not a heading",
"```",
"## Next",
].join("\n"));
// The service is loaded from another realm, so the values are copied out before being compared.
assert.deepEqual(
JSON.parse(JSON.stringify(headings.map(({ depth, text, slug }) => ({ depth, text, slug })))),
[
{ depth: 1, text: "Connecting a service", slug: "connecting-a-service" },
{ depth: 2, text: "How a connection works", slug: "how-a-connection-works" },
{ depth: 3, text: "What it allows", slug: "what-it-allows" },
{ depth: 2, text: "Next", slug: "next" },
]
);
});
test("a page takes its title from its first heading", () => {
assert.equal(docs.TitleFromMarkdown("# Your first campaign\n\n## Signing in"), "Your first campaign");
assert.equal(docs.TitleFromMarkdown("no heading here"), "");
});
// --- The pages themselves ---
test("the documentation has pages, in numbered groups", () => {
assert.ok(docPages.length >= 5, `expected several documentation pages, found ${docPages.length}`);
for (const page of docPages) {
const folder = `${page.group}`;
assert.ok(folder.length > 0, `${page.slug} sits in an oddly named folder`);
assert.match(page.slug, /^[a-z0-9]+(-[a-z0-9]+)*$/, `${page.slug} is not a url-friendly slug`);
}
});
test("every page has a title, and no two pages share a slug", () => {
const seen = new Set();
for (const page of docPages) {
const title = docs.TitleFromMarkdown(page.markdown);
assert.ok(title, `${page.slug} has no heading to title it`);
assert.ok(!seen.has(page.slug), `${page.slug} is published twice`);
seen.add(page.slug);
}
assert.equal(seen.size, docPages.length);
});
test("every page has sections, which is what the sidebar lists beside it", () => {
for (const page of docPages) {
const sections = docs.HeadingsFromMarkdown(page.markdown).filter((heading) => heading.depth > 1);
assert.ok(sections.length, `${page.slug} has no section headings to list`);
}
});
test("every group has a sidebar label in every locale", () => {
const labels = ["en", "es", "ca"].map((locale) =>
JSON.parse(readRepoFile("frontend", "i18n", "locales", locale, "docs.json"))
);
assert.ok(labels.every((label) => label.groups), "each docs.json namespace needs a `groups` object");
for (const group of groups) {
for (const label of labels) {
const text = label.groups[group];
assert.ok(text, `the "${group}" group has no label in its docs.json`);
assert.notEqual(text, group, `the "${group}" label is untranslated`);
}
}
});
test("the pages only link to pages that are published", () => {
for (const page of docPages) {
for (const link of page.markdown.matchAll(/\]\((\/docs\/?[a-z0-9-]*)\)/g)) {
const target = link[1].replace("/docs/", "");
if (!target) continue; // /docs itself
assert.ok(slugs.has(target), `${page.slug} links to ${link[1]}, which is not published`);
}
}
});
test("the three integrations each have their own page", () => {
for (const slug of ["discord", "foundry", "obsidian"]) {
assert.ok(pageAbout(slug), `${slug} has no documentation page`);
}
assert.ok(pageAbout("connecting-a-service"), "the shared way of connecting a service is undocumented");
});
// --- The integrations pages describe what the integrations actually offer ---
// discord-bot/src/commands.js builds the slash commands with discord.js, which the repository root
// does not install: the builder is stubbed by one that records the names it is given.
function loadSlashCommands() {
const registered = [];
class Builder {
constructor() {
this.name = "";
this.parent = null;
this.children = [];
this.optionNames = [];
}
setName(name) { this.name = name; return this; }
setDescription() { return this; }
setContexts() { return this; }
setRequired() { return this; }
setMaxLength() { return this; }
setAutocomplete() { return this; }
addChoices() { return this; }
addStringOption(configure) { configure(new Builder()); return this; }
addBooleanOption(configure) { configure(new Builder()); return this; }
addSubcommand(configure) {
const sub = new Builder();
sub.parent = this;
configure(sub);
this.children.push(sub);
return this;
}
}
class SlashCommandBuilder extends Builder {
constructor() {
super();
registered.push(this);
}
}
const moduleStub = { exports: {} };
vm.compileFunction(readRepoFile("discord-bot", "src", "commands.js"), ["require", "module", "exports"])(
(id) => {
if (id === "discord.js") return { InteractionContextType: { Guild: 0 }, SlashCommandBuilder };
throw new Error(`require("${id}") is not stubbed`);
},
moduleStub,
moduleStub.exports
);
const names = [];
for (const command of registered) {
names.push(command.name);
for (const sub of command.children) names.push(`${command.name} ${sub.name}`);
}
return names;
}
test("the Discord page lists every command the bot declares", () => {
const about = pageAbout("discord");
const commands = loadSlashCommands();
// Sanity check on the stub before it is trusted to list anything.
assert.ok(commands.includes("characters"), `expected the bot's commands, got ${commands.join(", ")}`);
assert.ok(commands.includes("dragonroll connect"));
for (const command of commands) {
assert.ok(
about.markdown.includes("`/" + command),
`the Discord page does not document /${command}`
);
}
});
// The Obsidian plugin registers each command palette entry with `this.addCommand({ id, name, … })`.
function loadObsidianCommands() {
const source = readRepoFile("obsidian-plugin", "main.js");
const commands = [...source.matchAll(
/this\.addCommand\(\{\s*id:\s*["']([^"']+)["'],\s*name:\s*["']([^"']+)["']/g
)].map((match) => ({ id: match[1], name: match[2] }));
// Sanity check on the extraction before it is trusted to list anything.
assert.ok(commands.length >= 2, `expected the plugin's commands, got ${commands.length}`);
return commands;
}
test("the Obsidian page lists the commands the plugin registers", () => {
const about = pageAbout("obsidian");
for (const command of loadObsidianCommands()) {
assert.ok(
about.markdown.includes(`**${command.name}**`),
`the Obsidian page does not document "${command.name}" (${command.id})`
);
}
});
test("the Foundry page covers what the world and the campaign do with each other", () => {
const about = pageAbout("foundry").markdown;
for (const topic of ["Auto-sync", "Force Sync", "item directory", "Pairing Status"]) {
assert.ok(about.includes(topic), `the Foundry page never mentions ${topic}`);
}
});
// --- The routes ---
test("the app renders whichever page the address asks for", () => {
const root = readRepoFile("frontend", "app", "app.vue");
assert.match(root, /<NuxtPage\s*\/?>/, "app.vue has to render the matched page");
assert.doesNotMatch(root, /CreateWindow/, "the window app boots from AppShell, not from app.vue");
});
test("the documentation has a route of its own, and the app keeps the rest", () => {
const pages = path.join("frontend", "app", "pages");
const docsRoutes = ["docs/index.vue", "docs/[slug].vue"];
for (const route of docsRoutes) {
assert.match(
readRepoFile(pages, route),
/<DocsView\s*\/?>/,
`${route} has to render the documentation`
);
}
for (const route of ["index.vue", "[...all].vue"]) {
assert.match(
readRepoFile(pages, route),
/<AppShell\s*\/?>/,
`${route} has to open the window app`
);
}
// The catch-all is what keeps /link/authorize, and every path a service already links to, alive.
const shell = readRepoFile("frontend", "app", "components", "views", "AppShell.vue");
assert.ok(shell.includes("/link/authorize"), "the service link screen has to stay reachable");
assert.ok(shell.includes("/discord/authorize"), "the legacy Discord link has to stay reachable");
});
test("the main menu points at the documentation", () => {
const menu = readRepoFile("frontend", "app", "components", "windows", "MainMenuWindow.vue");
assert.match(menu, /href="\/docs"/, "the main menu has to link to /docs");
assert.match(menu, /main-menu\.documentation/);
for (const locale of ["en", "es", "ca"]) {
const strings = JSON.parse(readRepoFile("frontend", "i18n", "locales", locale, "main-menu.json"));
assert.ok(strings.documentation, `${locale} has no label for the documentation link`);
}
});
// Inside a campaign the documentation is reached from the top bar, on the left of the campaign
// settings button (Syndria98/dragonroll#90), and it opens as a window of its own in front of the
// workspace rather than as a trip to /docs (Syndria98/dragonroll#95).
test("the campaign top bar opens the documentation as a window", () => {
const topBar = readRepoFile("frontend", "app", "components", "viewer", "TopBar.vue");
const right = /<div class="right">([\s\S]*?)<\/div>/.exec(topBar)?.[1];
assert.ok(right, "expected the top bar to have its buttons in a right-hand group");
assert.match(right, /OpenDocumentation/, "the top bar has a button for the documentation");
assert.match(right, /main-menu\.documentation/, "under the same label the main menu uses");
assert.match(topBar, /CreateWindow\('documentation'\)/, "the button opens the documentation window");
// To the left of the settings button: the group is read left to right, so the button has to
// come first in it.
const docsAt = right.indexOf("OpenDocumentation");
const settingsAt = right.indexOf("OpenCampaignSettings");
assert.ok(
docsAt !== -1 && settingsAt !== -1 && docsAt < settingsAt,
"the documentation button sits on the left of the settings button"
);
// The open notes of the campaign live only in memory, so nothing the top bar does may leave
// the app: a window comes to the front, an address would take the campaign away with it.
assert.doesNotMatch(topBar, /href="\/docs"/, "the top bar does not send the campaign to /docs");
assert.doesNotMatch(topBar, /target="_blank"/, "…nor opens a tab out of it");
});
// The window the button opens (Syndria98/dragonroll#95): registered like every other window, and
// reading its pages without ever leaving the window it is drawn in.
test("the documentation is registered as a window", () => {
const definitions = readRepoFile("frontend", "app", "services", "WindowDefinitions.js");
const definition = /\n\s*documentation:\s*\{([\s\S]*?)\n\s{2}\}/.exec(definitions);
assert.ok(definition, "the documentation is not registered as a window");
assert.match(definition[1], /title:\s*'windows\.documentation'/, "its title is an i18n key");
assert.match(definition[1], /movable:\s*true/);
assert.match(definition[1], /close:\s*\(\)\s*=>\s*ClearWindow\(\{\s*type:\s*'documentation'\s*\}\)/);
const component = /component:\s*\(\)\s*=>\s*import\(['"]~\/components\/windows\/([^'"]+)['"]\)/.exec(definition[1]);
assert.ok(component, "the documentation window names no component of its own");
assert.ok(
fs.existsSync(path.join(__dirname, "..", "frontend", "app", "components", "windows", component[1])),
`the documentation window points at a component that does not exist: ${component[1]}`
);
});
test("the documentation window reads the published pages without leaving itself", () => {
const source = readRepoFile("frontend", "app", "components", "windows", "DocumentationWindow.vue");
// The pages are the ones of app/content/docs, read through the same service the /docs page uses.
assert.match(source, /from '~\/services\/Docs'/, "the window reads the documentation through the docs service");
for (const lookup of ["GetDocsNav", "GetDocsPage", "GetDocsFirstSlug"]) {
assert.match(source, new RegExp(lookup), `the window does not use ${lookup}`);
}
// Resizable, with a floor low enough to read the two columns on a small screen.
assert.match(source, /SetResizable\(id,\s*true\)/, "the window is resizable");
assert.match(source, /SetMinSize\(id,\s*\{\s*width:\s*\d+,\s*height:\s*\d+\s*\}\)/, "…and it says how small it goes");
// Nothing in it is a route: the window holds the page it shows, so following the sidebar
// leaves the campaign behind it exactly as it was.
assert.doesNotMatch(source, /NuxtLink|useRoute|navigateTo/, "the documentation window does not navigate the app");
// Which means the links the markdown carries (`[Foundry](/docs/foundry)`) and the sections of
// a page have to be answered inside the window.
assert.match(source, /\\\/docs/, "the markdown's links to the other pages are followed in the window");
assert.match(source, /scrollIntoView/, "so are the sections of the page it is showing");
assert.match(source, /preventDefault/, "…and none of them reaches the app's address");
// A window is not a page: the reading column is what scrolls, nothing is as tall as the viewport.
const reading = /\.docs-reading\s*\{[^}]*\}/.exec(source)?.[0];
assert.ok(reading, "the window has a reading column of its own");
assert.match(reading, /overflow-y:\s*auto/, "…and that is what scrolls");
assert.doesNotMatch(source, /100vh/, "a window fills itself, not the viewport");
});
test("the documentation window is titled in every locale", () => {
for (const locale of ["en", "es", "ca"]) {
const strings = JSON.parse(readRepoFile("frontend", "i18n", "locales", locale, "windows.json"));
const title = strings.documentation;
assert.ok(title, `${locale} has no title for the documentation window`);
if (locale !== "en") {
assert.notEqual(title.toLowerCase(), "documentation", `the ${locale} window title is untranslated`);
}
}
});
// --- How the documentation is laid out (Syndria98/dragonroll#85) ---
// The `<style>` of DocsView.vue read as `{ selector, media, declarations }` rules: the block is
// flat — every rule is a top level selector and the only nesting is the media queries — so pairing
// braces is enough, and the test does not need a stylesheet parser the repository root lacks.
function DocsStyleRules() {
const source = readRepoFile("frontend", "app", "components", "views", "DocsView.vue");
const css = source
.slice(source.indexOf(">", source.indexOf("<style")) + 1, source.indexOf("</style>"))
.replace(/\/\*[\s\S]*?\*\//g, "");
const rules = [];
function scan(text, media) {
let index = 0;
for (;;) {
const brace = text.indexOf("{", index);
if (brace === -1) return rules;
const selector = text.slice(index, brace).trim();
let depth = 1;
let cursor = brace + 1;
while (cursor < text.length && depth > 0) {
if (text[cursor] === "{") depth += 1;
else if (text[cursor] === "}") depth -= 1;
cursor += 1;
}
const body = text.slice(brace + 1, cursor - 1);
if (selector.startsWith("@")) scan(body, selector);
else rules.push({ selector, media, declarations: body });
index = cursor;
}
}
return scan(css, null);
}
const styleRules = DocsStyleRules();
// The rules that name a class, with `media` null for the plain ones and "min-width" / "max-width"
// for the ones a media query switches on. The last one wins where they overlap, as in a stylesheet.
function RulesFor(className, media = null) {
return styleRules.filter((rule) =>
rule.selector.split(",").some((name) => name.trim() === className) &&
(media === null ? rule.media === null : Boolean(rule.media) && rule.media.includes(media))
);
}
// A `padding:` shorthand spread over its four sides, the way the browser reads it.
function PaddingOf(rule) {
const shorthand = rule.declarations.match(/(?:^|[;\s])padding:\s*([^;]+)/);
assert.ok(shorthand, `the ${rule.selector} rule sets no padding to compare`);
const values = shorthand[1].trim().split(/\s+/).map((value) => parseFloat(value));
assert.ok(
values.length <= 4 && values.every((value) => Number.isFinite(value)),
`only px padding is compared here, ${rule.selector} has "${shorthand[1].trim()}"`
);
return {
top: values[0],
right: values[1] ?? values[0],
bottom: values[2] ?? values[0],
left: values[3] ?? values[1] ?? values[0],
};
}
test("the two asides are as tall as the page they stand beside", () => {
for (const className of [".docs-sidebar", ".docs-sections"]) {
const aside = RulesFor(className).find((rule) => /position:\s*sticky/.test(rule.declarations));
assert.ok(aside, `${className} has to stay beside the text while the page scrolls`);
assert.match(aside.declarations, /height:\s*100vh/, `${className} has to fill the page, not just its own contents`);
assert.doesNotMatch(aside.declarations, /max-height/, `${className} is capped at a screen height by 'height'`);
}
});
test("a narrow window stacks the columns and lets each one be its own height", () => {
const stacked = RulesFor(".docs-sidebar", "max-width");
assert.equal(stacked.length, 1, "the stacked layout is set by one rule");
assert.match(stacked[0].declarations, /position:\s*static/, "a stacked sidebar does not follow the scroll");
assert.match(stacked[0].declarations, /height:\s*auto/, "…and it is not held at a screen height either");
});
test("the reading column is centred in the space left beside the sidebar", () => {
const reading = RulesFor(".docs-article").find((rule) => /max-width:/.test(rule.declarations));
assert.ok(reading, "the text has to be capped in width to be readable");
assert.match(reading.declarations, /margin-inline:\s*auto/, "…and centred in the space left beside the sidebar");
assert.match(reading.selector, /\.docs-pager/, "the pager under the text follows the same column");
});
test("a very wide window keeps the sections next to the text, not at the edge of the screen", () => {
const centred = RulesFor(".docs", "min-width");
assert.equal(centred.length, 1, "one wide window rule centres the documentation");
assert.match(centred[0].declarations, /justify-content:\s*center/);
const wider = Number(centred[0].media.match(/min-width:\s*(\d+)/)[1]);
assert.ok(wider >= 1400, `${wider}px is not a wide window: the layout breaks before that`);
const main = RulesFor(".docs-main", "min-width");
assert.equal(main.length, 1, "the main column is capped once the window is wide");
assert.match(main[0].declarations, /flex:\s*0 1 \d+px/, "…so it stops growing and the sections sit next to it");
});
test("the sections aside has more room around its links than the sidebar has", () => {
const shared = RulesFor(".docs-sidebar").find((rule) => /padding:/.test(rule.declarations));
const sections = RulesFor(".docs-sections").filter((rule) => /padding:/.test(rule.declarations)).pop();
assert.ok(sections && sections !== shared, "the sections aside sets its own padding");
const room = PaddingOf(sections);
const sidebar = PaddingOf(shared);
for (const side of ["top", "right", "bottom", "left"]) {
assert.ok(room[side] >= sidebar[side], `the sections aside is tighter than the sidebar on the ${side}`);
}
assert.ok(
["top", "right", "bottom", "left"].some((side) => room[side] > sidebar[side]),
"the sections aside asks for more padding than the two asides share"
);
});
// The /docs page and the documentation window render the very same HTML, so the markdown it renders
// is styled once, in the stylesheet both of them load, rather than in whichever one asked for it
// first (Syndria98/dragonroll#95).
test("the rendered markdown is styled once, where both readers reach it", () => {
const styles = readRepoFile("frontend", "app", "assets", "css", "main.scss");
const markdown = styles.slice(styles.indexOf(".docs-markdown h1"));
for (const selector of [
".docs-markdown h1",
".docs-markdown h2",
".docs-markdown h3",
".docs-markdown p",
".docs-markdown a",
".docs-markdown code",
".docs-markdown pre",
".docs-markdown table",
]) {
assert.ok(markdown.includes(selector), `${selector} has to be styled for both readers of the docs`);
}
// Theme colours, as everywhere: the window and the page are read on either theme.
for (const colour of ["var\\(--color-border\\)", "var\\(--color-link\\)", "var\\(--color-background-light\\)"]) {
assert.match(markdown, new RegExp(colour), "the markdown's look uses the theme's colours");
}
});

View File

@@ -0,0 +1,386 @@
// Tests for the sidebar's "force import from Foundry" button (Syndria98/dragonroll#77):
// right-clicking an actor or an item offers to pull the whole actor list or item
// directory of the linked world over. The campaign asks its own backend, which reads
// the world's snapshot off the bridge and writes every document through the writers a
// sync push uses — so a row the campaign already holds is written over instead of
// imported a second time, and the answer counts the rows it made apart from the ones it
// wrote over, which is what the confirmation toast says.
//
// The repository root installs no dependencies, so nothing here is required the way the
// backend itself does it. The import route runs in a stubbed `require` against a fake
// bridge and fake writers, and those writers are then loaded for real and run against
// fake models, like tests/item-folder-sync.test.js does. The sidebar is a Vue component
// this repository cannot build, so its checks read the source, like
// tests/item-sheet-window.test.js does.
//
// 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 sidebarSource = read("frontend", "app", "components", "partials", "ContentSidebar.vue");
// --- The import route, against a fake bridge and fake writers ---------------------
const LINKED_CAMPAIGN = { _id: "campaign-1", id: "campaign-1", foundryWorldId: "world-1" };
// What the bridge answers for a whole list: the bridge wraps what the world published
// in `{status, data, world}`, and the route unwraps `data` again.
function bridgeSnapshot(data, world = { id: "world-1", title: "Curse of Strahd" }) {
return { status: 200, data: { status: "ok", data, world, syncedAt: "2026-10-15T10:00:00.000Z" } };
}
// The foundry route with every require stubbed. `campaign` is what the caller owns
// (`null` for a campaign that is not theirs), `answers` maps the bridge path to its
// answer — an Error stands for a bridge that cannot be reached — and `mapping` says
// what a world document becomes in the campaign: a new row or one it already had.
function loadImportRoute({
campaign = LINKED_CAMPAIGN,
answers = {},
mapping = () => ({ created: true }),
} = {}) {
const routes = new Map();
const router = {
get: (route, ...handlers) => routes.set(`GET ${route}`, handlers),
post: (route, ...handlers) => routes.set(`POST ${route}`, handlers),
};
const asked = { bridgePaths: [], campaignFilters: [] };
const written = { actors: [], items: [] };
const requireStub = (id) => {
if (id === "express") return { Router: () => router };
if (id === "../services/foundry") {
return {
requestFoundry: async (bridgePath) => {
asked.bridgePaths.push(bridgePath);
const answer = answers[bridgePath];
if (answer instanceof Error) throw answer;
// A bridge with nothing to answer is one no GM client has published to.
return answer ?? { status: 503, data: { status: "error", msg: "foundry.not-ready" } };
},
};
}
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (id === "../models/Campaign") {
return {
findOne: (filter) => {
asked.campaignFilters.push(filter);
const query = { select: () => query, lean: () => Promise.resolve(campaign ?? null) };
return query;
},
};
}
if (id === "./foundry-link") {
return {
saveFoundryActor: async (own, source) => { written.actors.push(source); return mapping(source); },
saveFoundryItem: async (own, source) => { written.items.push(source); return mapping(source); },
};
}
throw new Error(`require("${id}") is not stubbed`);
};
const moduleStub = { exports: {} };
vm.compileFunction(read("backend", "src", "routes", "foundry.js"), ["require", "module", "exports"])(
requireStub, moduleStub, moduleStub.exports
);
async function importFrom(body, user = { id: "user-1" }) {
const handlers = routes.get("POST /import");
assert.ok(handlers, "POST /import is not mounted");
const res = { payload: null, json(payload) { this.payload = payload; } };
await handlers[handlers.length - 1]({ body, user }, res);
return res.payload;
}
return { importFrom, asked, written };
}
const TWO_ACTORS = [
{ _id: "actor-1", name: "Thalia", type: "character" },
{ _id: "actor-2", name: "Grimnir", type: "npc" },
];
test("the import pulls the world's actors and counts them new against updated", async () => {
const route = loadImportRoute({
answers: { "api/actors": bridgeSnapshot(TWO_ACTORS) },
mapping: (source) => ({ created: source._id === "actor-2" }),
});
const response = await route.importFrom({ campaign: "campaign-1", kind: "actors" });
assert.deepEqual(route.asked.bridgePaths, ["api/actors"], "the actors are read off the bridge");
assert.deepEqual(route.asked.campaignFilters[0], { _id: "campaign-1", createdBy: "user-1" },
"only the campaign the caller holds is imported");
assert.deepEqual(route.written.actors.map((source) => source.name), ["Thalia", "Grimnir"]);
assert.deepEqual(response, { status: "ok", kind: "actors", imported: 1, updated: 1 });
});
test("the item import pulls the world's item directory", async () => {
const route = loadImportRoute({
answers: { "api/items": bridgeSnapshot([{ _id: "item-1", name: "Longsword", type: "weapon" }]) },
});
const response = await route.importFrom({ campaign: "campaign-1", kind: "items" });
assert.deepEqual(route.asked.bridgePaths, ["api/items"], "the bridge's world items, not its actors");
assert.equal(route.written.items.length, 1);
assert.equal(route.written.actors.length, 0);
assert.deepEqual(response, { status: "ok", kind: "items", imported: 1, updated: 0 });
});
test("only the actor and item lists can be imported", async () => {
for (const kind of [undefined, "maps", "notes", "everything"]) {
const route = loadImportRoute();
const response = await route.importFrom({ campaign: "campaign-1", kind });
assert.equal(response.msg, "errors.missing-data", `"${kind}" is not a list to import`);
assert.deepEqual(route.asked.bridgePaths, [], "nothing is asked of the bridge for it");
}
});
test("a campaign the caller does not hold is not imported", async () => {
const route = loadImportRoute({ campaign: null });
const response = await route.importFrom({ campaign: "someone-elses-campaign", kind: "actors" });
assert.equal(response.msg, "errors.notfound");
assert.deepEqual(route.asked.bridgePaths, [], "the bridge is not asked for somebody else's world");
});
test("a campaign with no linked world is told so, and nothing is written", async () => {
const route = loadImportRoute({ campaign: { _id: "campaign-1" } });
const response = await route.importFrom({ campaign: "campaign-1", kind: "items" });
assert.equal(response.msg, "foundry.errors.import-not-linked");
assert.deepEqual(route.asked.bridgePaths, []);
assert.deepEqual(route.written.items, []);
});
test("another world's snapshot is not written into the campaign", async () => {
const route = loadImportRoute({
answers: { "api/actors": bridgeSnapshot(TWO_ACTORS, { id: "world-2", title: "Another World" }) },
});
const response = await route.importFrom({ campaign: "campaign-1", kind: "actors" });
assert.equal(response.msg, "foundry.errors.import-world-mismatch");
assert.deepEqual(route.written.actors, [], "the bridge keeps one world's snapshot at a time");
});
test("a bridge that is not there says so instead of importing nothing", async () => {
const notSetUp = loadImportRoute({
answers: { "api/actors": Object.assign(new Error("Foundry API is not configured."), { code: "FOUNDRY_NOT_CONFIGURED" }) },
});
const unreachable = loadImportRoute({ answers: { "api/actors": new Error("ECONNREFUSED") } });
const noSnapshotYet = loadImportRoute(); // answers nothing → the bridge's own 503
for (const route of [notSetUp, unreachable, noSnapshotYet]) {
const response = await route.importFrom({ campaign: "campaign-1", kind: "actors" });
assert.equal(response.msg, "foundry.errors.import-unavailable");
assert.deepEqual(route.written.actors, []);
}
});
test("a world document that maps to nothing is not counted", async () => {
const route = loadImportRoute({
answers: { "api/items": bridgeSnapshot([
{ _id: "item-1", name: "Longsword", type: "weapon" },
{ _id: "spell-1", name: "Magic Missile", type: "spell" },
]) },
// what is not gear maps to nothing, exactly like a sync push skips it
mapping: (source) => (source.type === "spell" ? null : { created: true }),
});
const response = await route.importFrom({ campaign: "campaign-1", kind: "items" });
assert.equal(route.written.items.length, 2, "every world document is offered to the writer");
assert.deepEqual(response, { status: "ok", kind: "items", imported: 1, updated: 0 });
});
// --- The writers, against fake models: existing rows are written over, not doubled ---
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, $or and $exists.
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 route loaded for its writers: the same functions the world's pushes and the
// campaign's import run through, here against rows the campaign already holds.
function loadFoundryWriters({ seed = {} } = {}) {
const campaign = { _id: "campaign-1", id: "campaign-1", foundryWorldId: "world-1" };
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"));
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("the writers a sync push uses are the ones an import writes through", () => {
const { writers } = loadFoundryWriters();
assert.equal(typeof writers.saveFoundryActor, "function");
assert.equal(typeof writers.saveFoundryItem, "function");
});
test("an imported actor the campaign already has is written over, not made again", async () => {
const sync = loadFoundryWriters({
seed: { actors: [{ _id: "actor-1", name: "Thalia the old", foundryActorId: "actor-1", level: 1 }] },
});
const worldActor = { _id: "actor-1", name: "Thalia", type: "character", system: { details: { level: 3 } } };
const first = await sync.writers.saveFoundryActor(sync.campaign, worldActor);
const second = await sync.writers.saveFoundryActor(sync.campaign, worldActor);
assert.equal(sync.models["../models/Actor"].rows.length, 1, "the world's actor stands in one row");
assert.equal(first.created, false, "the row was already there");
assert.equal(second.created, false);
assert.equal(sync.models["../models/Actor"].rows[0].name, "Thalia", "a force import writes the world over the row");
assert.equal(sync.models["../models/Actor"].rows[0].level, 3);
});
test("an actor the world has never been seen as becomes one row, and the next import updates it", async () => {
const sync = loadFoundryWriters();
const worldActor = { _id: "actor-9", name: "Grimnir", type: "npc", system: { details: { cr: 2 } } };
const made = await sync.writers.saveFoundryActor(sync.campaign, worldActor);
const again = await sync.writers.saveFoundryActor(sync.campaign, worldActor);
assert.equal(made.created, true, "the first import makes the row");
assert.equal(again.created, false, "the one after it only writes it over");
assert.equal(sync.models["../models/Actor"].rows.length, 1);
assert.equal(sync.models["../models/Actor"].rows[0].foundryActorId, "actor-9");
});
test("a hand-made item folds into the import instead of doubling, and keeps being updated", async () => {
const sync = loadFoundryWriters({
seed: { items: [{ _id: "item-1", name: "Longsword", quantity: 1 }] },
});
const worldItem = { _id: "sword-9", name: "Longsword", type: "weapon", system: { quantity: 4, weight: 3, rarity: "rare" } };
const made = await sync.writers.saveFoundryItem(sync.campaign, worldItem);
const again = await sync.writers.saveFoundryItem(sync.campaign, worldItem);
const rows = sync.models["../models/Item"].rows;
assert.equal(rows.length, 1, "the campaign's own row is the world item's row");
assert.equal(made.created, false, "adopting a row the campaign made is not importing it new");
assert.equal(again.created, false);
assert.equal(rows[0].foundryItemId, "sword-9");
assert.equal(rows[0].quantity, 4, "and the force import writes the world over it");
assert.equal(rows[0].rarity, "rare");
});
// --- The sidebar: the button, and the toast it leaves behind ----------------------
const entryMenu = /function showEntryMenu[\s\S]*?\n\}/.exec(sidebarSource)?.[0] ?? "";
const importer = /async function forceImportFromFoundry[\s\S]*?\n\}/.exec(sidebarSource)?.[0] ?? "";
test("the actor and item rows offer a force import in their right-click menu", () => {
assert.ok(entryMenu, "the sidebar has an entry menu");
assert.match(entryMenu, /if \(entityType === ['"]actor['"] \|\| entityType === ['"]item['"]\)/,
"the offer belongs to the two lists mirroring a world, not the maps");
assert.match(entryMenu, /t\(['"]campaigns\.foundry-import\.run['"]\)/);
assert.match(entryMenu, /action: \(\) => \{ HideContextMenu\(\); forceImportFromFoundry\(entityType\); \}/);
});
test("the import is asked for once, says what landed, and reads the list back", async () => {
assert.ok(importer, "the sidebar has the import");
assert.match(importer, /if \(!campaignId\.value \|\| !section \|\| importingFoundry\.value\) return;/,
"clicking a row again while the world is on its way does not start a second import");
assert.match(importer, /Server\(\)\.post\(['"]\/foundry\/import['"], \{ campaign: campaignId\.value, kind: section \}\)/);
assert.match(importer, /DisplayToast\(['"]green['"], t\(['"]campaigns\.foundry-import\.done['"]/);
assert.match(importer, /imported: response\.data\.imported \?\? 0/);
assert.match(importer, /updated: response\.data\.updated \?\? 0/);
assert.match(importer, /await fetchCampaignEntries\(section\)/, "what arrived is read back into the list");
// the failed import says what the backend said, the way the other windows do
assert.match(importer, /DisplayToast\(['"]red['"], t\(response\.data\.msg \|\| ['"]campaigns\.foundry-import\.error['"]\)/);
});
test("every locale has the strings of the button, its toast and its errors", () => {
for (const locale of ["en", "es", "ca"]) {
const campaigns = JSON.parse(read("frontend", "i18n", "locales", locale, "campaigns.json"));
for (const key of ["run", "done", "error"]) {
assert.ok(campaigns["foundry-import"]?.[key], `${locale} is missing campaigns.foundry-import.${key}`);
}
const foundry = JSON.parse(read("frontend", "i18n", "locales", locale, "foundry.json"));
for (const key of ["import-not-linked", "import-unavailable", "import-world-mismatch"]) {
assert.ok(foundry.errors?.[key], `${locale} is missing foundry.errors.${key}`);
}
}
});

View File

@@ -0,0 +1,239 @@
// Tests for Syndria98/dragonroll#65: picking an item's icon opens a window that asks
// where the icon comes from — upload one from this device, or load one from the icon
// library the linked Foundry world ships in its data directory's `icons/` folder.
// That library runs into the thousands, so it is listed one folder per request, with
// its icons paged and its thumbnails lazy to load.
//
// The icon listing helpers are a pure CommonJS service, so they are required and called
// directly. The windows and the bridge live in files this repository installs no
// dependencies for, so those checks read the sources, like tests/map-viewer.test.js does.
//
// 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 iconService = require(path.join(__dirname, "..", "backend", "src", "services", "foundry-icons"));
const foundryService = require(path.join(__dirname, "..", "backend", "src", "services", "foundry"));
const http = require("node:http");
const windowDefsSource = read("frontend", "app", "services", "WindowDefinitions.js");
const itemWindowSource = read("frontend", "app", "components", "windows", "ItemSheetWindow.vue");
const sourceWindowSource = read("frontend", "app", "components", "windows", "ItemIconSourceWindow.vue");
const foundryIconsSource = read("frontend", "app", "components", "windows", "FoundryIconPickerWindow.vue");
const foundryRouteSource = read("backend", "src", "routes", "foundry.js");
const bridgeSource = read("dragonroll-foundry", "bridge", "server.js");
// --- The listing service: what the browser may ask for, and what it gets back ------
test("icon listings always stay inside Foundry's icon root", () => {
assert.equal(iconService.ICON_ROOT, "icons");
assert.equal(iconService.normalizeIconDirectory(""), "icons");
assert.equal(iconService.normalizeIconDirectory(undefined), "icons");
assert.equal(iconService.normalizeIconDirectory("/icons/svg/"), "icons/svg");
assert.equal(iconService.normalizeIconDirectory("icons/sfdcc/axes"), "icons/sfdcc/axes");
assert.equal(iconService.normalizeIconDirectory("icons/./svg"), "icons/svg");
// nothing that leaves `icons/` is a folder this route will list
assert.equal(iconService.normalizeIconDirectory("icons/../secret"), null);
assert.equal(iconService.normalizeIconDirectory("../etc"), null);
assert.equal(iconService.normalizeIconDirectory("systems/dnd5e/icons"), null);
assert.equal(iconService.parentIconDirectory("icons/svg/axes"), "icons/svg");
assert.equal(iconService.parentIconDirectory("icons"), null);
});
test("icons are listed a page at a time, bounded", () => {
assert.deepEqual(iconService.readIconListingPage({}), { limit: iconService.DEFAULT_ICON_PAGE_SIZE, offset: 0 });
assert.deepEqual(iconService.readIconListingPage({ limit: "20", offset: "240" }), { limit: 20, offset: 240 });
// a caller cannot ask for the whole library at once, or for a page before the first
assert.equal(iconService.readIconListingPage({ limit: "99999" }).limit, iconService.MAX_ICON_PAGE_SIZE);
assert.equal(iconService.readIconListingPage({ offset: "-10" }).offset, 0);
});
test("only image files become icons, and they load from the world's own address", () => {
const listing = iconService.shapeIconListing({
base: "https://vtt.example.com/",
dir: "icons/svg",
listing: {
directories: ["icons/svg/creature", "icons/svg/creature", "icons/svg"],
files: ["icons/svg/dice.svg", "icons/svg/sword.png", "icons/svg/readme.txt", "stray.md"],
offset: 0,
next: 120,
},
});
assert.equal(listing.dir, "icons/svg");
assert.equal(listing.parent, "icons");
assert.deepEqual(listing.folders.map((folder) => folder.path), ["icons/svg/creature"]);
assert.deepEqual(listing.folders.map((folder) => folder.name), ["creature"]);
assert.deepEqual(listing.files.map((icon) => icon.path), ["icons/svg/dice.svg", "icons/svg/sword.png"]);
assert.equal(listing.files[0].name, "dice.svg");
assert.equal(listing.files[0].url, "https://vtt.example.com/icons/svg/dice.svg");
assert.equal(listing.next, 120);
});
test("an icon path with spaces still gives the browser a loadable url", () => {
assert.equal(
iconService.joinFoundryAssetUrl("http://vtt.test:30000", "icons/sfdcc/axes/halberd sword.svg"),
"http://vtt.test:30000/icons/sfdcc/axes/halberd%20sword.svg"
);
assert.equal(iconService.joinFoundryAssetUrl("", "icons/svg/dice.svg"), "");
});
// --- The backend route ------------------------------------------------------------
test("the foundry proxy lists one icon folder for one of the caller's campaigns", () => {
assert.match(foundryRouteSource, /router\.get\(["']\/icons["'], async \(req, res\)/);
const route = /router\.get\(["']\/icons[\s\S]*?module\.exports/.exec(foundryRouteSource)?.[0] ?? foundryRouteSource;
// the campaign is where the world address is kept, so it has to be the caller's own
assert.match(route, /findOwnedCampaign\(req\.query\.campaign, req\.user\.id\)/);
assert.match(foundryRouteSource, /Campaign\.findOne\(\{\s*_id:\s*campaignId,\s*createdBy:\s*userId\s*\}\)/);
assert.match(route, /campaign\.settings\?\.integrations\?\.foundryUrl/);
assert.match(route, /requestFoundry\(`api\/icons\?\$\{query\}`\)/);
// a folder outside the icon root is refused before it reaches the Foundry host
assert.match(route, /const dir = normalizeIconDirectory\(req\.query\.dir\);/);
});
// --- The bridge on the Foundry host ------------------------------------------------
test("the bridge lists a core icon folder and never leaves the icon root", () => {
assert.match(bridgeSource, /const dataPath = \(process\.env\.DRAGONROLL_FOUNDRY_DATA_PATH \|\| ""\)\.trim\(\);/);
assert.match(bridgeSource, /if \(pathname === "\/api\/icons"\) return sendIconListing\(request, response\);/);
assert.match(bridgeSource, /if \(!dataPath\) return sendJson\(response, 503, \{ status: "error", msg: "foundry\.errors\.icons-unavailable" \}\);/);
const normalize = /function normalizeIconDirectory\(input\) \{[\s\S]*?\n\}/.exec(bridgeSource)?.[0] ?? "";
assert.match(normalize, /segments\.includes\("\.\."\) \|\| segments\[0\] !== iconRoot/);
// the answer is one folder plus the offset of the next page of its icons
assert.match(bridgeSource, /directories\.sort\(\(a, b\) => a\.localeCompare\(b\)\);/);
assert.match(bridgeSource, /const page = files\.slice\(offset, offset \+ limit\);/);
assert.match(bridgeSource, /next: offset \+ page\.length < files\.length \? offset \+ page\.length : null,/);
});
// --- The windows -------------------------------------------------------------------
test("choosing an icon opens its own window from the item sheet", () => {
assert.match(windowDefsSource, /item_icon_source:\s*{\s*title:[^}]*ItemIconSourceWindow\.vue/s);
assert.match(windowDefsSource, /foundry_icons:\s*{\s*title:[^}]*FoundryIconPickerWindow\.vue/s);
// the item window asks where the icon comes from instead of opening a file dialog
assert.match(itemWindowSource, /CreateChildWindow\(id, ['"]item_icon_source['"]/);
assert.doesNotMatch(itemWindowSource, /type="file"/);
});
test("the icon source window offers uploading and Foundry, and uploads the local file", () => {
assert.match(sourceWindowSource, /\$t\(['"]campaigns\.item\.icon-picker\.upload['"]\)/);
assert.match(sourceWindowSource, /\$t\(['"]campaigns\.item\.icon-picker\.foundry['"]\)/);
// upload: a local file, sent through the item route like the character sheet does its photo
assert.match(sourceWindowSource, /type="file" accept="image\/\*"/);
assert.match(sourceWindowSource, /\/item\/upload-image\?item=\$\{itemId\}/);
assert.match(sourceWindowSource, /formData\.append\(['"]image['"], file\)/);
// and it hands the item over to the icon browser, as its child window
assert.match(sourceWindowSource, /CreateChildWindow\(id, ['"]foundry_icons['"]/);
});
test("the icon browser browses the world's icons folder by folder", () => {
assert.match(foundryIconsSource, /\/foundry\/icons\?\$\{params\.toString\(\)\}/);
// one folder per request: navigating a folder asks for it, and going up asks for its parent
assert.match(foundryIconsSource, /Load\(ICON_ROOT\)/);
assert.match(foundryIconsSource, /@click="Load\(folder\.path\)"/);
assert.match(foundryIconsSource, /Load\(listing\.value\.parent \|\| ICON_ROOT\)/);
// lazy in every way that matters: a page of icons at a time, thumbnails fetched when seen
assert.match(foundryIconsSource, /if \(offset\) params\.set\(['"]offset['"], String\(offset\)\)/);
assert.match(foundryIconsSource, /@click="Load\(listing\.dir, listing\.next\)"/);
assert.match(foundryIconsSource, /loading="lazy"/);
// picking an icon stores the world's url and tells the item window about it
assert.match(foundryIconsSource, /Server\(\)\.post\(['"]\/item\/update['"], \{ id: itemId, image: icon\.url \}\)/);
assert.match(foundryIconsSource, /emitter\.emit\(['"]campaign-entry-updated['"], \{ entityType: ['"]item['"], entry: response\.data\.item \}\)/);
assert.match(foundryIconsSource, /ClearWindow\(\{ type: ['"]item_icon_source['"] \}\)/);
});
// --- The bridge the backend reads the icon library through (issue #74) --------
//
// The icon window reaches the world's `icons/` folder through the backend, which
// in turn reads the bridge that the world already pushes its snapshot to. When
// that push works the campaign reads as connected, so a read that still reports
// the bridge as unset is the bug this guards against.
// Set the bridge environment for one call and put it back exactly as it was.
function withBridgeEnv(env, run) {
const keys = ["FOUNDRY_API_URL", "FOUNDRY_API_CLIENT_URL", "FOUNDRY_API_TOKEN"];
const saved = Object.fromEntries(keys.map((key) => [key, process.env[key]]));
for (const key of keys) {
if (env[key] === undefined) delete process.env[key];
else process.env[key] = env[key];
}
return Promise.resolve()
.then(run)
.finally(() => {
for (const key of keys) {
if (saved[key] === undefined) delete process.env[key];
else process.env[key] = saved[key];
}
});
}
test("a connected world answers icon reads through the bridge set under the client URL", async () => {
// A world that connects and syncs is often configured with FOUNDRY_API_CLIENT_URL
// alone — the address its own client reaches. The backend read falls back to it,
// so the icon window is not told its bridge is unset while the world is right there.
const answers = [];
const bridge = http.createServer((request, response) => {
answers.push(request.url);
response.writeHead(200, { "Content-Type": "application/json" });
response.end(JSON.stringify({ status: "ok", dir: "icons", directories: ["icons/svg"], files: [], offset: 0, next: null }));
});
await new Promise((resolve) => bridge.listen(0, "127.0.0.1", resolve));
const clientUrl = `http://127.0.0.1:${bridge.address().port}/`;
try {
const result = await withBridgeEnv(
{ FOUNDRY_API_URL: undefined, FOUNDRY_API_CLIENT_URL: clientUrl, FOUNDRY_API_TOKEN: "read-token" },
() => foundryService.requestFoundry("api/icons?dir=icons&offset=0&limit=120"),
);
assert.equal(result.status, 200);
assert.equal(result.data.status, "ok");
assert.equal(answers.length, 1);
assert.match(answers[0], /^\/api\/icons\?/);
} finally {
await new Promise((resolve) => bridge.close(resolve));
}
});
test("without a bridge under either name a read says it is not configured", async () => {
const error = await withBridgeEnv(
{ FOUNDRY_API_URL: undefined, FOUNDRY_API_CLIENT_URL: undefined, FOUNDRY_API_TOKEN: undefined },
() => foundryService.requestFoundry("api/icons?dir=icons").then(() => null, (err) => err),
);
assert.equal(error?.code, "FOUNDRY_NOT_CONFIGURED");
});
test("the icon window says what actually failed instead of always blaming the bridge", () => {
// axios rejects a non-2xx answer, so the catch reads the route's own i18n key
// off the response: a campaign with no world address is told as much rather
// than as a bridge that is not set up.
assert.match(foundryIconsSource, /requestError\.response\?\.data\?\.msg/);
assert.match(foundryIconsSource, /requestError\.response\?\.data\?\.msg \|\| ['"]foundry\.errors\.icons-unavailable['"]/);
});
// --- Strings -----------------------------------------------------------------------
test("every locale names the icon windows and their controls", () => {
for (const locale of ["en", "es", "ca"]) {
const windows = JSON.parse(read("frontend", "i18n", "locales", locale, "windows.json"));
for (const key of ["icon-source", "foundry-icons"]) {
assert.ok(windows[key], `${locale} is missing the ${key} window title`);
}
const campaigns = JSON.parse(read("frontend", "i18n", "locales", locale, "campaigns.json"));
for (const key of ["intro", "upload", "upload-hint", "foundry", "foundry-hint"]) {
assert.ok(campaigns.item?.["icon-picker"]?.[key], `${locale} is missing campaigns.item.icon-picker.${key}`);
}
const foundry = JSON.parse(read("frontend", "i18n", "locales", locale, "foundry.json"));
for (const key of ["loading", "empty", "load-more", "up"]) {
assert.ok(foundry.icons?.[key], `${locale} is missing foundry.icons.${key}`);
}
for (const key of ["icons-unavailable", "icons-no-world-url"]) {
assert.ok(foundry.errors?.[key], `${locale} is missing foundry.errors.${key}`);
}
}
});

View File

@@ -1,7 +1,9 @@
// Tests for item folders following the Foundry world into the campaign // Tests for item folders following the Foundry world into the campaign
// (Syndria98/dragonroll#44): the world's item directory is grouped into folders, and // (Syndria98/dragonroll#44): the world's item directory is grouped into folders, and
// Dragonroll mirrors that tree as Folders of target 'item' and files the synced items // Dragonroll mirrors that tree as Folders of target 'item' and files the synced items
// in them, so its item list reads like the world's. // in them, so its item list reads like the world's. And for those folders' colours
// going both ways (Syndria98/dragonroll#57): the world's colour arrives with its tree,
// and the one the campaign picks travels back on the folder list the module reads.
// //
// The repository root installs no dependencies, so each side is loaded the way the // The repository root installs no dependencies, so each side is loaded the way the
// other tests do it. The sync route runs against a stubbed `require` (express, // other tests do it. The sync route runs against a stubbed `require` (express,
@@ -122,21 +124,24 @@ function loadSyncRoute({ seed = {}, worldId = "world-1" } = {}) {
post: (route, ...handlers) => routes.set(`POST ${route}`, handlers), post: (route, ...handlers) => routes.set(`POST ${route}`, handlers),
}; };
const campaign = { _id: "campaign-1", id: "campaign-1", name: "Test Campaign", foundryWorldId: worldId }; const campaign = { _id: "campaign-1", id: "campaign-1", name: "Test Campaign", foundryWorldId: worldId };
// Every row belongs to the campaign the sync token belongs to, like every real row
// does: the sync looks its rows up by campaign, so a seeded row without one would be
// invisible to it and a test would pass without touching what it means to check.
const seeded = (rows = []) => rows.map((row) => ({ campaign: campaign._id, ...row }));
const models = { const models = {
"../models/Actor": fakeModel("actor", seed.actors, campaign.id), "../models/Actor": fakeModel("actor", seeded(seed.actors)),
"../models/Item": fakeModel("item", seed.items, campaign.id), "../models/Item": fakeModel("item", seeded(seed.items)),
"../models/Folder": fakeModel("folder", seed.folders, campaign.id), "../models/Folder": fakeModel("folder", seeded(seed.folders)),
}; };
const requireStub = (id) => { const requireStub = (id) => {
if (id === "express") return { Router: () => router }; if (id === "express") return { Router: () => router };
// The route hashes the sync token with node's own crypto: the real module costs nothing if (id.startsWith("node:")) return require(id); // crypto: the sync token is hashed, not stubbed
// to hand it, and nothing here depends on what the hash looks like.
if (id === "node:crypto") return require("node:crypto");
if (id === "mongoose") return { isValidObjectId: (value) => typeof value === "string" && value.length > 20 }; if (id === "mongoose") return { isValidObjectId: (value) => typeof value === "string" && value.length > 20 };
if (id === "../models/Campaign") return { findOne: async () => campaign }; if (id === "../models/Campaign") return { findOne: async () => campaign };
if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) }; if (id === "../services/actor-foundry") return { foundryActorToCharacter: (actor) => ({ name: actor?.name ?? "" }) };
if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js")); if (id === "../services/item-foundry") return repoRequire(path.join("backend", "src", "services", "item-foundry.js"));
if (id === "../services/foundry-icons") return repoRequire(path.join("backend", "src", "services", "foundry-icons.js"));
if (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`);
}; };
@@ -295,6 +300,144 @@ test("an item the world moved out of a folder follows it to the root", async ()
assert.equal(sync.models["../models/Item"].rows[0].folder, null); assert.equal(sync.models["../models/Item"].rows[0].folder, null);
}); });
// --- Only the world's item directory is listed (Syndria98/dragonroll#67) --------------
// The campaign's item list equals the world's items tab: gear that only an actor
// carries is its inventory (kept on the actor document), not a Dragonroll item.
test("an actor's gear is kept off the campaign's item list", async () => {
const sync = loadSyncRoute();
await sync.call("POST /sync/snapshot", {
worldId: "world-1",
items: [worldItem()],
// Thalia carries a potion the world's item directory does not hold.
actors: [{
_id: "actor-1",
name: "Thalia",
items: [{ _id: "potion-1", name: "Potion of Healing", type: "consumable", system: { quantity: 2 } }],
}],
});
const names = sync.models["../models/Item"].rows.map((row) => row.name);
assert.deepEqual(names, ["Longsword"], "only the world's item reaches the list, not the actor's potion");
});
test("the campaign's item list is the world's whole item directory", async () => {
const sync = loadSyncRoute();
await sync.call("POST /sync/snapshot", {
worldId: "world-1",
items: [worldItem(), worldItem({ _id: "item-2", name: "Torch", type: "loot", system: { quantity: 1 } })],
actors: [],
});
assert.deepEqual(
sync.models["../models/Item"].rows.map((row) => row.name).sort(),
["Longsword", "Torch"],
);
});
test("an item carried by a character is listed once, as its world entry", async () => {
const sync = loadSyncRoute();
await sync.call("POST /sync/snapshot", {
worldId: "world-1",
items: [worldItem()],
// The same sword, a second copy embedded in an actor under another id.
actors: [{ _id: "actor-1", name: "Thalia", items: [worldItem({ _id: "sword-copy" })] }],
});
assert.deepEqual(sync.models["../models/Item"].rows.map((row) => row.name), ["Longsword"]);
});
test("a full snapshot prunes gear that only an actor carried", async () => {
const sync = loadSyncRoute({
seed: { items: [{ _id: "potion-1", name: "Potion of Healing", foundryItemId: "embedded-1" }] },
});
// The world's item directory is now empty: nothing but a character holds the potion.
await sync.call("POST /sync/snapshot", {
worldId: "world-1",
items: [],
actors: [{
_id: "actor-1",
name: "Thalia",
items: [{ _id: "embedded-1", name: "Potion of Healing", type: "consumable", system: { quantity: 2 } }],
}],
fullSync: true,
});
assert.deepEqual(sync.models["../models/Item"].rows, [], "the actor's own gear no longer stands in the item list");
});
test("a folder coloured in the world is coloured in the campaign", async () => {
const sync = loadSyncRoute();
await sync.call("POST /sync/item-snapshot", {
worldId: "world-1",
items: [],
folders: [{ id: "folder-melee", name: "Melee Weapons", parent: null, color: "#7f00ff" }],
});
assert.equal(sync.models["../models/Folder"].rows[0].color, "#7f00ff");
});
test("a folder the world leaves uncoloured takes the campaign's colour off", async () => {
const sync = loadSyncRoute({
seed: {
folders: [{ _id: "folder-1", target: "item", foundryFolderId: "folder-melee", name: "Melee Weapons", color: "#7f00ff" }],
},
});
await sync.call("POST /sync/item-snapshot", {
worldId: "world-1",
items: [],
folders: [{ id: "folder-melee", name: "Melee Weapons", parent: null, color: null }],
});
assert.equal(sync.models["../models/Folder"].rows[0].color, null, "the world has no colour to show, so neither does the campaign");
});
test("a module that says nothing about colours leaves the campaign's colour alone", async () => {
const sync = loadSyncRoute({
seed: {
folders: [{ _id: "folder-1", target: "item", foundryFolderId: "folder-melee", name: "Melee Weapons", color: "#7f00ff" }],
},
});
// A tree pushed by a module that knows folders but not their colours: no colour at all.
await sync.call("POST /sync/snapshot", {
worldId: "world-1",
actors: [],
items: [],
folders: [{ id: "folder-melee", name: "Melee Weapons", parent: null }],
});
assert.equal(sync.models["../models/Folder"].rows[0].color, "#7f00ff");
});
test("the folder list the world reads back carries the colours the campaign picked", async () => {
const sync = loadSyncRoute({
seed: {
folders: [
{ _id: "folder-1", target: "item", foundryFolderId: "folder-melee", name: "Melee Weapons", color: "#0080ff" },
{ _id: "folder-2", target: "item", name: "Homebrew" },
{ _id: "folder-3", name: "Chapter 1" },
],
items: [{ _id: "item-1", name: "Longsword", foundryItemId: "item-1", folder: "folder-1" }],
},
});
const response = await sync.call("GET /sync/items");
assert.equal(response.status, "ok");
assert.equal(response.items.length, 1);
const coloured = response.folders.find((folder) => folder._id === "folder-1");
assert.equal(coloured.foundryFolderId, "folder-melee", "the world's folder to write the colour back to");
assert.equal(coloured.color, "#0080ff");
assert.ok(!response.folders.some((folder) => folder._id === "folder-3"), "only the item list's folders travel back");
});
test("every folder listing says which campaign list it belongs to", () => { test("every folder listing says which campaign list it belongs to", () => {
// The sidebar's four lists share the Folder model, so a listing that names no target // The sidebar's four lists share the Folder model, so a listing that names no target
// would show folders of the other lists between its own rows. The note routes and // would show folders of the other lists between its own rows. The note routes and
@@ -328,15 +471,40 @@ function makeWorld() {
registered: new Map(), registered: new Map(),
requests: [], requests: [],
timers: new Map(), timers: new Map(),
intervals: new Map(),
// What Dragonroll answers a folder reconcile with: the campaign's folders and the
// colours its user gave them.
remoteFolders: [],
nextTimerId: 1, nextTimerId: 1,
}; };
// Foundry's `update` takes dotted paths ("flags.dragonroll-foundry.itemId"); an
// embedded update names the row to write them on, so `_id` is not a path to set.
function writeFoundryPaths(target, data) {
for (const [key, value] of Object.entries(data)) {
if (key === "_id") continue;
const parts = key.split(".");
const last = parts.pop();
let node = target;
for (const part of parts) node = node[part] ??= {};
node[last] = value;
}
return target;
}
// A Folder document, plain data and the `update` both the GM and Dragonroll write with.
const makeFolder = (id, name, over = {}) => ({
id, name, type: "Item", parent: null, color: null, documentName: "Folder",
async update(data) { return writeFoundryPaths(this, data); },
...over,
});
const folders = [ const folders = [
{ id: "folder-melee", name: "Melee Weapons", type: "Item", parent: null, documentName: "Folder" }, makeFolder("folder-melee", "Melee Weapons", { color: "#8b0000" }),
{ id: "folder-ranged", name: "Ranged Weapons", type: "Item", parent: "folder-melee", documentName: "Folder" }, makeFolder("folder-ranged", "Ranged Weapons", { parent: "folder-melee" }),
// An actor's own inventory folder: it hangs off the actor, not the world. // An actor's own inventory folder: it hangs off the actor, not the world.
{ id: "folder-carried", name: "Carried", type: "Item", parent: { id: "actor-1", documentName: "Actor" }, documentName: "Folder" }, makeFolder("folder-carried", "Carried", { parent: { id: "actor-1", documentName: "Actor" } }),
{ id: "folder-journal", name: "Lore", type: "JournalEntry", parent: null, documentName: "Folder" }, makeFolder("folder-journal", "Lore", { type: "JournalEntry" }),
]; ];
const items = [ const items = [
{ {
@@ -362,10 +530,15 @@ function makeWorld() {
id: "actor-1", name: "Thalia", type: "character", documentName: "Actor", flags: {}, id: "actor-1", name: "Thalia", type: "character", documentName: "Actor", flags: {},
items: { contents: [carriedItem] }, items: { contents: [carriedItem] },
getFlag() { return undefined; }, getFlag() { return undefined; },
// A pushed actor has its items marked as synced and itself mapped to the async update(data) { return writeFoundryPaths(this, data); },
// campaign row: nothing here reads those flags back. // Embedded documents are written through the document holding them, and each
async update() { return this; }, // update names the row it belongs to.
async updateEmbeddedDocuments() { return []; }, async updateEmbeddedDocuments(_kind, updates) {
for (const update of updates) {
if (carriedItem.id === update._id) writeFoundryPaths(carriedItem, update);
}
return [];
},
toObject() { return { _id: this.id, name: this.name, type: this.type, flags: this.flags }; }, toObject() { return { _id: this.id, name: this.name, type: this.type, flags: this.flags }; },
}, },
]; ];
@@ -387,15 +560,24 @@ function makeWorld() {
return id; return id;
}, },
clearTimeout: (id) => state.timers.delete(id), clearTimeout: (id) => state.timers.delete(id),
setInterval: () => 0, setInterval: (fn, delay = 0) => {
clearInterval: () => {}, // Recorded, never run by itself: tests ask for a periodic reconcile with
// `runIntervals`, so the ones watching single pushes stay on their own.
const id = state.nextTimerId++;
state.intervals.set(id, { fn, delay });
return id;
},
clearInterval: (id) => state.intervals.delete(id),
fetch: async (url, options = {}) => { fetch: async (url, options = {}) => {
const href = String(url);
state.requests.push({ state.requests.push({
href: String(url), href,
method: options.method, method: options.method,
body: options.body ? JSON.parse(options.body) : null, body: options.body ? JSON.parse(options.body) : null,
}); });
return { ok: true, status: 200, json: async () => ({ status: "ok", actors: [], items: [] }) }; const payload = { status: "ok", actors: [], items: [] };
if (href.includes("foundry/sync/items")) payload.folders = state.remoteFolders;
return { ok: true, status: 200, json: async () => payload };
}, },
Actor: { async create() { return null; } }, Actor: { async create() { return null; } },
Item: { async create() { return null; } }, Item: { async create() { return null; } },
@@ -446,6 +628,12 @@ function makeWorld() {
await drain(); await drain();
} }
}; };
// The reconciles `setInterval` registered: what runs every few seconds on a world
// that is linked, and so what carries Dragonroll's folder colours back into the world.
state.runIntervals = async () => {
for (const interval of [...state.intervals.values()]) await interval.fn();
await drain();
};
state.linkedSetup = async () => { state.linkedSetup = async () => {
await state.fire("init"); await state.fire("init");
await state.fire("ready"); await state.fire("ready");
@@ -466,9 +654,9 @@ test("the world sends its item folder tree with a snapshot", async () => {
const [push] = world.pushes("foundry/sync/snapshot"); const [push] = world.pushes("foundry/sync/snapshot");
assert.ok(push, "the actor change pushed a snapshot"); assert.ok(push, "the actor change pushed a snapshot");
assert.deepEqual(push.body.folders, [ assert.deepEqual(push.body.folders, [
{ id: "folder-melee", name: "Melee Weapons", parent: null }, { id: "folder-melee", name: "Melee Weapons", parent: null, color: "#8b0000" },
{ id: "folder-ranged", name: "Ranged Weapons", parent: "folder-melee" }, { id: "folder-ranged", name: "Ranged Weapons", parent: "folder-melee", color: null },
], "the item directory tree, nested, without the actor's own or another type's folders"); ], "the item directory tree, nested and coloured, without the actor's own or another type's folders");
const longsword = push.body.items.find((item) => item._id === "item-1"); const longsword = push.body.items.find((item) => item._id === "item-1");
assert.equal(longsword.dragonroll.folder, "folder-melee", "a world item says which folder it stands in"); assert.equal(longsword.dragonroll.folder, "folder-melee", "a world item says which folder it stands in");
const torch = push.body.items.find((item) => item._id === "item-2"); const torch = push.body.items.find((item) => item._id === "item-2");
@@ -513,6 +701,21 @@ test("a folder change reaches Dragonroll without pushing the items in it", async
]); ]);
}); });
test("a folder the GM colours sends its colour with the tree", async () => {
const world = await makeWorld().linkedSetup();
const ranged = world.folder("folder-ranged");
ranged.color = "#123456";
await world.fire("updateFolder", ranged);
await world.runTimers();
const [push] = world.pushes("foundry/sync/item-snapshot");
assert.deepEqual(push.body.folders.map((folder) => [folder.id, folder.color]), [
["folder-melee", "#8b0000"],
["folder-ranged", "#123456"],
], "every folder reports the colour the world shows for it, `null` for one it left uncoloured");
});
test("a folder of another document type does not touch the item list", async () => { test("a folder of another document type does not touch the item list", async () => {
const world = await makeWorld().linkedSetup(); const world = await makeWorld().linkedSetup();
@@ -533,8 +736,48 @@ test("autosync off: folder changes stop syncing", async () => {
assert.deepEqual(world.syncRequests(), []); assert.deepEqual(world.syncRequests(), []);
}); });
// --- The colours the campaign gives those folders travel back to the world ---------
test("a folder coloured in the Dragonroll campaign is coloured in the world", async () => {
const world = await makeWorld().linkedSetup();
world.remoteFolders = [
{ _id: "db-melee", name: "Melee Weapons", foundryFolderId: "folder-melee", color: "#0080ff" },
// A folder the campaign made for its own items: there is no world document to colour.
{ _id: "db-homebrew", name: "Homebrew", color: "#00ff00" },
];
await world.runIntervals();
assert.equal(world.folder("folder-melee").color, "#0080ff");
assert.equal(world.folder("folder-ranged").color, null, "a folder the campaign says nothing about keeps what the world shows");
assert.deepEqual(world.requests.filter((request) => request.method === "POST"), [],
"Dragonroll's own write is not pushed back to the campaign as a world change");
});
test("a colour taken off in the campaign comes off the world's folder", async () => {
const world = await makeWorld().linkedSetup();
world.remoteFolders = [{ _id: "db-melee", name: "Melee Weapons", foundryFolderId: "folder-melee", color: null }];
await world.runIntervals();
assert.equal(world.folder("folder-melee").color, null, "uncoloured in the campaign is uncoloured in the world");
});
test("autosync off: the campaign's folder colours are not written into the world", async () => {
const world = await makeWorld().linkedSetup();
await world.game.settings.set("dragonroll-foundry", "autoSync", false);
world.remoteFolders = [{ _id: "db-melee", name: "Melee Weapons", foundryFolderId: "folder-melee", color: "#0080ff" }];
await world.runIntervals();
assert.equal(world.folder("folder-melee").color, "#8b0000", "the world keeps what it shows while autosync is off");
});
// --- The sidebar groups its items under those folders ---------------------------- // --- The sidebar groups its items under those folders ----------------------------
// `vm.compileFunction` is synchronous, so the service is ready right away. Loading it with
// a top-level `await` instead makes Node read this whole file as an ES module, where
// `require` is not defined and none of these tests run at all.
function loadItemFoldersService() { function loadItemFoldersService() {
const source = read("frontend", "app", "services", "ItemFolders.js").replace("export { BuildItemRows };", "return { BuildItemRows };"); const source = read("frontend", "app", "services", "ItemFolders.js").replace("export { BuildItemRows };", "return { BuildItemRows };");
return vm.compileFunction(source)(); return vm.compileFunction(source)();

View File

@@ -0,0 +1,89 @@
// Tests for Syndria98/dragonroll#63: the item rows in the campaign sidebar dropped the text
// listing category, rarity and quantity — the rarity colours the text of the entry instead
// (common white, uncommon green, rare blue, very rare purple, legendary orange) — and the
// quantity left the item surfaces altogether, since it only belongs to an actor's inventory.
//
// The repository root installs no dependencies, so these read the sources the way
// tests/item-entry-display.test.js does — the checks are about the markup and style.
//
// 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 sidebarSource = read("frontend", "app", "components", "partials", "ContentSidebar.vue");
const itemWindowSource = read("frontend", "app", "components", "windows", "ItemSheetWindow.vue");
const entryFormSource = read("frontend", "app", "components", "windows", "CreateCampaignEntryWindow.vue");
const sheetSource = read("frontend", "app", "components", "windows", "CharacterSheetWindow.vue");
const colorsSource = read("frontend", "app", "assets", "css", "colors.scss");
// The block that renders the item rows, as in tests/item-entry-display.test.js.
const itemSection =
/<template v-else-if="activeSection === 'items'">([\s\S]*?)<\/template>\s*\n\s*<template v-else>/.exec(sidebarSource)?.[1] ?? "";
const rarities = ["common", "uncommon", "rare", "very-rare", "legendary"];
// `selector` is inserted verbatim, so escape the `.` of a class combination. Comments are dropped:
// they explain a rule, they are not part of it.
function ruleFor(selector) {
const rule = new RegExp(`\\.${selector}\\s*\\{([^}]*)\\}`).exec(sidebarSource)?.[0];
return rule?.replace(/\/\*[\s\S]*?\*\//g, "");
}
test("the item entry no longer lists the category, rarity and quantity as text", () => {
assert.ok(itemSection, "expected to find the items section of the sidebar");
assert.doesNotMatch(itemSection, /entity-entry-meta/, "the item row must not render a meta line");
assert.doesNotMatch(itemSection, /campaigns\.item\.(categories|rarities|quantity)/, "the item row must not render item meta text");
assert.doesNotMatch(sidebarSource, /itemSummary/, "the removed summary helper must not be kept around");
});
test("the rarity of an item picks a class for the text of its entry", () => {
assert.match(
itemSection,
/<span class="entity-entry-name" :class="rarityClass\(row\.item\)"/,
"the item name must carry the class picked from its rarity"
);
const helper = /function rarityClass\(item\)\s*\{[\s\S]*?\n\}/.exec(sidebarSource)?.[0] ?? "";
assert.ok(helper, "expected a rarityClass helper");
for (const rarity of rarities) {
assert.ok(helper.includes(`'${rarity}'`), `rarityClass must know about '${rarity}'`);
}
});
test("each rarity colours the entry text with its own theme colour", () => {
for (const rarity of rarities) {
const rule = ruleFor(`entity-entry-name\\.rarity-${rarity}`);
assert.ok(rule, `expected a colour rule for .entity-entry-name.rarity-${rarity}`);
assert.match(rule, new RegExp(`color:\\s*var\\(--color-rarity-${rarity}\\)`));
}
});
test("both theme maps carry the rarity colours", () => {
for (const rarity of rarities) {
const declarations = colorsSource.match(new RegExp(`rarity-${rarity}:\\s*#[0-9a-fA-F]{6}`, "g")) || [];
assert.equal(declarations.length, 2, `expected rarity-${rarity} in both the dark and the light map`);
}
});
test("the quantity only shows in an actor's inventory", () => {
assert.doesNotMatch(itemWindowSource, /quantity/, "the item window must not list the quantity");
assert.doesNotMatch(entryFormSource, /quantity/, "the item create/edit form must not offer the quantity");
// the character sheet's inventory table keeps it.
assert.match(sheetSource, /campaigns\.character-sheet\.quantity/);
assert.match(sheetSource, /\{\{ item\.quantity \}\}/);
});
test("no locale keeps the removed item quantity strings", () => {
for (const locale of ["en", "es", "ca"]) {
const campaigns = JSON.parse(read("frontend", "i18n", "locales", locale, "campaigns.json"));
assert.ok(campaigns.item, `${locale} is missing the campaigns.item block`);
assert.equal(campaigns.item.quantity, undefined, `${locale} still has campaigns.item.quantity`);
assert.equal(campaigns.item["quantity-short"], undefined, `${locale} still has campaigns.item.quantity-short`);
// the character sheet's inventory keeps its own quantity column label
assert.ok(campaigns["character-sheet"]?.quantity, `${locale} is missing campaigns.character-sheet.quantity`);
}
});

View File

@@ -73,12 +73,15 @@ test("the item info window is registered and opens on a sidebar click", () => {
}); });
test("the item window shows the info and offers both icon sources", () => { test("the item window shows the info and offers both icon sources", () => {
// info: name, category, rarity, quantity, weight, properties, description // info: name, category, rarity, weight, properties, description — quantity is gone
for (const key of ["form.name", "form.category", "form.rarity", "form.quantity", "form.weight", "form.properties", "form.description"]) { // (#63 keeps it for the actors' inventories).
for (const key of ["form.name", "form.category", "form.rarity", "form.weight", "form.properties", "form.description"]) {
assert.ok(itemWindowSource.includes(key), `expected the window to render ${key}`); assert.ok(itemWindowSource.includes(key), `expected the window to render ${key}`);
} }
// own icon: upload through the item route like the character sheet does its photo // own icon: #65 moved picking one into a window of its own, which uploads through
assert.match(itemWindowSource, /\/item\/upload-image\?item=/); // the item route (see tests/foundry-icon-picker.test.js); the sheet opens it and
// follows whatever the choice leaves behind.
assert.match(itemWindowSource, /CreateChildWindow\(id, ['"]item_icon_source['"]/);
// Foundry icon: switch the item image back to the one the world sent // Foundry icon: switch the item image back to the one the world sent
assert.match(itemWindowSource, /form\.value\.foundryImage/); assert.match(itemWindowSource, /form\.value\.foundryImage/);
assert.match(itemWindowSource, /updateItem\(\{ image: form\.value\.foundryImage \}\)/); assert.match(itemWindowSource, /updateItem\(\{ image: form\.value\.foundryImage \}\)/);

View File

@@ -341,6 +341,17 @@ function mapViewerTokenWiringTests() {
assert.match(pane, /@contextmenu\.stop\.prevent="onTokenContextMenu\(token\)"/); assert.match(pane, /@contextmenu\.stop\.prevent="onTokenContextMenu\(token\)"/);
}); });
test("double clicking a token opens its actor's character sheet", () => {
assert.match(pane, /@dblclick="openTokenSheet\(token\)"/);
// The sheet is opened for the actor behind the token, and only when that actor is known.
assert.match(pane, /function openTokenSheet\(token\) \{[^}]*tokenActor\(token\)[^}]*openActorSheet\(/);
// A single click is not the trigger: it lands on the token at the end of every drag, so
// moving a token would open its sheet every time.
assert.doesNotMatch(pane, /@click="openTokenSheet\(/);
// The keyboard reaches the same sheet: Enter on a focused token, like its arrow keys.
assert.match(pane, /if \(event\.key === 'Enter'\) openTokenSheet\(token\);/);
});
test("tokens are saved and taken off through the map routes", () => { test("tokens are saved and taken off through the map routes", () => {
assert.match(pane, /['"]\/map\/place-token['"]/); assert.match(pane, /['"]\/map\/place-token['"]/);
assert.match(pane, /['"]\/map\/remove-token['"]/); assert.match(pane, /['"]\/map\/remove-token['"]/);

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

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

View File

@@ -0,0 +1,72 @@
// Tests for Syndria98/dragonroll#71: `pnpm dev` warned, on every frontend build,
// "You probably don't mean to use the color value red in interpolation here" from `theme-vars()`
// in colors.scss. `red`, `green` and `gray` are also Sass colour keywords, so as unquoted map keys
// they were parsed as colour *values* and interpolating one into `--color-#{$name}` warned (and can
// emit an invalid name). Quoting those keys keeps them strings; the emitted CSS is unchanged, so
// `var(--color-red)` and friends still resolve.
//
// `sass` is not installed for `npm test`, so this reads colors.scss the way the other tests read
// sources: the check is that no map key is left bare when it spells a CSS colour keyword.
//
// 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 colorsSource = read("frontend", "app", "assets", "css", "colors.scss");
// The CSS named colours. Sass parses any of these (in any case) as a colour value, so a theme or
// accent map key spelled like one of them has to be quoted to stay a string.
const colorKeywords = new Set(
[
"aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige", "bisque", "black",
"blanchedalmond", "blue", "blueviolet", "brown", "burlywood", "cadetblue", "chartreuse",
"chocolate", "coral", "cornflowerblue", "cornsilk", "crimson", "cyan", "darkblue", "darkcyan",
"darkgoldenrod", "darkgray", "darkgreen", "darkkhaki", "darkmagenta", "darkolivegreen",
"darkorange", "darkorchid", "darkred", "darksalmon", "darkseagreen", "darkslateblue",
"darkslategray", "darkturquoise", "darkviolet", "deeppink", "deepskyblue", "dimgray",
"dodgerblue", "firebrick", "floralwhite", "forestgreen", "fuchsia", "gainsboro", "ghostwhite",
"gold", "goldenrod", "gray", "green", "greenyellow", "honeydew", "hotpink", "indianred",
"indigo", "ivory", "khaki", "lavender", "lavenderblush", "lawngreen", "lemonchiffon",
"lightblue", "lightcoral", "lightcyan", "lightgoldenrodyellow", "lightgray", "lightgreen",
"lightpink", "lightsalmon", "lightseagreen", "lightskyblue", "lightslategray",
"lightsteelblue", "lightyellow", "lime", "limegreen", "linen", "magenta", "maroon",
"mediumaquamarine", "mediumblue", "mediumorchid", "mediumpurple", "mediumseagreen",
"mediumslateblue", "mediumspringgreen", "mediumturquoise", "mediumvioletred", "midnightblue",
"mintcream", "mistyrose", "moccasin", "navajowhite", "navy", "oldlace", "olive", "olivedrab",
"orange", "orangered", "orchid", "palegoldenrod", "palegreen", "paleturquoise",
"palevioletred", "papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue", "purple",
"rebeccapurple", "red", "rosybrown", "royalblue", "saddlebrown", "salmon", "sandybrown",
"seagreen", "seashell", "sienna", "silver", "skyblue", "slateblue", "slategray", "snow",
"springgreen", "steelblue", "tan", "teal", "thistle", "tomato", "transparent", "turquoise",
"violet", "wheat", "white", "whitesmoke", "yellow", "yellowgreen",
]
);
// The keys of the `$themes` and `$accents` maps and of each theme inside them: a line starting with
// `key:` or `"key":`. The custom properties of the mixins (`--color-#{$name}: #{$value};`) do not
// match, `#` is not part of a key.
const mapKeys = [...colorsSource.matchAll(/^\s*("[^"]+"|[A-Za-z][A-Za-z0-9_-]*)\s*:/gm)].map((m) => m[1]);
test("the theme and accent maps are read as maps of keys", () => {
// sanity check on the extraction above before it is trusted to find a bare colour keyword
for (const key of ["dark", "light", "katlum", "solus", "silang", "background", "text"]) {
assert.ok(mapKeys.includes(key), `expected to find the map key '${key}'`);
}
});
test("no map key is a bare CSS colour keyword", () => {
const bare = mapKeys.filter((key) => !key.startsWith('"') && colorKeywords.has(key.toLowerCase()));
assert.deepEqual(bare, [], `quote these colors.scss map keys so Sass keeps them strings: ${bare.join(", ")}`);
});
test("the colour-named theme keys are quoted in both maps", () => {
for (const [key, value] of [["red", "#e06c75"], ["green", "#98c379"], ["gray", "#cccccc"]]) {
const declarations = colorsSource.match(new RegExp(`"${key}":\\s*${value}\\b`, "g")) || [];
assert.equal(declarations.length, 2, `expected quoted "${key}": ${value} in both the dark and the light map`);
}
});