80 lines
4.2 KiB
JavaScript
80 lines
4.2 KiB
JavaScript
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 };
|