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