Files
dragonroll/dragonroll-foundry/scripts/api.js
Aran Roig af76cf1050
All checks were successful
Build and Deploy Nuxt / build (push) Successful in 1m6s
Things
2026-10-13 22:50:51 +02:00

1019 lines
35 KiB
JavaScript

const MODULE_ID = "dragonroll-foundry";
const SETTING_BRIDGE_URL = "bridgeUrl";
const SETTING_PUSH_TOKEN = "pushToken";
const SETTING_BRIDGE_CONFIG = "bridgeConfig";
const SETTING_DRAGONROLL_API_URL = "dragonrollApiUrl";
const SETTING_LINK_CODE = "linkCode";
const SETTING_SYNC_TOKEN = "syncToken";
let syncTimeout;
let syncInProgress = false;
let syncRequested = false;
let handlingLinkCode = false;
let updatingLinkCodeSetting = false;
let linkRetriesDisabled = false;
const FATAL_LINK_ERRORS = new Set([
"foundry.errors.link-expired",
"foundry.errors.world-already-linked",
]);
let actorSyncTimeout;
let characterSyncRunning = false;
let actorSyncErrorLogged = false;
const syncingActorIds = new Set();
const queuedActorChanges = new Map();
let itemSyncTimeout;
let itemSyncRunning = false;
let itemSyncErrorLogged = false;
const syncingItemIds = new Set();
const queuedItemChanges = new Map();
function getCollectionContents(collection, collectionName) {
if (!collection) {
throw new Error(`Foundry ${collectionName} collection is not available yet.`);
}
return collection.contents;
}
function toPlainData(document) {
return document?.toObject() ?? null;
}
const api = Object.freeze({
/** Return metadata for the currently loaded world. */
getWorld() {
if (!game.world) return null;
return {
id: game.world.id,
title: game.world.title,
system: game.system.id,
url: window.location.origin,
};
},
/** Return plain data snapshots for all Actor documents in the active world. */
getActors() {
return getCollectionContents(game.actors, "actor").map(toPlainData);
},
/** Return plain data snapshots for Actors whose system type is `character`. */
getCharacters() {
return getCollectionContents(game.actors, "actor")
.filter((actor) => actor.type === "character")
.map(toPlainData);
},
/** Return one Actor snapshot, or null when its id is not in the active world. */
getActor(actorId) {
return toPlainData(game.actors?.get(actorId));
},
/** Return plain data snapshots for world-level Item documents. */
getItems() {
return getCollectionContents(game.items, "item").map(toPlainData);
},
/** Return one world-level Item snapshot, or null when its id is not in the active world. */
getItem(itemId) {
return toPlainData(game.items?.get(itemId));
},
/** Return embedded Item snapshots belonging to an Actor, or null if the Actor is missing. */
getActorItems(actorId) {
const actor = game.actors?.get(actorId);
if (!actor) return null;
return getCollectionContents(actor.items, "actor item").map(toPlainData);
},
});
Hooks.once("init", () => {
game.settings.register(MODULE_ID, SETTING_BRIDGE_URL, {
name: "Legacy bridge URL",
scope: "client",
config: false,
type: String,
default: "",
});
game.settings.register(MODULE_ID, SETTING_PUSH_TOKEN, {
name: "Legacy bridge publish token",
scope: "client",
config: false,
type: String,
default: "",
});
game.settings.register(MODULE_ID, SETTING_BRIDGE_CONFIG, {
name: "Bridge configuration",
scope: "client",
config: false,
type: Object,
default: {},
});
game.settings.register(MODULE_ID, SETTING_SYNC_TOKEN, {
name: "Character sync token",
scope: "client",
config: false,
type: String,
default: "",
});
game.settings.register(MODULE_ID, SETTING_DRAGONROLL_API_URL, {
name: "Dragonroll Endpoint",
hint: "The Dragonroll server URL. The API path is added automatically.",
scope: "client",
config: true,
type: String,
default: "https://dragonroll.aranroig.com",
});
game.settings.register(MODULE_ID, SETTING_LINK_CODE, {
name: "Dragonroll Campaign Pairing Code",
hint: "Paste a pairing code created in Dragonroll campaign settings.",
scope: "client",
config: true,
type: String,
default: "",
onChange: handleLinkCodeChange,
});
const module = game.modules.get(MODULE_ID);
if (!module) {
console.warn(`${MODULE_ID} | Could not register the public API: module was not found.`);
return;
}
module.api = api;
console.info(`${MODULE_ID} | Public API registered.`);
});
function dragonrollEndpoint(path) {
const endpoint = game.settings.get(MODULE_ID, SETTING_DRAGONROLL_API_URL)?.trim();
if (!endpoint) throw new Error("Set the Dragonroll endpoint in the Dragonroll Foundry module settings first.");
const apiBase = new URL(endpoint);
const basePath = apiBase.pathname.replace(/\/+$/, "");
const isLocalBackend = ["localhost", "127.0.0.1", "[::1]"].includes(apiBase.hostname)
&& apiBase.port === "5000";
const hasApiPath = basePath.endsWith("/api");
apiBase.pathname = `${hasApiPath || isLocalBackend ? basePath : `${basePath}/api`}/`;
apiBase.search = "";
apiBase.hash = "";
return new URL(path.replace(/^\/+/, ""), apiBase);
}
async function postDragonroll(path, body, token = "") {
const headers = { "Content-Type": "application/json" };
if (token) headers.Authorization = `Bearer ${token}`;
const response = await fetch(dragonrollEndpoint(path), {
method: "POST",
headers,
body: JSON.stringify(body),
});
const result = await response.json();
if (!response.ok || result.status !== "ok") {
throw new Error(result.msg || `Dragonroll returned HTTP ${response.status}.`);
}
return result;
}
async function getDragonroll(path, token) {
const response = await fetch(dragonrollEndpoint(path), {
headers: { Authorization: `Bearer ${token}` },
});
const result = await response.json();
if (!response.ok || result.status !== "ok") {
throw new Error(result.msg || `Dragonroll returned HTTP ${response.status}.`);
}
return result;
}
function linkErrorMessage(error) {
const messages = {
"foundry.errors.link-expired": "The pairing code is invalid, expired, or already used.",
"foundry.errors.world-already-linked": "This Foundry world is already linked to another campaign.",
};
return messages[error.message] || error.message;
}
async function setLinkCode(value) {
updatingLinkCodeSetting = true;
try {
await game.settings.set(MODULE_ID, SETTING_LINK_CODE, value);
} finally {
updatingLinkCodeSetting = false;
}
}
function handleLinkCodeChange(value) {
if (updatingLinkCodeSetting || handlingLinkCode || !value?.trim()) return;
linkRetriesDisabled = false;
completeDragonrollCampaignLink(value.trim());
}
async function completeDragonrollCampaignLink(code, options = {}) {
if (handlingLinkCode) return;
handlingLinkCode = true;
const notifyOnError = options.notifyOnError !== false;
try {
if (!game.user?.isGM || !game.world) throw new Error("Open the world as a GM to link it.");
const result = await postDragonroll("foundry/link/complete", { code, world: api.getWorld() });
let syncTokenStored = false;
if (result.syncToken) {
try {
await game.settings.set(MODULE_ID, SETTING_SYNC_TOKEN, result.syncToken);
syncTokenStored = true;
} catch (error) {
console.error(`${MODULE_ID} | Could not save the character sync token.`, error);
}
}
if (result.bridgeConfig?.url && result.bridgeConfig?.pushToken) {
try {
await game.settings.set(MODULE_ID, SETTING_BRIDGE_CONFIG, result.bridgeConfig);
} catch (error) {
console.error(`${MODULE_ID} | Could not save the bridge configuration.`, error);
ui.notifications?.warn("The world was linked, but its bridge settings could not be saved on this client.");
}
}
// Keep an unprocessed pairing code in the setting when its sync token could
// not be saved, so the retry below can complete the link again.
if (syncTokenStored || !result.syncToken) await setLinkCode("");
if (!syncTokenStored) {
ui.notifications?.warn("The world was linked, but character sync is unavailable. Update Dragonroll and link the world again.");
}
scheduleSnapshotSync(0);
setTimeout(initializeCharacterSync, 0);
setTimeout(reconcileDragonrollItems, 2000);
ui.notifications?.info("This Foundry world is now linked to the Dragonroll campaign.");
} catch (error) {
console.error(`${MODULE_ID} | Could not complete the campaign link.`, error);
// Expired or already-used codes will never redeem, so stop the background
// retry; any error keeps retrying (the Dragonroll server may be restarting).
linkRetriesDisabled = FATAL_LINK_ERRORS.has(error.message);
if (notifyOnError) ui.notifications?.error(linkErrorMessage(error));
} finally {
handlingLinkCode = false;
}
}
// A pairing code entered while the Dragonroll server was unreachable (or just
// before Foundry restarted) stays in the setting; redeem it on world start so
// the connection survives restarts without typing the code in again.
async function resumePendingDragonrollLink(options = {}) {
if (handlingLinkCode || !game.user?.isGM || !game.world) return;
const code = game.settings.get(MODULE_ID, SETTING_LINK_CODE)?.trim();
if (code) await completeDragonrollCampaignLink(code, options);
}
function scheduleSnapshotSync(delay = 500) {
clearTimeout(syncTimeout);
syncTimeout = setTimeout(publishSnapshot, delay);
}
function getBridgeConfig() {
const configured = game.settings.get(MODULE_ID, SETTING_BRIDGE_CONFIG);
if (configured?.url?.trim() && configured?.pushToken?.trim()) return configured;
const legacy = {
url: game.settings.get(MODULE_ID, SETTING_BRIDGE_URL)?.trim(),
pushToken: game.settings.get(MODULE_ID, SETTING_PUSH_TOKEN)?.trim(),
};
return legacy.url && legacy.pushToken ? legacy : null;
}
function getSyncToken() {
return game.settings.get(MODULE_ID, SETTING_SYNC_TOKEN)?.trim() || "";
}
function dragonrollActorId(actor) {
return actor.getFlag?.(MODULE_ID, "actorId") || actor.flags?.[MODULE_ID]?.actorId || "";
}
function serializeFoundryActor(actor) {
const data = {
...toPlainData(actor),
items: actor.items?.contents?.map(toPlainData) || [],
};
if (data.img && !/^(https?:|data:|\/\/)/i.test(data.img)) {
data.img = new URL(data.img, window.location.origin).toString();
}
return data;
}
function isSupportedCharacterActor(actor) {
const savedType = actor.getFlag?.(MODULE_ID, "actorType") || actor.flags?.[MODULE_ID]?.actorType;
return ["character", "npc", "creature"].includes(savedType || actor.type);
}
async function markActorItemsAsSynced(actor) {
const updates = actor.items.contents
.filter((item) => !item.getFlag?.(MODULE_ID, "syncedItem"))
.map((item) => ({
_id: item.id,
[`flags.${MODULE_ID}.syncedItem`]: true,
}));
if (updates.length) {
await withActorSyncSuppressed(actor, () => actor.updateEmbeddedDocuments("Item", updates));
}
}
async function withActorSyncSuppressed(actor, callback) {
if (!actor?.id) return callback();
syncingActorIds.add(actor.id);
try {
return await callback();
} finally {
syncingActorIds.delete(actor.id);
}
}
async function setDragonrollActorId(actor, actorId) {
if (!actor || !actorId) return;
await withActorSyncSuppressed(actor, () => actor.update({
[`flags.${MODULE_ID}.actorId`]: String(actorId),
[`flags.${MODULE_ID}.syncMutation`]: false,
}));
}
function reportActorSyncError(error) {
if (actorSyncErrorLogged) return;
actorSyncErrorLogged = true;
console.warn(`${MODULE_ID} | Character sync failed and will retry.`, error);
}
async function pushFoundryActors(actors, fullSync = false) {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || (!actors.length && !fullSync)) return;
if (game.system.id !== "dnd5e") {
throw new Error("Character sync currently requires the D&D 5e Foundry system.");
}
const supportedActors = actors.filter(isSupportedCharacterActor);
for (const actor of supportedActors) await markActorItemsAsSynced(actor);
const result = await postDragonroll("foundry/sync/snapshot", {
worldId: game.world.id,
actors: supportedActors.map(serializeFoundryActor),
// Dragonroll deduplicates by name, so sending the world directory next to
// the actor copies keeps a single Item per piece of gear.
items: getWorldItemSnapshots(),
fullSync,
}, token);
for (const mapping of result.actors || []) {
const actor = game.actors.get(mapping.foundryActorId);
if (actor && dragonrollActorId(actor) !== mapping.actorId) {
await setDragonrollActorId(actor, mapping.actorId);
}
}
await rememberItemMappings(result.items);
actorSyncErrorLogged = false;
}
async function deleteDragonrollActor(foundryActorId) {
const token = getSyncToken();
if (!token || !game.world || !foundryActorId) return;
await postDragonroll("foundry/sync/delete", {
worldId: game.world.id,
foundryActorId,
}, token);
}
function queueActorChange(kind, actor) {
if (!actor || !game.user?.isGM || !getSyncToken()) return;
if (syncingActorIds.has(actor.id) || actor.flags?.[MODULE_ID]?.syncMutation) return;
queuedActorChanges.set(actor.id, { kind, actor });
clearTimeout(actorSyncTimeout);
actorSyncTimeout = setTimeout(flushActorChanges, 400);
}
async function flushActorChanges() {
const changes = [...queuedActorChanges.values()];
queuedActorChanges.clear();
const deleted = changes.filter((change) => change.kind === "delete");
const changed = changes.filter((change) => change.kind !== "delete");
try {
for (const change of deleted) await deleteDragonrollActor(change.actor.id);
await pushFoundryActors(changed.map((change) => change.actor));
} catch (error) {
reportActorSyncError(error);
for (const change of changes) queuedActorChanges.set(change.actor.id, change);
clearTimeout(actorSyncTimeout);
actorSyncTimeout = setTimeout(flushActorChanges, 5000);
}
}
// --- World item sync -------------------------------------------------------
// Items embedded in an actor travel with that actor's snapshot; the items below
// handle the world-level item directory (game.items) in both directions.
function itemPropertyLabels(item) {
const values = item.system?.properties?.value;
if (!Array.isArray(values) || !values.length || game.system?.id !== "dnd5e") return [];
const propertyConfigs = [
CONFIG.DND5E?.weaponProperties,
CONFIG.DND5E?.armorProperties,
CONFIG.DND5E?.toolProperties,
CONFIG.DND5E?.consumableProperties,
];
return values
.map((key) => {
for (const config of propertyConfigs) {
const label = config?.[key]?.label;
if (label) return String(label).toLowerCase();
}
return typeof key === "string" ? key : "";
})
.filter(Boolean);
}
function serializeFoundryItem(item) {
const data = toPlainData(item);
if (!data) return null;
if (data.img && !/^(https?:|data:|\/\/)/i.test(data.img)) {
data.img = new URL(data.img, window.location.origin).toString();
}
// Dragonroll shows plain property text; send Foundry's own labels when present
// so keys such as "ver" do not end up in its Item list.
const properties = itemPropertyLabels(item);
if (properties.length) data.dragonroll = { properties };
return data;
}
function getWorldItemSnapshots() {
return (game.items?.contents || []).map(serializeFoundryItem).filter(Boolean);
}
function dragonrollItemIdOf(item) {
return item.getFlag?.(MODULE_ID, "itemId") || item.flags?.[MODULE_ID]?.itemId || "";
}
async function withItemSyncSuppressed(item, callback) {
if (!item?.id) return callback();
syncingItemIds.add(item.id);
try {
return await callback();
} finally {
syncingItemIds.delete(item.id);
}
}
async function setDragonrollItemId(item, itemId) {
if (!item || !itemId) return;
await withItemSyncSuppressed(item, () => item.update({
[`flags.${MODULE_ID}.itemId`]: String(itemId),
[`flags.${MODULE_ID}.syncMutation`]: false,
}));
}
async function rememberItemMappings(mappings) {
for (const mapping of mappings || []) {
const item = game.items?.get(mapping.foundryItemId);
if (item && String(dragonrollItemIdOf(item)) !== String(mapping.itemId)) {
await setDragonrollItemId(item, mapping.itemId);
}
}
}
function reportItemSyncError(error) {
if (itemSyncErrorLogged) return;
itemSyncErrorLogged = true;
console.warn(`${MODULE_ID} | Item sync failed and will retry.`, error);
}
// Item pushes are upserts only: the full world snapshot sent with the actors
// owns pruning, because it is the only one that sees every embedded copy.
async function pushFoundryItems(items) {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || !items.length) return;
const result = await postDragonroll("foundry/sync/item-snapshot", {
worldId: game.world.id,
items: items.map(serializeFoundryItem).filter(Boolean),
}, token);
await rememberItemMappings(result.items);
itemSyncErrorLogged = false;
}
async function deleteDragonrollItem(foundryItemId) {
const token = getSyncToken();
if (!token || !game.world || !foundryItemId) return;
await postDragonroll("foundry/sync/item-delete", {
worldId: game.world.id,
foundryItemId,
}, token);
}
function queueFoundryItemChange(kind, item) {
if (!item || !game.user?.isGM || !getSyncToken()) return;
if (syncingItemIds.has(item.id) || item.flags?.[MODULE_ID]?.syncMutation) return;
queuedItemChanges.set(item.id, { kind, item });
clearTimeout(itemSyncTimeout);
itemSyncTimeout = setTimeout(flushItemChanges, 400);
}
async function flushItemChanges() {
const changes = [...queuedItemChanges.values()];
queuedItemChanges.clear();
const deleted = changes.filter((change) => change.kind === "delete");
const changed = changes.filter((change) => change.kind !== "delete");
try {
for (const change of deleted) await deleteDragonrollItem(change.item.id);
if (changed.length) await pushFoundryItems(changed.map((change) => change.item));
} catch (error) {
reportItemSyncError(error);
for (const change of changes) queuedItemChanges.set(change.item.id, change);
clearTimeout(itemSyncTimeout);
itemSyncTimeout = setTimeout(flushItemChanges, 5000);
}
}
const CATEGORY_TO_FOUNDRY_ITEM_TYPE = {
weapon: "weapon",
armor: "equipment",
shield: "equipment",
consumable: "consumable",
tool: "tool",
"adventuring-gear": "loot",
"magic-item": "loot",
treasure: "loot",
other: "loot",
};
const RARITY_TO_FOUNDRY_VALUE = {
common: "common",
uncommon: "uncommon",
rare: "rare",
"very-rare": "veryRare",
legendary: "legendary",
artifact: "artifact",
};
function makeFoundryItemData(entry) {
const type = CATEGORY_TO_FOUNDRY_ITEM_TYPE[entry.category] || "loot";
const data = {
name: String(entry.name || "").trim(),
type,
system: {
quantity: Number(entry.quantity) || 1,
weight: Number(entry.weight) || 0,
rarity: RARITY_TO_FOUNDRY_VALUE[entry.rarity] || "common",
description: { value: entry.description || "" },
},
flags: { [MODULE_ID]: { itemId: String(entry._id), syncMutation: true } },
};
if (type === "equipment") data.system.armor = { type: entry.category === "shield" ? "shield" : "medium" };
return data;
}
function foundryItemUpdateData(entry) {
return {
name: String(entry.name || "").trim(),
"system.quantity": Number(entry.quantity) || 1,
"system.weight": Number(entry.weight) || 0,
"system.rarity": RARITY_TO_FOUNDRY_VALUE[entry.rarity] || "common",
"system.description.value": entry.description || "",
};
}
async function applyDragonrollItem(item, entry) {
const updates = foundryItemUpdateData(entry);
const changed = Object.entries(updates).some(([key, value]) => documentValue(item, key) !== value);
await withItemSyncSuppressed(item, async () => {
if (changed) await item.update(updates);
if (dragonrollItemIdOf(item) !== String(entry._id)) {
await item.update({ [`flags.${MODULE_ID}.itemId`]: String(entry._id) });
}
});
}
async function mapDragonrollItem(itemId, foundryItemId) {
const token = getSyncToken();
return postDragonroll("foundry/sync/map-item", {
worldId: game.world.id,
itemId: String(itemId),
foundryItemId: String(foundryItemId),
}, token);
}
async function createFoundryWorldItem(entry) {
const data = makeFoundryItemData(entry);
if (!data.name) return;
const item = await Item.create(data);
if (!item) return;
await withItemSyncSuppressed(item, async () => {
await item.update({ [`flags.${MODULE_ID}.syncMutation`]: false });
});
await mapDragonrollItem(entry._id, item.id);
}
async function reconcileDragonrollItems() {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || itemSyncRunning) return;
itemSyncRunning = true;
try {
if (game.system.id !== "dnd5e") {
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 remoteById = new Map(remoteItems.map((entry) => [String(entry._id), entry]));
const localByRemoteId = new Map(game.items.contents
.map((item) => [String(dragonrollItemIdOf(item)), item])
.filter(([itemId]) => itemId));
const retainedFoundryIds = new Set();
for (const entry of remoteItems) {
let item = entry.foundryItemId ? game.items.get(entry.foundryItemId) : null;
if (!item) item = localByRemoteId.get(String(entry._id));
if (item) {
retainedFoundryIds.add(item.id);
await applyDragonrollItem(item, entry);
if (!entry.foundryItemId) await mapDragonrollItem(entry._id, item.id);
} else if (entry.foundryItemId) {
// Imported gear that only exists inside an actor's inventory: its actor
// snapshot owns it, so cloning it into the world would duplicate it.
continue;
} else {
// A Dragonroll item named like an unmapped Foundry item maps to that
// document instead of adding a second copy of the same gear.
const sameName = game.items.contents.find((candidate) => candidate.name === String(entry.name).trim()
&& !dragonrollItemIdOf(candidate));
if (sameName) {
retainedFoundryIds.add(sameName.id);
await mapDragonrollItem(entry._id, sameName.id);
} else {
await createFoundryWorldItem(entry);
}
}
}
for (const item of game.items.contents) {
const itemId = dragonrollItemIdOf(item);
if (!itemId || retainedFoundryIds.has(item.id) || remoteById.has(String(itemId))) continue;
await withItemSyncSuppressed(item, () => item.delete());
}
itemSyncErrorLogged = false;
} catch (error) {
reportItemSyncError(error);
} finally {
itemSyncRunning = false;
}
}
function getDragonrollImageUrl(image) {
if (!image) return "";
if (/^(https?:|data:|\/\/)/i.test(image)) return image;
const endpoint = new URL(game.settings.get(MODULE_ID, SETTING_DRAGONROLL_API_URL));
const basePath = endpoint.pathname.replace(/\/+$/, "");
endpoint.pathname = `${basePath.endsWith("/api") ? basePath : `${basePath}/api`}/public/${encodeURIComponent(image)}`;
endpoint.search = "";
endpoint.hash = "";
return endpoint.toString();
}
function makeFoundryCharacterData(entry) {
const stats = entry.abilityScores || {};
const items = [];
if (entry.className) items.push({ name: entry.className, type: "class", system: { levels: Number(entry.level) || 1 } });
if (entry.subclass) items.push({ name: entry.subclass, type: "subclass" });
if (entry.background) items.push({ name: entry.background, type: "background" });
for (const name of String(entry.spells || "").split("\n").map((value) => value.trim()).filter(Boolean)) {
items.push({ name, type: "spell" });
}
for (const item of entry.inventory || []) {
if (!item.name?.trim()) continue;
items.push({
name: item.name.trim(),
type: "loot",
system: { quantity: Number(item.quantity) || 1, weight: { value: Number(item.weight) || 0 } },
});
}
return {
name: entry.name,
type: entry.type === "character" ? "character" : "npc",
img: getDragonrollImageUrl(entry.image) || undefined,
system: {
details: {
race: entry.species || "",
level: Number(entry.level) || 1,
background: entry.background || "",
biography: { value: entry.description || "" },
cr: entry.challengeRating || "",
},
abilities: Object.fromEntries(["str", "dex", "con", "int", "wis", "cha"].map((key) => [
key,
{ value: Number(stats[key]) || 10 },
])),
attributes: {
ac: { value: Number(entry.armorClass) || 10 },
movement: { walk: Number(entry.speed) || 30 },
},
},
items,
flags: { [MODULE_ID]: {
actorId: String(entry._id),
actorType: entry.type,
traits: entry.traits || "",
proficiencies: entry.proficiencies || "",
syncMutation: true,
} },
};
}
function documentValue(document, path) {
return path.split(".").reduce((value, key) => value?.[key], document);
}
function characterUpdateData(entry) {
const stats = entry.abilityScores || {};
const updates = {
name: entry.name,
img: getDragonrollImageUrl(entry.image) || "icons/svg/mystery-man.svg",
"system.details.race": entry.species || "",
"system.details.level": Number(entry.level) || 1,
"system.details.background": entry.background || "",
"system.details.biography.value": entry.description || "",
"system.details.cr": entry.challengeRating || "",
[`flags.${MODULE_ID}.traits`]: entry.traits || "",
[`flags.${MODULE_ID}.proficiencies`]: entry.proficiencies || "",
"system.attributes.ac.value": Number(entry.armorClass) || 10,
"system.attributes.movement.walk": Number(entry.speed) || 30,
};
for (const key of ["str", "dex", "con", "int", "wis", "cha"]) {
updates[`system.abilities.${key}.value`] = Number(stats[key]) || 10;
}
return updates;
}
async function reconcileEmbeddedItems(actor, entry) {
const desired = [];
if (entry.className) desired.push({ type: "class", name: entry.className, system: { levels: Number(entry.level) || 1 } });
if (entry.subclass) desired.push({ type: "subclass", name: entry.subclass });
if (entry.background) desired.push({ type: "background", name: entry.background });
for (const name of String(entry.spells || "").split("\n").map((value) => value.trim()).filter(Boolean)) {
desired.push({ type: "spell", name });
}
for (const item of entry.inventory || []) {
if (item.name?.trim()) desired.push({
type: "loot",
name: item.name.trim(),
system: { quantity: Number(item.quantity) || 1, weight: { value: Number(item.weight) || 0 } },
});
}
const retainedIds = new Set();
for (const wanted of desired) {
const existing = actor.items.contents.find((item) => item.name === wanted.name
&& item.type === wanted.type && item.getFlag?.(MODULE_ID, "syncedItem"))
|| actor.items.contents.find((item) => item.name === wanted.name
&& item.getFlag?.(MODULE_ID, "syncedItem"));
if (existing) {
retainedIds.add(existing.id);
const update = { _id: existing.id };
const expected = { name: wanted.name };
if (wanted.system?.levels !== undefined) expected["system.levels"] = wanted.system.levels;
if (wanted.system?.quantity !== undefined) expected["system.quantity"] = wanted.system.quantity;
if (wanted.system?.weight?.value !== undefined) expected["system.weight.value"] = wanted.system.weight.value;
let changed = false;
for (const [key, value] of Object.entries(expected)) {
if (documentValue(existing, key) !== value) {
update[key] = value;
changed = true;
}
}
if (changed) await actor.updateEmbeddedDocuments("Item", [update]);
} else {
const created = await actor.createEmbeddedDocuments("Item", [{
...wanted,
flags: { [MODULE_ID]: { syncedItem: true } },
}]);
for (const item of created) retainedIds.add(item.id);
}
}
const staleItemIds = actor.items.contents
.filter((item) => item.getFlag?.(MODULE_ID, "syncedItem") && !retainedIds.has(item.id))
.map((item) => item.id);
if (staleItemIds.length) await actor.deleteEmbeddedDocuments("Item", staleItemIds);
}
async function applyDragonrollCharacter(actor, entry) {
const updates = characterUpdateData(entry);
const changed = Object.entries(updates).some(([key, value]) => documentValue(actor, key) !== value);
await withActorSyncSuppressed(actor, async () => {
if (changed) await actor.update(updates);
await reconcileEmbeddedItems(actor, entry);
if (dragonrollActorId(actor) !== String(entry._id)
|| actor.getFlag?.(MODULE_ID, "actorType") !== entry.type) {
await actor.update({
[`flags.${MODULE_ID}.actorId`]: String(entry._id),
[`flags.${MODULE_ID}.actorType`]: entry.type,
});
}
});
}
async function mapDragonrollActor(actorId, foundryActorId) {
const token = getSyncToken();
return postDragonroll("foundry/sync/map", {
worldId: game.world.id,
actorId: String(actorId),
foundryActorId: String(foundryActorId),
}, token);
}
async function createFoundryCharacter(entry) {
if (game.system.id !== "dnd5e") {
throw new Error("Character sync currently requires the D&D 5e Foundry system.");
}
const actor = await Actor.create(makeFoundryCharacterData(entry), { renderSheet: false });
if (!actor) return;
await withActorSyncSuppressed(actor, async () => {
await actor.update({ [`flags.${MODULE_ID}.syncMutation`]: false });
});
await mapDragonrollActor(entry._id, actor.id);
}
async function reconcileDragonrollCharacters() {
const token = getSyncToken();
if (!token || !game.user?.isGM || !game.world || characterSyncRunning) return;
characterSyncRunning = true;
try {
if (game.system.id !== "dnd5e") {
throw new Error("Character sync currently requires the D&D 5e Foundry system.");
}
const result = await getDragonroll("foundry/sync/characters", token);
const remoteActors = result.actors || [];
const remoteById = new Map(remoteActors.map((actor) => [String(actor._id), actor]));
const localByRemoteId = new Map(game.actors.contents
.map((actor) => [String(dragonrollActorId(actor)), actor])
.filter(([actorId]) => actorId));
const retainedFoundryIds = new Set();
for (const entry of remoteActors) {
let actor = entry.foundryActorId ? game.actors.get(entry.foundryActorId) : null;
if (!actor) actor = localByRemoteId.get(String(entry._id));
if (actor) {
retainedFoundryIds.add(actor.id);
await applyDragonrollCharacter(actor, entry);
if (!entry.foundryActorId) await mapDragonrollActor(entry._id, actor.id);
} else {
await createFoundryCharacter(entry);
}
}
for (const actor of game.actors.contents) {
const actorId = dragonrollActorId(actor);
if (!actorId || retainedFoundryIds.has(actor.id) || remoteById.has(String(actorId))) continue;
await withActorSyncSuppressed(actor, () => actor.delete());
}
actorSyncErrorLogged = false;
} catch (error) {
reportActorSyncError(error);
} finally {
characterSyncRunning = false;
}
}
async function initializeCharacterSync() {
if (!getSyncToken() || !game.user?.isGM || !game.world) return;
try {
await pushFoundryActors(game.actors.contents, true);
await reconcileDragonrollCharacters();
} catch (error) {
reportActorSyncError(error);
scheduleDragonrollCharacterSync(15000);
}
}
function queueFoundryActorChange(kind, actor) {
if (kind !== "delete" && (actor.flags?.[MODULE_ID]?.syncMutation || syncingActorIds.has(actor.id))) return;
queueActorChange(kind, actor);
}
async function publishSnapshot() {
if (!game.user?.isGM || !game.world) return;
if (syncInProgress) {
syncRequested = true;
return;
}
const bridgeConfig = getBridgeConfig();
if (!bridgeConfig) return;
syncInProgress = true;
try {
const actorItems = Object.fromEntries(
game.actors.contents.map((actor) => [
actor.id,
actor.items.contents.map(toPlainData),
]),
);
const response = await fetch(new URL("internal/snapshot", `${bridgeConfig.url.replace(/\/+$/, "")}/`), {
method: "POST",
headers: {
"Authorization": `Bearer ${bridgeConfig.pushToken}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
world: api.getWorld(),
actors: api.getActors(),
items: api.getItems(),
actorItems,
}),
});
if (!response.ok) {
throw new Error(`Bridge returned HTTP ${response.status}.`);
}
} catch (error) {
console.error(`${MODULE_ID} | Could not publish the world snapshot.`, error);
scheduleSnapshotSync(15000);
} finally {
syncInProgress = false;
if (syncRequested) {
syncRequested = false;
scheduleSnapshotSync();
}
}
}
async function publishHeartbeat() {
if (!game.user?.isGM || !game.world) return;
const bridgeConfig = getBridgeConfig();
if (!bridgeConfig) return;
try {
const response = await fetch(new URL("internal/heartbeat", `${bridgeConfig.url.replace(/\/+$/, "")}/`), {
method: "POST",
headers: {
"Authorization": `Bearer ${bridgeConfig.pushToken}`,
"Content-Type": "application/json",
},
body: JSON.stringify({ worldId: game.world.id }),
});
if (response.status === 409 || response.status === 503) {
scheduleSnapshotSync(0);
return;
}
if (!response.ok) throw new Error(`Bridge returned HTTP ${response.status}.`);
} catch (error) {
console.warn(`${MODULE_ID} | Bridge heartbeat failed.`, error);
scheduleSnapshotSync(15000);
}
}
Hooks.once("ready", () => {
resumePendingDragonrollLink();
setInterval(() => {
if (linkRetriesDisabled) return;
resumePendingDragonrollLink({ notifyOnError: false });
}, 60000);
scheduleSnapshotSync(0);
setInterval(publishHeartbeat, 60000);
setTimeout(initializeCharacterSync, 1000);
setInterval(reconcileDragonrollCharacters, 5000);
// Items reconcile after the character snapshot has landed so Dragonroll has
// already seen the world directory when it starts sending its own items back.
setTimeout(reconcileDragonrollItems, 2000);
setInterval(reconcileDragonrollItems, 5000);
for (const event of [
"createActor", "updateActor", "deleteActor",
"createItem", "updateItem", "deleteItem",
]) {
Hooks.on(event, (document) => {
scheduleSnapshotSync();
const isDelete = event.startsWith("delete");
if (document.documentName === "Actor") {
queueFoundryActorChange(isDelete ? "delete" : "upsert", document);
return;
}
if (document.documentName !== "Item") return;
// Items embedded in an actor travel with that actor's snapshot: adding or
// removing one only changes the actor, never deletes it.
if (document.parent?.documentName === "Actor") {
queueFoundryActorChange("upsert", document.parent);
return;
}
queueFoundryItemChange(isDelete ? "delete" : "upsert", document);
});
}
});