670 lines
26 KiB
JavaScript
670 lines
26 KiB
JavaScript
import {LiturgyData} from "../data/miracle/liturgydata.mjs";
|
|
import {Blessing} from "../documents/blessing.mjs";
|
|
import {Profession} from "../documents/profession.mjs";
|
|
import {Culture} from "../documents/culture.mjs";
|
|
import {Species} from "../documents/species.mjs";
|
|
import {SpecialAbility} from "../documents/specialAbility.mjs";
|
|
import {Equipment} from "../documents/equipment.mjs";
|
|
|
|
export class XmlImport {
|
|
#months = [
|
|
"Praios",
|
|
"Rondra",
|
|
"Efferd",
|
|
"Travia",
|
|
"Boron",
|
|
"Hesinde",
|
|
"Firun",
|
|
"Tsa",
|
|
"Phex",
|
|
"Peraine",
|
|
"Ingerimm",
|
|
"Rahja",
|
|
"Namenloser Tag"
|
|
]
|
|
|
|
/**
|
|
* @typedef ImportOptions
|
|
* @property {Boolean} skipMeta
|
|
* @property {Boolean} skipSpecies
|
|
* @property {Boolean} skipCulture
|
|
* @property {Boolean} skipProfessions
|
|
* @property {Boolean} skipAttributes
|
|
* @property {Boolean} skipAdvantages
|
|
* @property {Boolean} skipSpecialAbilities
|
|
* @property {Boolean} skipEquipment
|
|
* @property {Boolean} skipSpells
|
|
* @property {Boolean} skipLiturgies
|
|
* @property {Boolean} skipSkills
|
|
**/
|
|
|
|
static getOptions() {
|
|
return {
|
|
skipMeta: "Meta",
|
|
skipSpecies: "Rasse",
|
|
skipCulture: "Kultur",
|
|
skipProfessions: "Professionen",
|
|
skipAttribution: "Eigenschaften",
|
|
skipAdvantages: "Vor und Nachteile",
|
|
skipSpecialAbilities: "Sonderfertigkeiten",
|
|
skipEquipment: "Inventar",
|
|
skipSpells: "Zauber",
|
|
skipLiturgies: "Liturgien",
|
|
skipSkills: "Talente"
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Imports a character from a file created in the tool Helden-Software
|
|
* @param actorId the actor-id of the character
|
|
* @param file the file from which the character should be imported
|
|
* @param {ImportOptions?} options the set of item types the import should skip
|
|
*/
|
|
async importCharacter(actorId, file, options = undefined) {
|
|
let actor = game.actors.get(actorId)
|
|
console.log("starting import with following options", options)
|
|
let xmlString = await this.#parseFileToString(file)
|
|
let domParser = new DOMParser()
|
|
let dom = domParser.parseFromString(xmlString, 'application/xml')
|
|
|
|
let rawJson = this.#getJsonFromXML(dom)
|
|
|
|
if (!options) {
|
|
options = {
|
|
skipMeta: false,
|
|
skipSpecies: false,
|
|
skipCulture: false,
|
|
skipProfessions: false,
|
|
skipAttributes: false,
|
|
skipAdvantages: false,
|
|
skipSpecialAbilities: false,
|
|
skipEquipment: false,
|
|
skipSkills: false,
|
|
skipSpells: false,
|
|
skipLiturgies: false
|
|
}
|
|
}
|
|
|
|
let characterJson = this.#mapRawJson(actor, rawJson, options)
|
|
|
|
actor.update(characterJson)
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
* @param dom the XML-Dom from which the json should be extracted
|
|
* @returns {{}} the json parsed from the xml
|
|
*/
|
|
#getJsonFromXML(dom) {
|
|
let children = [...dom.children];
|
|
|
|
// initializing object to be returned.
|
|
let jsonResult = {};
|
|
|
|
let attributes = dom.attributes ? dom.attributes : []
|
|
for (let attribute of attributes) {
|
|
jsonResult[attribute.name] = attribute.value
|
|
}
|
|
|
|
if (children.length) {
|
|
for (let child of children) {
|
|
|
|
// checking is child has siblings of same name.
|
|
let childIsArray = children.filter(eachChild => eachChild.nodeName === child.nodeName).length > 1;
|
|
|
|
// if child is array, save the values as array, else as strings.
|
|
if (childIsArray) {
|
|
if (jsonResult[child.nodeName] === undefined) {
|
|
jsonResult[child.nodeName] = [this.#getJsonFromXML(child)];
|
|
} else {
|
|
jsonResult[child.nodeName].push(this.#getJsonFromXML(child));
|
|
}
|
|
} else {
|
|
jsonResult[child.nodeName] = this.#getJsonFromXML(child);
|
|
}
|
|
}
|
|
}
|
|
|
|
return jsonResult;
|
|
}
|
|
|
|
/**
|
|
* gets the text content of a file
|
|
* @param file the file with the desired content
|
|
* @returns {Promise<String>} a promise that returns the string contents of the file
|
|
*/
|
|
async #parseFileToString(file) {
|
|
return new Promise((resolve, reject) => {
|
|
let reader = new FileReader()
|
|
reader.readAsText(file, "utf-8")
|
|
reader.onload = event => {
|
|
resolve(event.target.result)
|
|
}
|
|
reader.onerror = event => {
|
|
reject(event)
|
|
}
|
|
})
|
|
}
|
|
|
|
|
|
/**
|
|
*Calculates a Birthdate String in the Calendar of Bosparans Fall
|
|
* @param json json with the day, the month and the year of the birthday
|
|
* @returns {string} a string in the format of "DD.MMMM.YYYY BF"
|
|
*/
|
|
#calculateBirthdate(json) {
|
|
let day = json.gbtag
|
|
let month = this.#months[parseInt(json.gbmonat) - 1]
|
|
let year = json.gbjahr
|
|
|
|
return `${day}. ${month} ${year} BF`
|
|
}
|
|
|
|
|
|
/**
|
|
* parses a json into a fitting character-json
|
|
* @param {Character} actor
|
|
* @param rawJson the json parsed from the Helden-Software XML
|
|
* @param {ImportOptions} options
|
|
* @returns {{}} a json representation of the character
|
|
*/
|
|
#mapRawJson(actor, rawJson, options) {
|
|
let json = {}
|
|
let held = rawJson.helden.held;
|
|
json.name = held.name
|
|
json.meta = {}
|
|
if (!options.skipSpecies) this.#mapSpezies(actor, held.basis.rasse) // as string includes the demonymized form
|
|
if (!options.skipCulture) this.#mapKultur(actor, held.basis.kultur) // as string includes the demonymized form
|
|
if (!options.skipProfessions) this.#mapProfessions(actor, held.basis.ausbildungen.ausbildung)
|
|
if (!options.skipMeta) {
|
|
json.meta.geschlecht = held.basis.geschlecht.name
|
|
json.meta.haarfarbe = held.basis.rasse.aussehen.haarfarbe
|
|
json.meta.groesse = held.basis.rasse.groesse.value.replace(",", ".") // fixes localisation
|
|
json.meta.augenfarbe = held.basis.rasse.aussehen.augenfarbe
|
|
json.meta.geburtstag = this.#calculateBirthdate(held.basis.rasse.aussehen)
|
|
json.meta.alter = held.basis.rasse.aussehen.alter
|
|
json.meta.gewicht = held.basis.rasse.groesse.gewicht
|
|
json.meta.aussehen = [
|
|
held.basis.rasse.aussehen.aussehentext0,
|
|
held.basis.rasse.aussehen.aussehentext1,
|
|
held.basis.rasse.aussehen.aussehentext2,
|
|
held.basis.rasse.aussehen.aussehentext3].join('\n')
|
|
json.meta.familie = [
|
|
held.basis.rasse.aussehen.familietext0,
|
|
held.basis.rasse.aussehen.familietext1,
|
|
held.basis.rasse.aussehen.familietext2,
|
|
held.basis.rasse.aussehen.familietext3,
|
|
held.basis.rasse.aussehen.familietext4,
|
|
held.basis.rasse.aussehen.familietext5].join('\n')
|
|
json.meta.titel = held.basis.rasse.aussehen.titel
|
|
json.meta.stand = held.basis.rasse.aussehen.stand
|
|
}
|
|
if (!options.skipAttributes) {
|
|
let attributes = held.eigenschaften.eigenschaft
|
|
json.attribute = {}
|
|
|
|
if (held.basis.gilde) {
|
|
json.attribute.gilde = held.basis.gilde.name
|
|
}
|
|
json.attribute.mu = this.#getAttributeJson(attributes, "Mut")
|
|
json.attribute.kl = this.#getAttributeJson(attributes, "Klugheit")
|
|
json.attribute.in = this.#getAttributeJson(attributes, "Intuition")
|
|
json.attribute.ch = this.#getAttributeJson(attributes, "Charisma")
|
|
json.attribute.ff = this.#getAttributeJson(attributes, "Fingerfertigkeit")
|
|
json.attribute.ge = this.#getAttributeJson(attributes, "Gewandtheit")
|
|
json.attribute.ko = this.#getAttributeJson(attributes, "Konstitution")
|
|
json.attribute.kk = this.#getAttributeJson(attributes, "Körperkraft")
|
|
json.mr = {
|
|
mod: this.#filterAttribute(attributes, "Magieresistenz").mod
|
|
}
|
|
json.lep = {
|
|
mod: this.#filterAttribute(attributes, "Lebensenergie").mod
|
|
}
|
|
json.aup = {
|
|
mod: this.#filterAttribute(attributes, "Ausdauer").mod
|
|
}
|
|
json.asp = {
|
|
mod: this.#filterAttribute(attributes, "Astralenergie").mod
|
|
}
|
|
json.kap = {
|
|
mod: this.#filterAttribute(attributes, "Karmaenergie").mod
|
|
}
|
|
let attribute = this.#filterAttribute(attributes, "ini")
|
|
json.ini = {
|
|
mod: attribute.mod,
|
|
aktuell: attribute.value
|
|
}
|
|
json.attribute.so = this.#getAttributeJson(attributes, "Sozialstatus")
|
|
}
|
|
if (!options.skipAdvantages) this.#mapAdvantages(actor, held)
|
|
let specialAbilities = []
|
|
let liturgies = []
|
|
for (let specialAbility in held.sf.sonderfertigkeit) {
|
|
specialAbility = held.sf.sonderfertigkeit[specialAbility]
|
|
if (specialAbility.name.startsWith("Liturgie:")) {
|
|
if (!options.skipLiturgies) {
|
|
liturgies.push({
|
|
name: specialAbility.name.replace("Liturgie:", "").trim(),
|
|
})
|
|
}
|
|
} else {
|
|
if (!options.skipSpecialAbilities) {
|
|
let specialAbilityJson = {
|
|
name: specialAbility.name,
|
|
auswahlen: []
|
|
}
|
|
let fields = Object.keys(specialAbility)
|
|
if (fields.length > 1) {
|
|
for (let field in fields) {
|
|
field = fields[field]
|
|
if (field !== "name") {
|
|
let choices = specialAbility[field]
|
|
if (choices.hasOwnProperty("name")) {
|
|
specialAbilityJson.auswahlen.push(choices.name)
|
|
} else {
|
|
for (let choice in choices.wahl) {
|
|
choice = choices.wahl[choice]
|
|
specialAbilityJson.auswahlen.push(choice.value)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
specialAbilities.push(specialAbilityJson)
|
|
}
|
|
}
|
|
}
|
|
this.#mapSpecialAbilities(actor, specialAbilities)
|
|
json.liturgien = liturgies
|
|
|
|
let combatValues = []
|
|
for (let combatValue in held.kampf.kampfwerte) {
|
|
combatValue = held.kampf.kampfwerte[combatValue]
|
|
combatValues.push({
|
|
name: combatValue.name,
|
|
at: combatValue.attacke.value,
|
|
pa: combatValue.parade.value,
|
|
})
|
|
}
|
|
json.kampfwerte = combatValues
|
|
|
|
if (!options.skipSkills) this.#mapSkills(actor, held, combatValues)
|
|
if (!options.skipSpells) this.#mapSpells(actor, held)
|
|
if (!options.skipLiturgies) this.#mapLiturgies(actor, liturgies)
|
|
if (!options.skipEquipment) this.#mapEquipment(actor, held)
|
|
|
|
let notes = []
|
|
for (let note in held.kommentare) {
|
|
note = held.kommentare[note]
|
|
if (note.hasOwnProperty("key")) {
|
|
notes.push({
|
|
key: note.key,
|
|
notiz: note.kommentar,
|
|
})
|
|
}
|
|
}
|
|
json.notizen = notes
|
|
|
|
return {
|
|
name: held.name,
|
|
system: json,
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @param attributes an array with the attributes
|
|
* @param name the name of the chosen attribute
|
|
* @returns {{}} a representation of the chosen Attribute
|
|
*/
|
|
#getAttributeJson(attributes, name) {
|
|
let attribute = this.#filterAttribute(attributes, name)
|
|
return {
|
|
start: parseInt(attribute.value),
|
|
aktuell: parseInt(attribute.value),
|
|
mod: parseInt(attribute.mod),
|
|
}
|
|
}
|
|
|
|
/**
|
|
* filters a given attribute array based on the name of an attribute
|
|
* @param attributes the attribute array
|
|
* @param name the name of the desired attribute
|
|
* @returns {{}} the json of the desired attribute
|
|
*/
|
|
#filterAttribute(attributes, name) {
|
|
return attributes.filter(attribute => attribute.name === name)[0]
|
|
}
|
|
|
|
async #addSkillFromCompendiumByNameToActor(talentName, taw, actor, combatStatistics, attributes) {
|
|
const compendiumOfSkills = game.packs.get('DSA_4-1.Skills');
|
|
const talentId = compendiumOfSkills.index.find(skill => skill.name === talentName)
|
|
if (talentId) {
|
|
|
|
const talent = await compendiumOfSkills.getDocument(talentId._id);
|
|
|
|
try {
|
|
const embeddedDocument = (await actor.createEmbeddedDocuments('Item', [talent]))[0]
|
|
if (talent.system.gruppe === "Kampf") {
|
|
const atbasis = attributes.find(p => p.name === "at").value
|
|
const pabasis = attributes.find(p => p.name === "pa").value
|
|
const combatStatistic = combatStatistics.find(p => p.name === talent.name)
|
|
if (combatStatistic) { // melee with AT/PA values
|
|
let at = combatStatistic.at - atbasis ?? 0
|
|
let pa = combatStatistic.pa - pabasis ?? 0
|
|
embeddedDocument.update({system: {taw, at, pa}});
|
|
} else { // ranged with only AT values which is equal to taw
|
|
embeddedDocument.update({system: {taw: taw, at: taw, pa: null}}); // at is already at raw taw and wasn't influenced by helden-software precalculations
|
|
}
|
|
} else {
|
|
embeddedDocument.update({system: {taw: taw, at: null, pa: null}}); // just regular talent with taw
|
|
}
|
|
} catch (error) {
|
|
console.error(`${talentName} not found in items`, error)
|
|
}
|
|
}
|
|
}
|
|
|
|
async #addAdvantageFromCompendiumByNameToActor(advantageName, advantageValue, actor) {
|
|
const compendiumOfAdvantages = game.packs.get('DSA_4-1.Advantage');
|
|
const advantageId = compendiumOfAdvantages.index.find(skill => skill.name === advantageName)
|
|
if (advantageId) {
|
|
|
|
const advantage = await compendiumOfAdvantages.getDocument(advantageId._id);
|
|
|
|
try {
|
|
const embeddedDocument = (await actor.createEmbeddedDocuments('Item', [advantage]))[0]
|
|
embeddedDocument.update({system: {value: advantageValue}});
|
|
} catch (error) {
|
|
console.error(`${advantageName} not found in items`, error)
|
|
}
|
|
}
|
|
}
|
|
|
|
async #addSpellsFromCompendiumByNameToActor(spellName, zfw, representation, hauszauber, actor) {
|
|
const compendiumOfSpells = game.packs.get('DSA_4-1.Spells');
|
|
const SCREAMING_NAME = spellName.toUpperCase()
|
|
const spellId = compendiumOfSpells.index.find(spell => spell.name === SCREAMING_NAME)
|
|
if (spellId) {
|
|
|
|
const spell = await compendiumOfSpells.getDocument(spellId._id);
|
|
|
|
try {
|
|
const embeddedDocument = (await actor.createEmbeddedDocuments('Item', [spell]))[0]
|
|
embeddedDocument.update({system: {zfw: zfw, hauszauber: hauszauber, repräsentation: representation}});
|
|
} catch (error) {
|
|
console.error(`${spell} not found in items`, error)
|
|
}
|
|
}
|
|
}
|
|
|
|
async #addLiturgiesFromCompendiumByNameToActor(liturgyName, actor) {
|
|
const compendiumOfLiturgies = game.packs.get('DSA_4-1.Liturgies');
|
|
const liturgyId = compendiumOfLiturgies.index.find(liturgy => {
|
|
return liturgy.name === LiturgyData.lookupAlias(liturgyName.split(" (")[0])
|
|
})
|
|
if (liturgyId) {
|
|
|
|
const liturgy = await compendiumOfLiturgies.getDocument(liturgyId._id);
|
|
|
|
try {
|
|
await actor.createEmbeddedDocuments('Item', [liturgy])
|
|
} catch (error) {
|
|
console.error(`${liturgy} not found in items`, error)
|
|
}
|
|
}
|
|
}
|
|
|
|
#mapSkills(actor, held, kampfwerte) {
|
|
if (actor.itemTypes["Skill"].length > 0) {
|
|
actor.itemTypes["Skill"].forEach(s => {
|
|
actor.items.get(s._id).delete()
|
|
})
|
|
}
|
|
if (actor.itemTypes["Blessing"].length > 0) {
|
|
actor.itemTypes["Blessing"].forEach(p => {
|
|
actor.items.get(p._id).delete()
|
|
})
|
|
}
|
|
for (let talent in held.talentliste.talent) {
|
|
talent = held.talentliste.talent[talent]
|
|
|
|
// hook liturgy
|
|
if (talent.name.startsWith("Liturgiekenntnis")) {
|
|
|
|
actor.createEmbeddedDocuments('Item', [
|
|
new Blessing({
|
|
name: talent.name,
|
|
type: "Blessing",
|
|
system: {
|
|
gottheit: new RegExp("\\((.+)\\)").exec(talent.name)[1],
|
|
wert: talent.value
|
|
}
|
|
})
|
|
])
|
|
|
|
} else {
|
|
// proceed
|
|
const eigenschaften = held.eigenschaften.eigenschaft
|
|
this.#addSkillFromCompendiumByNameToActor(talent.name, talent.value, actor, kampfwerte, eigenschaften)
|
|
}
|
|
}
|
|
}
|
|
|
|
#mapAdvantages(actor, held) {
|
|
if (actor.itemTypes["Advantage"].length > 0) {
|
|
actor.itemTypes["Advantage"].forEach(a => {
|
|
actor.items.get(a._id).delete()
|
|
})
|
|
}
|
|
for (let advantage in held.vt.vorteil) {
|
|
advantage = held.vt.vorteil[advantage]
|
|
this.#addAdvantageFromCompendiumByNameToActor(advantage.name, advantage.value, actor)
|
|
}
|
|
}
|
|
|
|
#mapSpells(actor, held) {
|
|
if (actor.itemTypes["Spell"].length > 0) {
|
|
actor.itemTypes["Spell"].forEach(s => {
|
|
actor.items.get(s._id).delete()
|
|
})
|
|
}
|
|
for (let spell in held.zauberliste.zauber) {
|
|
spell = held.zauberliste.zauber[spell]
|
|
this.#addSpellsFromCompendiumByNameToActor(spell.name, spell.value, spell.repraesentation, spell.hauszauber === "true", actor)
|
|
}
|
|
}
|
|
|
|
#mapLiturgies(actor, liturgies) {
|
|
if (actor.itemTypes["Liturgy"].length > 0) {
|
|
actor.itemTypes["Liturgy"].forEach(l => {
|
|
actor.items.get(l._id).delete()
|
|
})
|
|
}
|
|
for (let liturgy in liturgies) {
|
|
liturgy = liturgies[liturgy]
|
|
this.#addLiturgiesFromCompendiumByNameToActor(liturgy.name, actor)
|
|
}
|
|
}
|
|
|
|
#mapEquipment(actor, held) {
|
|
if (actor.itemTypes["Equipment"].length > 0) {
|
|
actor.itemTypes["Equipment"].forEach(e => {
|
|
actor.items.get(e._id).delete()
|
|
})
|
|
}
|
|
let i = 100
|
|
held.gegenstände?.gegenstand?.forEach(e => {
|
|
const compendiumOfArmor = game.packs.get('DSA_4-1.Armor');
|
|
const compendiumOfWeapons = game.packs.get('DSA_4-1.Weapons');
|
|
const compendiumOfAmmunition = game.packs.get('DSA_4-1.Ammunition');
|
|
const compendiumOfItems = game.packs.get('DSA_4-1.Items');
|
|
let eId = null
|
|
let compendium = null
|
|
if (compendiumOfArmor?.index.find(p => p.name === e.name)) {
|
|
eId = compendiumOfArmor?.index.find(p => p.name === e.name)
|
|
compendium = compendiumOfArmor
|
|
}
|
|
if (compendiumOfWeapons?.index.find(p => p.name === e.name)) {
|
|
eId = compendiumOfWeapons?.index.find(p => p.name === e.name)
|
|
compendium = compendiumOfWeapons
|
|
}
|
|
if (compendiumOfAmmunition?.index.find(p => p.name === e.name)) {
|
|
eId = compendiumOfAmmunition?.index.find(p => p.name === e.name)
|
|
compendium = compendiumOfAmmunition
|
|
}
|
|
if (compendiumOfItems?.index.find(p => p.name === e.name)) {
|
|
eId = compendiumOfItems?.index.find(p => p.name === e.name)
|
|
compendium = compendiumOfItems
|
|
}
|
|
|
|
if (eId && compendium) {
|
|
compendium.getDocument(eId._id).then(sf => actor.createEmbeddedDocuments('Item', [sf]))
|
|
} else {
|
|
actor.createEmbeddedDocuments('Item', [new Equipment(
|
|
{
|
|
name: e.modallgemein?.name?.value ?? e.name,
|
|
type: "Equipment",
|
|
sort: (i++) * 100,
|
|
system: {
|
|
quantity: e.anzahl,
|
|
price: e.modallgemein?.preis.value,
|
|
weight: e.modallgemein?.gewicht.value,
|
|
|
|
}
|
|
})
|
|
])
|
|
}
|
|
})
|
|
}
|
|
|
|
async #mapProfessions(actor, professions) {
|
|
if (actor.itemTypes["Profession"].length > 0) {
|
|
actor.itemTypes["Profession"].forEach(p => {
|
|
actor.items.get(p._id).delete()
|
|
})
|
|
}
|
|
if (professions.string) {
|
|
professions = {hauptprofession: professions}
|
|
}
|
|
Object.values(professions).forEach(profession => {
|
|
actor.createEmbeddedDocuments('Item', [
|
|
new Profession({
|
|
name: profession.string,
|
|
type: "Profession",
|
|
system: {
|
|
description: "",
|
|
alias: profession.tarnidentitaet ? profession.tarnidentitaet : profession.string,
|
|
revealed: !profession.tarnidentitaet
|
|
}
|
|
})
|
|
])
|
|
})
|
|
}
|
|
|
|
async #mapSpecialAbilities(actor, specialAbilities) {
|
|
if (actor.itemTypes["SpecialAbility"].length > 0) {
|
|
actor.itemTypes["SpecialAbility"].forEach(s => {
|
|
actor.items.get(s._id).delete()
|
|
})
|
|
}
|
|
specialAbilities.forEach((specialAbility) => {
|
|
const compendiumOfSF = game.packs.get('DSA_4-1.sonderfertigkeiten');
|
|
const regexp = /(\w*)\W?(\w*)?/
|
|
const [variantName, baseAbility, level] = regexp.exec(specialAbility.name)
|
|
const sfId = compendiumOfSF?.index.find(sf => sf.name === baseAbility)
|
|
|
|
if (sfId) {
|
|
if (variantName) {
|
|
console.debug(baseAbility + " to be imported as " + variantName) // TODO if baseAbility already imported, adjust its level instead of adding a new embeddedDocument
|
|
}
|
|
compendiumOfSF.getDocument(sfId._id).then(sf => {
|
|
actor.createEmbeddedDocuments('Item', [sf]).then(_ => {
|
|
actor.itemTypes["SpecialAbility"].find(p => p.name === baseAbility).update({
|
|
"system.value": variantName
|
|
})
|
|
})
|
|
})
|
|
} else {
|
|
actor.createEmbeddedDocuments('Item', [
|
|
new SpecialAbility({
|
|
name: specialAbility.name,
|
|
type: "SpecialAbility",
|
|
system: {
|
|
description: specialAbility.auswahl?.wahl?.join("\n"),
|
|
}
|
|
})
|
|
])
|
|
}
|
|
})
|
|
|
|
}
|
|
|
|
async #mapSpezies(actor, spezies) {
|
|
if (actor.itemTypes["Species"].length > 0) {
|
|
actor.itemTypes["Species"].forEach(s => {
|
|
actor.items.get(s._id).delete()
|
|
})
|
|
}
|
|
const compendiumOfSpecies = game.packs.get('DSA_4-1.Species');
|
|
const speciesId = compendiumOfSpecies?.index.find(species => species.name === spezies.name)?._id
|
|
|
|
if (speciesId) {
|
|
const species =
|
|
await compendiumOfSpecies.getDocument(speciesId);
|
|
try {
|
|
await actor.createEmbeddedDocuments('Item', [species])
|
|
} catch (e) {
|
|
}
|
|
} else {
|
|
actor.createEmbeddedDocuments('Item', [
|
|
new Species({
|
|
name: spezies.name,
|
|
type: "Species",
|
|
system: {
|
|
feminineDemonym: spezies.string,
|
|
masculineDemonym: spezies.string,
|
|
description: "Importiert",
|
|
}
|
|
})
|
|
])
|
|
}
|
|
|
|
}
|
|
|
|
async #mapKultur(actor, kultur) {
|
|
if (actor.itemTypes["Culture"].length > 0) {
|
|
actor.itemTypes["Culture"].forEach(c => {
|
|
actor.items.get(c._id).delete()
|
|
})
|
|
}
|
|
const compendiumOfCultures = game.packs.get('DSA_4-1.Cultures');
|
|
const cultureId = compendiumOfCultures?.index.find(culture => culture.name === kultur.name)?._id
|
|
|
|
if (cultureId) {
|
|
const culture =
|
|
await compendiumOfCultures.getDocument(cultureId);
|
|
try {
|
|
await actor.createEmbeddedDocuments('Item', [culture])
|
|
} catch (e) {
|
|
}
|
|
} else {
|
|
actor.createEmbeddedDocuments('Item', [
|
|
new Culture({
|
|
name: kultur.name,
|
|
type: "Culture",
|
|
system: {
|
|
variant: kultur.variante?.name ?? kultur.string ?? "",
|
|
feminineDemonym: kultur.string,
|
|
masculineDemonym: kultur.string,
|
|
description: "Importiert",
|
|
}
|
|
})
|
|
])
|
|
}
|
|
|
|
}
|
|
|
|
}
|