const { numberOr, asText, plainText, stringList } = require('./foundry-fields'); // 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 // field's `fallback` option hands back the bare id when the item is gone. Dragonroll // holds names, so a reference is read through the actor's items and an id that resolves // to nothing is dropped. An id travelling back as a name is how Foundry ends up with a // background item — and a details reference — that does not exist (Syndria98/dragonroll#54). const FOUNDRY_DOCUMENT_ID = /^[A-Za-z0-9_-]{16}$/; function looksLikeFoundryId(value) { // Sixteen plain letters is a name; the ids Foundry generates carry a digit. return FOUNDRY_DOCUMENT_ID.test(value) && /[0-9]/.test(value) && /[A-Za-z]/.test(value); } // The name a `system.details` entry stands for: an embedded item's id resolves to that // item's name, and plain text (older system releases store the name here) is the name. function detailsName(value, items) { const text = asText(value).trim(); if (!text) return ''; const referenced = items.find((item) => asText(item?._id ?? item?.id).trim() === text); if (referenced) return asText(referenced.name).trim(); return looksLikeFoundryId(text) ? '' : text; } function foundryActorToCharacter(foundryActor) { const system = foundryActor.system || {}; const details = system.details || {}; const abilities = system.abilities || {}; const attributes = system.attributes || {}; const movement = attributes.movement || {}; const items = Array.isArray(foundryActor.items) ? foundryActor.items : []; const classItem = items.find((item) => item.type === 'class'); const subclassItem = items.find((item) => item.type === 'subclass'); const backgroundItem = items.find((item) => item.type === 'background'); const traits = system.traits || {}; const savedDragonrollFields = foundryActor.flags?.['dragonroll-foundry'] || {}; const savedDragonrollType = savedDragonrollFields.actorType; const foundryProficiencies = [ ...stringList(traits.languages?.value), ...stringList(traits.armor?.value), ...stringList(traits.weapon?.value), ...stringList(traits.tool?.value) ].join(', '); return { name: asText(foundryActor.name).trim(), type: ['character', 'npc', 'creature'].includes(savedDragonrollType) ? savedDragonrollType : (['character', 'npc', 'creature'].includes(foundryActor.type) ? foundryActor.type : 'character'), species: detailsName(details.race || details.species, items), className: detailsName(details.class, items) || asText(classItem?.name), subclass: detailsName(details.subclass, items) || asText(subclassItem?.name), level: numberOr(details.level ?? classItem?.system?.levels, 1), background: detailsName(details.background, items) || asText(backgroundItem?.name), challengeRating: String(details.cr ?? ''), description: plainText(details.biography?.value || details.biography), image: asText(foundryActor.img || foundryActor.image), abilityScores: Object.fromEntries(['str', 'dex', 'con', 'int', 'wis', 'cha'].map((key) => [ key, numberOr(abilities[key]?.value, 10) ])), armorClass: numberOr(attributes.ac?.value ?? attributes.ac, 10), speed: numberOr(movement.walk ?? movement.value, 30), proficiencies: foundryProficiencies || asText(savedDragonrollFields.proficiencies), traits: asText(savedDragonrollFields.traits), inventory: items .filter((item) => !['class', 'subclass', 'background', 'spell'].includes(item.type)) .map((item) => ({ name: asText(item.name).trim(), quantity: numberOr(item.system?.quantity, 1), weight: numberOr(item.system?.weight?.value ?? item.system?.weight, 0) })) .filter((item) => item.name), spells: items.filter((item) => item.type === 'spell').map((item) => asText(item.name)).filter(Boolean).join('\n') }; } module.exports = { foundryActorToCharacter };