/******/ (() => { // webpackBootstrap /******/ "use strict"; var __webpack_exports__ = {}; ;// CONCATENATED MODULE: ./src/constants.js const debouncedReload = foundry.utils.debounce(() => window.location.reload(), 100); const CONSTANTS = { MODULE_NAME: "pathmuncher", MODULE_FULL_NAME: "Pathmuncher", FLAG_NAME: "pathmuncher", SETTINGS: { // Enable options LOG_LEVEL: "log-level", RESTRICT_TO_TRUSTED: "restrict-to-trusted", ADD_VISION_FEATS: "add-vision-feats", USE_CUSTOM_COMPENDIUM_MAPPINGS: "use-custom-compendium-mappings", CUSTOM_COMPENDIUM_MAPPINGS: "custom-compendium-mappings", USE_IMMEDIATE_DEEP_DIVE: "use-immediate-deep-dive", }, FEAT_PRIORITY: [ "Heritage", "Heritage Feat", "Ancestry", "Ancestry Feat", "Background", "Background Feat", "Class Feat", "Skill Feat", "General Feat", "Awarded Feat", ], ACTOR_FLAGS: { pathbuilderId: undefined, addFeats: true, addEquipment: true, addBackground: true, addHeritage: true, addAncestry: true, addSpells: true, adjustBlendedSlots: true, addMoney: true, addTreasure: true, addLores: true, addWeapons: true, addArmor: true, addDeity: true, addName: true, addClass: true, addFamiliars: true, addFormulas: true, }, CORE_COMPENDIUM_MAPPINGS: { feats: ["pf2e.feats-srd"], ancestryFeatures: ["pf2e.ancestryfeatures"], classFeatures: ["pf2e.classfeatures"], actions: ["pf2e.actionspf2e"], spells: ["pf2e-psychic-amps.psychic-psi-cantrips", "pf2e.spells-srd"], classes: ["pf2e.classes",], ancestries: ["pf2e.ancestries",], heritages: ["pf2e.heritages"], equipment: ["pf2e.equipment-srd"], formulas: ["pf2e.equipment-srd"], deities: ["pf2e.deities"], backgrounds: ["pf2e.backgrounds"], }, GET_DEFAULT_SETTINGS() { return foundry.utils.deepClone(CONSTANTS.DEFAULT_SETTINGS); }, }; CONSTANTS.DEFAULT_SETTINGS = { // Enable options [CONSTANTS.SETTINGS.RESTRICT_TO_TRUSTED]: { name: `${CONSTANTS.FLAG_NAME}.Settings.RestrictToTrusted.Name`, hint: `${CONSTANTS.FLAG_NAME}.Settings.RestrictToTrusted.Hint`, scope: "world", config: true, type: Boolean, default: false, onChange: debouncedReload, }, [CONSTANTS.SETTINGS.USE_CUSTOM_COMPENDIUM_MAPPINGS]: { name: `${CONSTANTS.FLAG_NAME}.Settings.UseCustomCompendiumMappings.Name`, scope: "world", config: false, type: Boolean, default: false, }, [CONSTANTS.SETTINGS.USE_IMMEDIATE_DEEP_DIVE]: { name: `${CONSTANTS.FLAG_NAME}.Settings.UseImmediateDeepDive.Name`, scope: "world", config: false, type: Boolean, default: true, }, [CONSTANTS.SETTINGS.CUSTOM_COMPENDIUM_MAPPINGS]: { scope: "world", config: false, type: Object, default: { feats: [ "battlezoo-ancestries-dragons-pf2e.pf2e-battlezoo-dragon-feats", "battlezoo-ancestries-year-of-monsters-pf2e.yom-features", "battlezoo-ancestries-year-of-monsters-pf2e.yom-feats", "clerics.clerics-feats", "clerics.clerics-features", "pf2e.feats-srd" ], ancestryFeatures: [ "battlezoo-ancestries-year-of-monsters-pf2e.yom-features", "pf2e.ancestryfeatures", ], classFeatures: [ "battlezoo-ancestries-year-of-monsters-pf2e.yom-features", "battlezoo-ancestries-dragons-pf2e.pf2e-battlezoo-dragon-feats", "battlezoo-ancestries-year-of-monsters-pf2e.yom-feats", "clerics.clerics-doctrines", "clerics.clerics-feats", "clerics.clerics-features", "pf2e.classfeatures", ], actions: ["pf2e.actionspf2e"], spells: ["pf2e-psychic-amps.psychic-psi-cantrips", "pf2e.spells-srd"], classes: ["clerics.clerics-features", "pf2e.classes",], ancestries: [ "battlezoo-ancestries-dragons-pf2e.pf2e-battlezoo-dragon-ancestry", "battlezoo-ancestries-year-of-monsters-pf2e.yom-ancestries", "pf2e.ancestries", ], heritages: [ "battlezoo-ancestries-dragons-pf2e.pf2e-battlezoo-dragon-heritages", "battlezoo-ancestries-year-of-monsters-pf2e.yom-heritages", "pf2e.heritages", ], equipment: [ "battlezoo-ancestries-dragons-pf2e.pf2e-battlezoo-dragon-equipment", "battlezoo-ancestries-year-of-monsters-pf2e.yom-equipment", "pf2e.equipment-srd" ], formulas: ["pf2e.equipment-srd"], deities: ["clerics.clerics-deities", "pf2e.deities"], backgrounds: ["pf2e.backgrounds"], }, }, [CONSTANTS.SETTINGS.ADD_VISION_FEATS]: { name: `${CONSTANTS.FLAG_NAME}.Settings.AddVisionFeats.Name`, hint: `${CONSTANTS.FLAG_NAME}.Settings.AddVisionFeats.Hint`, scope: "player", config: true, type: Boolean, default: true, }, // debug [CONSTANTS.SETTINGS.LOG_LEVEL]: { name: `${CONSTANTS.FLAG_NAME}.Settings.LogLevel.Name`, hint: `${CONSTANTS.FLAG_NAME}.Settings.LogLevel.Hint`, scope: "world", config: true, type: String, choices: { DEBUG: `${CONSTANTS.FLAG_NAME}.Settings.LogLevel.debug`, INFO: `${CONSTANTS.FLAG_NAME}.Settings.LogLevel.info`, WARN: `${CONSTANTS.FLAG_NAME}.Settings.LogLevel.warn`, ERR: `${CONSTANTS.FLAG_NAME}.Settings.LogLevel.error`, OFF: `${CONSTANTS.FLAG_NAME}.Settings.LogLevel.off`, }, default: "WARN", } }; CONSTANTS.PATH = `modules/${CONSTANTS.MODULE_NAME}`; /* harmony default export */ const constants = (CONSTANTS); ;// CONCATENATED MODULE: ./src/utils.js const utils = { isObject: (obj) => { return typeof obj === 'object' && !Array.isArray(obj) && obj !== null; }, isString: (str) => { return typeof str === 'string' || str instanceof String; }, wait: async (ms) => { return new Promise((resolve) => { setTimeout(resolve, ms); }); }, capitalize: (s) => { if (typeof s !== "string") return ""; return s.charAt(0).toUpperCase() + s.slice(1); }, setting: (key) => { return game.settings.get(constants.MODULE_NAME, constants.SETTINGS[key]); }, updateSetting: async (key, value) => { return game.settings.set(constants.MODULE_NAME, constants.SETTINGS[key], value); }, getFlags: (actor) => { const flags = actor.flags[constants.FLAG_NAME] ? actor.flags[constants.FLAG_NAME] : constants.ACTOR_FLAGS; return flags; }, setFlags: async (actor, flags) => { let updateData = {}; setProperty(updateData, `flags.${constants.FLAG_NAME}`, flags); await actor.update(updateData); return actor; }, resetFlags: async (actor) => { return utils.setFlags(actor, null); }, getOrCreateFolder: async (root, entityType, folderName, folderColor = "") => { let folder = game.folders.contents.find((f) => f.type === entityType && f.name === folderName // if a root folder we want to match the root id for the parent folder && (root ? root.id : null) === (f.folder?.id ?? null) ); // console.warn(`Looking for ${root} ${entityType} ${folderName}`); // console.warn(folder); if (folder) return folder; folder = await Folder.create( { name: folderName, type: entityType, color: folderColor, parent: (root) ? root.id : null, }, { displaySheet: false } ); return folder; }, // eslint-disable-next-line no-unused-vars getFolder: async (kind, subFolder = "", baseFolderName = "Pathmuncher", baseColor = "#6f0006", subColor = "#98020a", typeFolder = true) => { let entityTypes = new Map(); entityTypes.set("pets", "Pets"); const folderName = game.i18n.localize(`${constants.MODULE_NAME}.labels.${kind}`); const entityType = entityTypes.get(kind); const baseFolder = await utils.getOrCreateFolder(null, entityType, baseFolderName, baseColor); const entityFolder = typeFolder ? await utils.getOrCreateFolder(baseFolder, entityType, folderName, subColor) : baseFolder; if (subFolder !== "") { const subFolderName = subFolder.charAt(0).toUpperCase() + subFolder.slice(1); const typeFolder = await utils.getOrCreateFolder(entityFolder, entityType, subFolderName, subColor); return typeFolder; } else { return entityFolder; } }, }; /* harmony default export */ const src_utils = (utils); ;// CONCATENATED MODULE: ./src/logger.js const logger = { _showMessage: (logLevel, data) => { if (!logLevel || !data || typeof logLevel !== "string") { return false; } const setting = src_utils.setting("LOG_LEVEL"); const logLevels = ["DEBUG", "INFO", "WARN", "ERR", "OFF"]; const logLevelIndex = logLevels.indexOf(logLevel.toUpperCase()); if (setting == "OFF" || logLevelIndex === -1 || logLevelIndex < logLevels.indexOf(setting)) { return false; } return true; }, log: (logLevel, ...data) => { if (!logger._showMessage(logLevel, data)) { return; } logLevel = logLevel.toUpperCase(); let msg = "No logging message provided. Please see the payload for more information."; let payload = data.slice(); if (data[0] && typeof (data[0] == "string")) { msg = data[0]; if (data.length > 1) { payload = data.slice(1); } else { payload = null; } } msg = `${constants.MODULE_NAME} | ${logLevel} > ${msg}`; switch (logLevel) { case "DEBUG": if (payload) { console.debug(msg, ...payload); // eslint-disable-line no-console } else { console.debug(msg); // eslint-disable-line no-console } break; case "INFO": if (payload) { console.info(msg, ...payload); // eslint-disable-line no-console } else { console.info(msg); // eslint-disable-line no-console } break; case "WARN": if (payload) { console.warn(msg, ...payload); // eslint-disable-line no-console } else { console.warn(msg); // eslint-disable-line no-console } break; case "ERR": if (payload) { console.error(msg, ...payload); // eslint-disable-line no-console } else { console.error(msg); // eslint-disable-line no-console } break; default: break; } }, debug: (...data) => { logger.log("DEBUG", ...data); }, info: (...data) => { logger.log("INFO", ...data); }, warn: (...data) => { logger.log("WARN", ...data); }, error: (...data) => { logger.log("ERR", ...data); }, }; /* harmony default export */ const src_logger = (logger); ;// CONCATENATED MODULE: ./src/data/equipment.js const SWAPS = [ /^(Greater) (.*)/, /^(Lesser) (.*)/, /^(Major) (.*)/, /^(Moderate) (.*)/, /^(Standard) (.*)/, ]; // this equipment is named differently in foundry vs pathbuilder const EQUIPMENT_RENAME_STATIC_MAP = [ { pbName: "Chain", foundryName: "Chain (10 feet)" }, { pbName: "Oil", foundryName: "Oil (1 pint)" }, { pbName: "Bracelets of Dashing", foundryName: "Bracelet of Dashing" }, { pbName: "Fingerprinting Kit", foundryName: "Fingerprint Kit" }, { pbName: "Ladder", foundryName: "Ladder (10-foot)" }, { pbName: "Mezmerizing Opal", foundryName: "Mesmerizing Opal" }, { pbName: "Explorer's Clothing", foundryName: "Clothing (Explorer's)" }, { pbName: "Flaming Star (Greater)", foundryName: "Greater Flaming Star" }, { pbName: "Potion of Lesser Darkvision", foundryName: "Darkvision Elixir (Lesser)" }, { pbName: "Potion of Greater Darkvision", foundryName: "Darkvision Elixir (Greater)" }, { pbName: "Potion of Moderate Darkvision", foundryName: "Darkvision Elixir (Moderate)" }, { pbName: "Bottled Sunlight", foundryName: "Formulated Sunlight" }, { pbName: "Magazine (Repeating Hand Crossbow)", foundryName: "Magazine with 5 Bolts" }, { pbName: "Astrolabe (Standard)", foundryName: "Standard Astrolabe" }, { pbName: "Skinitch Salve", foundryName: "Skinstitch Salve" }, { pbName: "Flawless Scale", foundryName: "Abadar's Flawless Scale" }, { pbName: "Construct Key", foundryName: "Cordelia's Construct Key" }, { pbName: "Construct Key (Greater)", foundryName: "Cordelia's Greater Construct Key" }, { pbName: "Lesser Swapping Stone", foundryName: "Lesser Bonmuan Swapping Stone" }, { pbName: "Major Swapping Stone", foundryName: "Major Bonmuan Swapping Stone" }, { pbName: "Moderate Swapping Stone", foundryName: "Moderate Bonmuan Swapping Stone" }, { pbName: "Greater Swapping Stone", foundryName: "Greater Bonmuan Swapping Stone" }, { pbName: "Heartstone", foundryName: "Skarja's Heartstone" }, { pbName: "Bullets (10 rounds)", foundryName: "Sling Bullets" }, { pbName: "Hide", foundryName: "Hide Armor" }, { pbName: "Soverign Glue", foundryName: "Sovereign Glue" }, ]; function generateDynamicNames(pbName) { const result = []; // if we have a hardcoded map, don't return here for (const reg of SWAPS) { const match = pbName.match(reg); if (match) { result.push({ pbName, foundryName: `${match[2]} (${match[1]})`, details: match[2] }); } } return result; } function EQUIPMENT_RENAME_MAP(pbName = null) { const postfixNames = pbName ? generateDynamicNames(pbName) : []; return postfixNames.concat(EQUIPMENT_RENAME_STATIC_MAP); } // this is equipment is special and shouldn't have the transformations applied to it const RESTRICTED_EQUIPMENT = [ "Bracers of Armor", ]; const IGNORED_EQUIPMENT = [ "Unarmored" ]; ;// CONCATENATED MODULE: ./src/data/features.js // these are features which are named differently in pathbuilder to foundry const POSTFIX_PB_REMOVALS = [ /(.*) (Racket)$/, /(.*) (Style)$/, /(.*) (Initiate Benefit)$/, // Cleric + /(.*) (Doctrine)$/, /(.*) (Element)$/, /(.*) (Impulse Junction)$/, /(.*) (Gate Junction:).*$/, ]; const PREFIX_PB_REMOVALS = [ /^(Arcane Thesis): (.*)/, /^(Arcane School): (.*)/, /^(The) (.*)/, // Cleric + /^(Blessing): (.*)/, ]; const POSTFIX_PB_SPLIT_AND_KEEP = [ /(.*) (Impulse Junction)$/, /(.*) Gate Junction: (.*)$/, ]; const PARENTHESIS = [ /^(.*) \((.*)\)$/, ]; const SPLITS = [ /^(.*): (.*)/, ]; const features_SWAPS = [ /^(Greater) (.*)/, /^(Lesser) (.*)/, /^(Major) (.*)/, ]; const FEAT_RENAME_STATIC_MAP = [ { pbName: "Academic", foundryName: "Ustalavic Academic" }, { pbName: "Academic (Arcana)", foundryName: "Magaambya Academic" }, { pbName: "Academic (Nature)", foundryName: "Magaambya Academic" }, { pbName: "Aerialist", foundryName: "Shory Aerialist" }, { pbName: "Aeromancer", foundryName: "Shory Aeromancer" }, { pbName: "Ancient-Blooded", foundryName: "Ancient-Blooded Dwarf" }, { pbName: "Antipaladin [Chaotic Evil]", foundryName: "Antipaladin" }, { pbName: "Ape", foundryName: "Ape Animal Instinct" }, { pbName: "Aquatic Eyes (Darkvision)", foundryName: "Aquatic Eyes" }, { pbName: "Astrology", foundryName: "Saoc Astrology" }, { pbName: "Battle Ready", foundryName: "Battle-Ready Orc" }, { pbName: "Bite (Gnoll)", foundryName: "Bite" }, { pbName: "Bloodline: Genie (Efreeti)", foundryName: "Bloodline: Genie" }, { pbName: "Bloody Debilitations", foundryName: "Bloody Debilitation" }, { pbName: "Canoneer", foundryName: "Cannoneer" }, { pbName: "Cave Climber Kobold", foundryName: "Caveclimber Kobold" }, { pbName: "Child of Squalor", foundryName: "Child of the Puddles" }, { pbName: "Chosen One", foundryName: "Chosen of Lamashtu" }, { pbName: "Cognative Mutagen (Greater)", foundryName: "Cognitive Mutagen (Greater)" }, { pbName: "Cognative Mutagen (Lesser)", foundryName: "Cognitive Mutagen (Lesser)" }, { pbName: "Cognative Mutagen (Major)", foundryName: "Cognitive Mutagen (Major)" }, { pbName: "Cognative Mutagen (Moderate)", foundryName: "Cognitive Mutagen (Moderate)" }, { pbName: "Cognitive Crossover", foundryName: "Kreighton's Cognitive Crossover" }, { pbName: "Collegiate Attendant Dedication", foundryName: "Magaambyan Attendant Dedication" }, { pbName: "Construct Carver", foundryName: "Tupilaq Carver" }, { pbName: "Cunning Stance", foundryName: "Devrin's Cunning Stance" }, { pbName: "Constructed (Android)", foundryName: "Constructed" }, { pbName: "Dazzling Diversion", foundryName: "Devrin's Dazzling Diversion" }, { pbName: "Deadly Hair", foundryName: "Syu Tak-nwa's Deadly Hair" }, { pbName: "Deepvision", foundryName: "Deep Vision" }, { pbName: "Deflect Arrows", foundryName: "Deflect Arrow" }, { pbName: "Desecrator [Neutral Evil]", foundryName: "Desecrator" }, { pbName: "Detective Dedication", foundryName: "Edgewatch Detective Dedication" }, { pbName: "Duelist Dedication (LO)", foundryName: "Aldori Duelist Dedication" }, { pbName: "Dwarven Hold Education", foundryName: "Dongun Education" }, { pbName: "Ember's Eyes (Darkvision)", foundryName: "Ember's Eyes" }, { pbName: "Enhanced Familiar Feat", foundryName: "Enhanced Familiar" }, { pbName: "Enhanced Fire", foundryName: "Artokus's Fire" }, { pbName: "Enigma", foundryName: "Enigma Muse" }, { pbName: "Escape", foundryName: "Fane's Escape" }, { pbName: "Eye of the Arcane Lords", foundryName: "Eye of the Arclords" }, { pbName: "Flip", foundryName: "Farabellus Flip" }, { pbName: "Fourberie", foundryName: "Fane's Fourberie" }, { pbName: "Ganzi Gaze (Low-Light Vision)", foundryName: "Ganzi Gaze" }, { pbName: "Guild Agent Dedication", foundryName: "Pathfinder Agent Dedication" }, { pbName: "Harmful Font", foundryName: "Divine Font" }, { pbName: "Green Watcher", foundryName: "Greenwatcher" }, { pbName: "Green Watch Initiate", foundryName: "Greenwatch Initiate" }, { pbName: "Green Watch Veteran", foundryName: "Greenwatch Veteran" }, { pbName: "Healing Font", foundryName: "Divine Font" }, { pbName: "Heatwave", foundryName: "Heat Wave" }, { pbName: "Heavenseeker Dedication", foundryName: "Jalmeri Heavenseeker Dedication" }, { pbName: "Heir of the Astrologers", foundryName: "Heir of the Saoc" }, { pbName: "High Killer Training", foundryName: "Vernai Training" }, { pbName: "Ice-Witch", foundryName: "Irriseni Ice-Witch" }, { pbName: "Impeccable Crafter", foundryName: "Impeccable Crafting" }, { pbName: "Incredible Beastmaster's Companion", foundryName: "Incredible Beastmaster Companion" }, { pbName: "Interrogation", foundryName: "Bolera's Interrogation" }, { pbName: "Katana", foundryName: "Katana Weapon Familiarity" }, { pbName: "Liberator [Chaotic Good]", foundryName: "Liberator" }, { pbName: "Lumberjack Dedication", foundryName: "Turpin Rowe Lumberjack Dedication" }, { pbName: "Maestro", foundryName: "Maestro Muse" }, { pbName: "Major Lesson I", foundryName: "Major Lesson" }, { pbName: "Major Lesson II", foundryName: "Major Lesson" }, { pbName: "Major Lesson III", foundryName: "Major Lesson" }, { pbName: "Mantis God's Grip", foundryName: "Achaekek's Grip" }, { pbName: "Marked for Death", foundryName: "Mark for Death" }, { pbName: "Miraculous Spells", foundryName: "Miraculous Spell" }, { pbName: "Multifarious", foundryName: "Multifarious Muse" }, { pbName: "Mystic", foundryName: "Nexian Mystic" }, { pbName: "Paladin [Lawful Good]", foundryName: "Paladin" }, { pbName: "Parry", foundryName: "Aldori Parry" }, { pbName: "Polymath", foundryName: "Polymath Muse" }, { pbName: "Precise Debilitation", foundryName: "Precise Debilitations" }, { pbName: "Prodigy", foundryName: "Merabite Prodigy" }, { pbName: "Quick Climber", foundryName: "Quick Climb" }, { pbName: "Raider", foundryName: "Ulfen Raider" }, { pbName: "Recognise Threat", foundryName: "Recognize Threat" }, { pbName: "Redeemer [Neutral Good]", foundryName: "Redeemer" }, { pbName: "Revivification Protocall", foundryName: "Revivification Protocol" }, { pbName: "Riposte", foundryName: "Aldori Riposte" }, { pbName: "Rkoan Arts", foundryName: "Rokoan Arts" }, { pbName: "Saberteeth", foundryName: "Saber Teeth" }, { pbName: "Scholarly Recollection", foundryName: "Uzunjati Recollection" }, { pbName: "Scholarly Storytelling", foundryName: "Uzunjati Storytelling" }, { pbName: "Shamanic Adherent", foundryName: "Rivethun Adherent" }, { pbName: "Shamanic Disciple", foundryName: "Rivethun Disciple" }, { pbName: "Shamanic Spiritual Attunement", foundryName: "Rivethun Spiritual Attunement" }, { pbName: "Skysage Dedication", foundryName: "Oatia Skysage Dedication" }, { pbName: "Secret Lesson", foundryName: "Janatimo's Lessons" }, { pbName: "Sentry Dedication", foundryName: "Lastwall Sentry Dedication" }, { pbName: "Stab and Snag", foundryName: "Stella's Stab and Snag" }, { pbName: "Tenets of Evil", foundryName: "The Tenets of Evil" }, { pbName: "Tenets of Good", foundryName: "The Tenets of Good" }, { pbName: "Tongue of the Sun and Moon", foundryName: "Tongue of Sun and Moon" }, { pbName: "Tribal Bond", foundryName: "Quah Bond" }, { pbName: "Tyrant [Lawful Evil]", foundryName: "Tyrant" }, { pbName: "Vestigal Wings", foundryName: "Vestigial Wings" }, { pbName: "Virtue-Forged Tattooed", foundryName: "Virtue-Forged Tattoos" }, { pbName: "Wakizashi", foundryName: "Wakizashi Weapon Familiarity" }, { pbName: "Warden", foundryName: "Lastwall Warden" }, { pbName: "Warrior", foundryName: "Warrior Muse" }, { pbName: "Wary Eye", foundryName: "Eye of Ozem" }, { pbName: "Wayfinder Resonance Infiltrator", foundryName: "Westyr's Wayfinder Repository" }, { pbName: "Wind God's Fan", foundryName: "Wind God’s Fan" }, { pbName: "Wind God’s Fan", foundryName: "Wind God's Fan" }, // dragons { pbName: "Black", foundryName: "Black Dragon" }, { pbName: "Brine", foundryName: "Brine Dragon" }, { pbName: "Copper", foundryName: "Copper Dragon" }, { pbName: "Blue", foundryName: "Blue Dragon" }, { pbName: "Bronze", foundryName: "Bronze Dragon" }, { pbName: "Cloud", foundryName: "Cloud Dragon" }, { pbName: "Sky", foundryName: "Sky Dragon" }, { pbName: "Brass", foundryName: "Brass Dragon" }, { pbName: "Underworld", foundryName: "Underworld Dragon" }, { pbName: "Crystal", foundryName: "Crystal Dragon" }, { pbName: "Forest", foundryName: "Forest Dragon" }, { pbName: "Green", foundryName: "Green Dragon" }, { pbName: "Sea", foundryName: "Sea Dragon" }, { pbName: "Silver", foundryName: "Silver Dragon" }, { pbName: "White", foundryName: "White Dragon" }, { pbName: "Sovereign", foundryName: "Sovereign Dragon" }, { pbName: "Umbral", foundryName: "Umbral Dragon" }, { pbName: "Red", foundryName: "Red Dragon" }, { pbName: "Gold", foundryName: "Gold Dragon" }, { pbName: "Magma", foundryName: "Magma Dragon" }, // sizes for fleshwarp { pbName: "Medium", foundryName: "med" }, { pbName: "Small", foundryName: "sm" }, // Cleric + { pbName: "Decree of the Warsworn Ecstacy", foundryName: "Decree of Warsworn Ecstacy" }, { pbName: "Decree of Warsworn Ecstacy", foundryName: "Decree of the Warsworn Ecstacy" }, ]; function features_generateDynamicNames(pbName) { const result = []; // if we have a hardcoded map, don't return here if (FEAT_RENAME_STATIC_MAP.some((e) => e.pbName === pbName)) return result; for (const reg of POSTFIX_PB_REMOVALS) { const match = pbName.match(reg); if (match) { result.push({ pbName, foundryName: match[1], details: match[2] }); } } for (const reg of PREFIX_PB_REMOVALS) { const match = pbName.match(reg); if (match) { result.push({ pbName, foundryName: match[2], details: match[1] }); } } for (const reg of SPLITS) { const match = pbName.match(reg); if (match) { result.push({ pbName, foundryName: match[2], details: match[1] }); } } for (const reg of PARENTHESIS) { const match = pbName.match(reg); if (match) { result.push({ pbName, foundryName: match[1], details: match[2] }); } } for (const reg of features_SWAPS) { const match = pbName.match(reg); if (match) { result.push({ pbName, foundryName: `${match[2]} (${match[1]})`, details: match[2] }); } } return result; } function FEAT_RENAME_MAP(pbName = null) { const postfixNames = pbName ? features_generateDynamicNames(pbName) : []; return postfixNames.concat(FEAT_RENAME_STATIC_MAP); } const SHARED_IGNORE_LIST = [ "Draconic Rage", // just handled by effects on Draconic Instinct "Mirror Initiate Benefit", "Spellstrike Specifics", "Unarmored", "Simple Weapon Expertise", "Spellbook", "Energy Emanation", // pathbuilder does not pass through a type for this "Imprecise Sense", // this gets picked up and added by granted features "Imprecise Scent", // this gets picked up and added by granted features ]; const IGNORED_FEATS_LIST = [ // ignore skills listed as feats "Acrobatics", "Athletics", "Deception", "Intimidation", "Nature", "Performance", "Society", "Survival", "Arcana", "Crafting", "Diplomacy", "Medicine", "Occultism", "Religion", "Stealth", "Thievery", // sizes // "Medium", // "Small", ]; const IGNORED_SPECIALS_LIST = [ ]; function IGNORED_FEATS() { // const visionFeats = utils.setting("ADD_VISION_FEATS") ? [] : ["Low-Light Vision", "Darkvision"]; return IGNORED_FEATS_LIST.concat(SHARED_IGNORE_LIST); } function IGNORED_SPECIALS() { const visionFeats = src_utils.setting("ADD_VISION_FEATS") ? [] : ["Low-Light Vision", "Darkvision"]; return IGNORED_SPECIALS_LIST.concat(SHARED_IGNORE_LIST, visionFeats); } function SPECIAL_NAME_ADDITIONS(specials) { const newSpecials = []; for (const special of specials) { for (const reg of POSTFIX_PB_SPLIT_AND_KEEP) { const match = special.match(reg); if (match) { newSpecials.push(match[2]); } } } return newSpecials; } ;// CONCATENATED MODULE: ./src/data/spells.js const FEAT_SPELLCASTING = [ { name: "Kitsune Spell Familiarity", showSlotless: false, knownSpells: ["Daze", "Forbidding Ward", "Ghost Sound"], preparePBSpells: true, }, { name: "Kitsune Spell Expertise", showSlotless: false, knownSpells: ["Confusion", "Death Ward", "Illusory Scene"], preparePBSpells: true, }, { name: "Kitsune Spell Mysteries", showSlotless: false, knownSpells: ["Bane", "Illusory Object", "Sanctuary"], preparePBSpells: true, }, { name: "Nagaji Spell Familiarity", showSlotless: false, knownSpells: ["Daze", "Detect Magic", "Mage Hand"], preparePBSpells: true, }, { name: "Nagaji Spell Expertise", showSlotless: false, knownSpells: ["Blink", "Control Water", "Subconscious Suggestion"], preparePBSpells: true, }, { name: "Nagaji Spell Mysteries", showSlotless: false, knownSpells: ["Charm", "Fleet Step", "Heal"], preparePBSpells: true, }, { name: "Rat Magic", showSlotless: false, knownSpells: [], preparePBSpells: true, }, ]; const REMASTER_NAMES = [ { pbName: "Scorching Ray", foundryName: "Blazing Bolt" }, { pbName: "Burning Hands", foundryName: "Breathe Fire" }, { pbName: "Calm Emotions", foundryName: "Calm" }, { pbName: "Comprehend Languages", foundryName: "Translate" }, { pbName: "Purify Food and Drink", foundryName: "Cleanse Cuisine" }, { pbName: "Entangle", foundryName: "Entangling Flora" }, { pbName: "Endure Elements", foundryName: "Environmental Endurance" }, { pbName: "Meteor Swarm", foundryName: "Falling Stars" }, { pbName: "Plane Shift", foundryName: "Interplanar Teleport" }, { pbName: "Know Direction", foundryName: "Know the Way" }, { pbName: "Stoneskin", foundryName: "Mountain Resilience" }, { pbName: "Mage Armor", foundryName: "Mystic Armor" }, { pbName: "Tree Stride", foundryName: "Nature's Pathway" }, { pbName: "Barkskin", foundryName: "Oaken Resilience" }, { pbName: "Tree Shape", foundryName: "One with Plants" }, { pbName: "Meld into Stone", foundryName: "One with Stone" }, { pbName: "Gentle Repose", foundryName: "Peaceful Rest" }, { pbName: "Flesh to Stone", foundryName: "Petrify" }, { pbName: "Dimensional Lock", foundryName: "Planar Seal" }, { pbName: "Magic Fang", foundryName: "Runic Body" }, { pbName: "Magic Weapon", foundryName: "Runic Weapon" }, { pbName: "See Invisibility", foundryName: "See the Unseen" }, { pbName: "Longstrider", foundryName: "Tailwind" }, { pbName: "Tanglefoot", foundryName: "Tangle Vine" }, { pbName: "Mage Hand", foundryName: "Telekinetic Hand" }, { pbName: "Dimension Door", foundryName: "Translocate" }, { pbName: "Tongues", foundryName: "Truespeech" }, { pbName: "Gaseous Form", foundryName: "Vapor Form" }, ]; function spellRename(spellName) { if (foundry.utils.isNewerVersion(game.system.version, "5.3.0")) { const remasterName = REMASTER_NAMES.find((remaster) => remaster.pbName === spellName); if (remasterName) { return remasterName.foundryName; } } return spellName; } ;// CONCATENATED MODULE: ./src/app/Seasoning.js /** * This class acts as a wrapper around the renaming data, * and the changing of names for foundry * * When Munching we refer to this as Seasoning the data to taste. * * It's split out just to make it more manageable */ class Seasoning { // sluggify static slug(name) { return game.pf2e.system.sluggify(name); } // sluggify with dromedary casing static slugD(name) { return game.pf2e.system.sluggify(name, { camel: "dromedary" }); } static FEAT_RENAME_MAP(name) { return FEAT_RENAME_MAP(name); } static EQUIPMENT_RENAME_MAP(name) { return EQUIPMENT_RENAME_MAP(name); } static getSpellCastingFeatureAdjustment(name) { return FEAT_SPELLCASTING.find((f) => f.name === name); } static getFoundryEquipmentName(pbName) { return Seasoning.EQUIPMENT_RENAME_MAP(pbName).find((map) => map.pbName == pbName)?.foundryName ?? pbName; } // static getFoundryFeatureName(pbName) { // const match = Seasoning.FEAT_RENAME_MAP(pbName).find((map) => map.pbName == pbName); // return match ?? { pbName, foundryName: pbName, details: undefined }; // } static RESTRICTED_EQUIPMENT() { return RESTRICTED_EQUIPMENT; } // specials that are handled by Foundry and shouldn't be added static IGNORED_FEATS() { return IGNORED_FEATS(); }; static IGNORED_SPECIALS() { return IGNORED_SPECIALS(); } static IGNORED_EQUIPMENT() { return IGNORED_EQUIPMENT; }; static getSizeValue(size) { switch (size) { case 0: return "tiny"; case 1: return "sm"; case 3: return "lg"; default: return "med"; } } static PHYSICAL_ITEM_TYPES = new Set([ "armor", "backpack", "book", "consumable", "equipment", "treasure", "weapon" ]); static isPhysicalItemType(type) { return Seasoning.PHYSICAL_ITEM_TYPES.has(type); } static getMaterialGrade(material) { if (material.toLowerCase().includes("high-grade")) { return "high"; } else if (material.toLowerCase().includes("standard-grade")) { return "standard"; } return "low"; } static getFoundryFeatLocation(pathbuilderFeatType, pathbuilderFeatLevel) { if (pathbuilderFeatType === "Ancestry Feat") { return `ancestry-${pathbuilderFeatLevel}`; } else if (pathbuilderFeatType === "Class Feat") { return `class-${pathbuilderFeatLevel}`; } else if (pathbuilderFeatType === "Skill Feat") { return `skill-${pathbuilderFeatLevel}`; } else if (pathbuilderFeatType === "General Feat") { return `general-${pathbuilderFeatLevel}`; } else if (pathbuilderFeatType === "Background Feat") { return `skill-${pathbuilderFeatLevel}`; } else if (pathbuilderFeatType === "Archetype Feat") { return `archetype-${pathbuilderFeatLevel}`; } else if (pathbuilderFeatType === "Kineticist Feat") { // return as null for now return null; } else { return null; } } static getClassAdjustedSpecialNameLowerCase(name, className) { return `${name} (${className})`.toLowerCase(); } static getDualClassAdjustedSpecialNameLowerCase(name, dualClassName) { return `${name} (${dualClassName})`.toLowerCase(); } static getAncestryAdjustedSpecialNameLowerCase(name, ancestryName) { return `${name} (${ancestryName})`.toLowerCase(); } static getHeritageAdjustedSpecialNameLowerCase(name, heritageName) { return `${name} (${heritageName})`.toLowerCase(); } static getChampionType(alignment) { if (alignment == "LG") return "Paladin"; else if (alignment == "CG") return "Liberator"; else if (alignment == "NG") return "Redeemer"; else if (alignment == "LE") return "Tyrant"; else if (alignment == "CE") return "Antipaladin"; else if (alignment == "NE") return "Desecrator"; return "Unknown"; } } ;// CONCATENATED MODULE: ./src/app/CompendiumMatcher.js /* eslint-disable no-await-in-loop */ class CompendiumMatcher { constructor({ type, mappings = null, indexFields = ["name", "type", "system.slug"] } = {}) { this.type = type; this.indexFields = indexFields; this.packs = {}; const packMappings = mappings !== null ? mappings : src_utils.setting("USE_CUSTOM_COMPENDIUM_MAPPINGS") ? src_utils.setting("CUSTOM_COMPENDIUM_MAPPINGS") : constants.CORE_COMPENDIUM_MAPPINGS; packMappings[type].forEach((name) => { const compendium = game.packs.get(name); if (compendium) { this.packs[name] = compendium; } }); this.indexes = { }; } async loadCompendiums() { for (const [name, compendium] of Object.entries(this.packs)) { this.indexes[name] = await compendium.getIndex({ fields: this.indexFields }); } } getFoundryFeatureName(pbName) { const match = this.FEAT_RENAME_MAP(pbName).find((map) => map.pbName == pbName); return match ?? { pbName, foundryName: pbName, details: undefined }; } getNameMatch(pbName, foundryName) { for (const [packName, index] of Object.entries(this.indexes)) { const indexMatch = index.find((i) => i.name === foundryName) ?? index.find((i) => i.name === pbName); if (indexMatch) { src_logger.debug(`Found name only compendium document for ${pbName} (${foundryName}) in ${packName} with id ${indexMatch._id}`); return { i: indexMatch, pack: this.packs[packName] }; } } return undefined; } getSlugMatch(pbName, foundryName) { for (const [packName, index] of Object.entries(this.indexes)) { src_logger.debug(`Checking for compendium documents for ${pbName} (${foundryName}) in ${packName}`, { pbName, foundryName, packName, // index, // foundrySlug: Seasoning.slug(foundryName), // pbSlug: Seasoning.slug(pbName), // foundryMatch: index.find((i) => (i.system.slug ?? Seasoning.slug(i.name)) === Seasoning.slug(foundryName)), // pbMatch: index.find((i) => (i.system.slug ?? Seasoning.slug(i.name)) === Seasoning.slug(pbName)), // pbSlugMatch: (null ?? Seasoning.slug("Phase Bolt (Psychic)")) === Seasoning.slug("Phase Bolt (Psychic)"), }); const indexMatch = index.find((i) => (i.system.slug ?? Seasoning.slug(i.name)) === Seasoning.slug(foundryName)) ?? index.find((i) => (i.system.slug ?? Seasoning.slug(i.name)) === Seasoning.slug(pbName)); if (indexMatch) { src_logger.debug(`Found slug based compendium document for ${pbName} (${foundryName}) in ${packName} with id ${indexMatch._id}`); return { i: indexMatch, pack: this.packs[packName] }; } } return undefined; } getMatch(pbName, foundryName, forceName = false) { if (forceName) { const nameOnlyMatch = this.getNameMatch(pbName, foundryName); if (nameOnlyMatch) return nameOnlyMatch; } const slugMatch = this.getSlugMatch(pbName, foundryName); if (slugMatch) return slugMatch; return undefined; } static checkForFilters(i, filters) { for (const [key, value] of Object.entries(filters)) { if (getProperty(i, key) !== value) { return false; } } return true; } getNameMatchWithFilter(pbName, foundryName, filters = {}) { for (const [packName, index] of Object.entries(this.indexes)) { src_logger.debug(`Checking for compendium documents for ${pbName} (${foundryName}) in ${packName}`, { pbName, foundryName, filters, packName, // index, }); const indexMatch = index.find((i) => ((i.system.slug ?? Seasoning.slug(i.name)) === Seasoning.slug(foundryName)) && CompendiumMatcher.checkForFilters(i, filters)) ?? index.find((i) => ((i.system.slug ?? Seasoning.slug(i.name)) === Seasoning.slug(pbName) && CompendiumMatcher.checkForFilters(i, filters)) ); if (indexMatch) { src_logger.debug(`Found compendium document for ${pbName} (${foundryName}) in ${packName} with id ${indexMatch._id}`); return { i: indexMatch, pack: this.packs[packName] }; } } return undefined; } } ;// CONCATENATED MODULE: ./src/app/CompendiumSelector.js class CompendiumSelector extends FormApplication { constructor() { super(); this.lookups = src_utils.setting("CUSTOM_COMPENDIUM_MAPPINGS"); this.packs = game.packs .filter((p) => p.metadata.type === "Item") .map((p) => { return { id: p.metadata.id, label: `${p.metadata.label} (${p.metadata.packageName})` }; }); this.currentType = null; this.useCustomCompendiums = src_utils.setting("USE_CUSTOM_COMPENDIUM_MAPPINGS"); } static get defaultOptions() { return mergeObject(super.defaultOptions, { id: "pathmuncher-compendium-selector", template: `${constants.PATH}/templates/compendium-selector.hbs`, width: 722, height: 275, title: game.i18n.localize(`${constants.FLAG_NAME}.Dialogs.CompendiumSelector.Title`), resizable: true, classes: ['pathmuncher-compendium-selector'], }); } getData() { const lookups = []; for (const key in this.lookups) { lookups.push({ key, label: game.i18n.localize(`${constants.FLAG_NAME}.CompendiumGroups.${key}`), }); } return { lookups, title: this.options.title, sourceItems: [], compendiumItems: [], useCustomCompendiums: this.useCustomCompendiums, }; } async reset() { const defaults = constants.GET_DEFAULT_SETTINGS(); this.lookups = defaults[constants.SETTINGS.CUSTOM_COMPENDIUM_MAPPINGS].default; await src_utils.updateSetting("CUSTOM_COMPENDIUM_MAPPINGS", this.lookups); this.currentType = null; this.render(true); } async enableCustomCompendiums() { this.useCustomCompendiums = !this.useCustomCompendiums; await src_utils.updateSetting("USE_CUSTOM_COMPENDIUM_MAPPINGS", this.useCustomCompendiums); } filterList(event) { const compendiumType = event.srcElement.value; const sourceList = document.getElementById("sourceList"); const compendiumList = document.getElementById("compendiumList"); const sourceOptions = this.packs.filter((p) => !this.lookups[compendiumType].includes(p.id)); const compendiumOptions = this.packs.filter((p) => this.lookups[compendiumType].includes(p.id)); sourceList.innerHTML = ""; compendiumList.innerHTML = ""; sourceOptions.forEach((option) => { const sourceListItem = document.createElement("option"); sourceListItem.value = option.id; sourceListItem.appendChild(document.createTextNode(option.label)); sourceList.appendChild(sourceListItem); }); compendiumOptions.forEach((option) => { const compendiumListItem = document.createElement("option"); compendiumListItem.value = option.id; compendiumListItem.appendChild(document.createTextNode(option.label)); compendiumList.appendChild(compendiumListItem); }); this.currentType = compendiumType; } async updateCompendiums() { const compendiumList = document.getElementById("compendiumList"); const compendiumOptions = Array.from(compendiumList.options); const compendiumIds = compendiumOptions.map((option) => { return option.value; }); this.lookups[this.currentType] = compendiumIds; src_utils.updateSetting("CUSTOM_COMPENDIUM_MAPPINGS", this.lookups); } async addCompendium() { const sourceList = document.getElementById("sourceList"); const compendiumList = document.getElementById("compendiumList"); const selectedOptions = Array.from(sourceList.selectedOptions); selectedOptions.forEach((option) => { compendiumList.appendChild(option); }); await this.updateCompendiums(); } async removeCompendium() { const sourceList = document.getElementById("sourceList"); const compendiumList = document.getElementById("compendiumList"); const selectedOptions = Array.from(compendiumList.selectedOptions); selectedOptions.forEach((option) => { sourceList.appendChild(option); }); await this.updateCompendiums(); } async moveUp() { const compendiumList = document.getElementById("compendiumList"); const selectedOption = compendiumList.selectedOptions[0]; if (selectedOption && selectedOption.previousElementSibling) { compendiumList.insertBefore(selectedOption, selectedOption.previousElementSibling); } await this.updateCompendiums(); } async moveDown() { const compendiumList = document.getElementById("compendiumList"); const selectedOption = compendiumList.selectedOptions[0]; if (selectedOption && selectedOption.nextElementSibling) { compendiumList.insertBefore(selectedOption.nextElementSibling, selectedOption); } await this.updateCompendiums(); } activateListeners(html) { super.activateListeners(html); document.getElementById("addButton").addEventListener("click", this.addCompendium.bind(this)); document.getElementById("removeButton").addEventListener("click", this.removeCompendium.bind(this)); document.getElementById("upButton").addEventListener("click", this.moveUp.bind(this)); document.getElementById("downButton").addEventListener("click", this.moveDown.bind(this)); document.getElementById("compSelector").addEventListener("change", this.filterList.bind(this)); document.getElementById("resetButton").addEventListener("click", this.reset.bind(this)); document.getElementById("enableCustomCompendiums").addEventListener("change", this.enableCustomCompendiums.bind(this)); } } ;// CONCATENATED MODULE: ./src/app/Pathmuncher.js /* eslint-disable no-await-in-loop */ /* eslint-disable no-continue */ class Pathmuncher { FEAT_RENAME_MAP(name) { const dynamicItems = [ { pbName: "Shining Oath", foundryName: `Shining Oath (${Seasoning.getChampionType(this.source.alignment)})` }, { pbName: "Counterspell", foundryName: `Counterspell (${src_utils.capitalize(this.getClassSpellCastingType() ?? "")})` }, { pbName: "Counterspell", foundryName: `Counterspell (${src_utils.capitalize(this.getClassSpellCastingType(true) ?? "")})` }, { pbName: "Cantrip Expansion", foundryName: `Cantrip Expansion (${this.source.class})` }, { pbName: "Cantrip Expansion", foundryName: `Cantrip Expansion (${this.source.dualClass})` }, { pbName: "Cantrip Expansion", foundryName: `Cantrip Expansion (${src_utils.capitalize(this.getClassSpellCastingType() ?? "")} Caster)` }, { pbName: "Cantrip Expansion", foundryName: `Cantrip Expansion (${src_utils.capitalize(this.getClassSpellCastingType(true) ?? "")} Caster)` }, ]; return Seasoning.FEAT_RENAME_MAP(name).concat(dynamicItems); } getFoundryFeatureName(pbName) { const match = this.FEAT_RENAME_MAP(pbName).find((map) => map.pbName == pbName); return match ?? { pbName, foundryName: pbName, details: undefined }; } constructor(actor, { addFeats = true, addEquipment = true, addSpells = true, adjustBlendedSlots = true, addMoney = true, addLores = true, addWeapons = true, addArmor = true, addTreasure = true, addDeity = true, addName = true, addClass = true, addBackground = true, addHeritage = true, addAncestry = true, statusCallback = null } = {} ) { this.actor = actor; // note not all these options do anything yet! this.options = { addTreasure, addMoney, addFeats, addSpells, adjustBlendedSlots, addEquipment, addLores, addWeapons, addArmor, addDeity, addName, addClass, addBackground, addHeritage, addAncestry, }; this.source = null; this.parsed = { specials: [], feats: [], equipment: [], armor: [], weapons: [], }; this.usedLocations = new Set(); this.usedLocationsAlternateRules = new Set(); this.autoAddedFeatureIds = new Set(); this.autoAddedFeatureItems = {}; this.promptRules = {}; this.allFeatureRules = {}; this.autoAddedFeatureRules = {}; this.grantItemLookUp = {}; this.autoFeats = []; this.keyAbility = null; this.boosts = { custom: false, class: {}, background: {}, ancestry: {}, }; this.size = "med"; this.result = { character: { _id: this.actor.id, prototypeToken: {}, }, class: [], deity: [], heritage: [], ancestry: [], background: [], casters: [], spells: [], feats: [], weapons: [], armor: [], equipment: [], lores: [], money: [], treasure: [], adventurersPack: { item: null, contents: [ { slug: "bedroll", qty: 1 }, { slug: "chalk", qty: 10 }, { slug: "flint-and-steel", qty: 1 }, { slug: "rope", qty: 1 }, { slug: "rations", qty: 14 }, { slug: "torch", qty: 5 }, { slug: "waterskin", qty: 1 }, ], }, focusPool: 0, }; this.check = {}; this.bad = []; this.statusCallback = statusCallback; this.compendiumMatchers = {}; const compendiumMappings = src_utils.setting("USE_CUSTOM_COMPENDIUM_MAPPINGS") ? src_utils.setting("CUSTOM_COMPENDIUM_MAPPINGS") : constants.CORE_COMPENDIUM_MAPPINGS; for (const type of Object.keys(compendiumMappings)) { this.compendiumMatchers[type] = new CompendiumMatcher({ type }); } } async #loadCompendiumMatchers() { for (const matcher of Object.values(this.compendiumMatchers)) { await matcher.loadCompendiums(); } } #statusUpdate(total, count, type, prefixLabel) { if (this.statusCallback) this.statusCallback(total, count, type, prefixLabel); } async fetchPathbuilder(pathbuilderId) { if (!pathbuilderId) { const flags = src_utils.getFlags(this.actor); pathbuilderId = flags?.pathbuilderId; } if (pathbuilderId) { const jsonData = await foundry.utils.fetchJsonWithTimeout( `https://www.pathbuilder2e.com/json.php?id=${pathbuilderId}` ); if (jsonData.success) { this.source = jsonData.build; } else { ui.notifications.warn( game.i18n.format(`${constants.FLAG_NAME}.Dialogs.Pathmuncher.FetchFailed`, { pathbuilderId }) ); } } else { ui.notifications.error(game.i18n.localize(`${constants.FLAG_NAME}.Dialogs.Pathmuncher.NoId`)); } } #generateFoundryFeatLocation(document, feature) { if (feature.type && feature.level) { const ancestryParagonVariant = game.settings.get("pf2e", "ancestryParagonVariant"); const dualClassVariant = game.settings.get("pf2e", "dualClassVariant"); // const freeArchetypeVariant = game.settings.get("pf2e", "freeArchetypeVariant"); const location = Seasoning.getFoundryFeatLocation(feature.type, feature.level); if (location && !this.usedLocations.has(location)) { document.system.location = location; this.usedLocations.add(location); } else if (location && this.usedLocations.has(location)) { src_logger.debug("Variant feat location", { ancestryParagonVariant, location, feature }); // eslint-disable-next-line max-depth if (ancestryParagonVariant && feature.type === "Ancestry Feat") { document.system.location = "ancestry-bonus"; this.usedLocationsAlternateRules.add(location); } else if (dualClassVariant && feature.type === "Class Feat") { document.system.location = `dualclass-${feature.level}`; this.usedLocationsAlternateRules.add(location); } } } } #processSpecialData(name) { if (name.includes("Domain: ")) { const domainName = name.split(" ")[1]; this.parsed.feats.push({ name: "Deity's Domain", extra: domainName }); return true; } else { return false; } } #getContainerData(key) { return { id: key, containerName: this.source.equipmentContainers[key].containerName, bagOfHolding: this.source.equipmentContainers[key].bagOfHolding, backpack: this.source.equipmentContainers[key].backpack, }; } #nameMap() { src_logger.debug("Starting Equipment Rename"); this.source.equipment .filter((e) => e[0] && e[0] !== "undefined") .forEach((e) => { const name = Seasoning.getFoundryEquipmentName(e[0]); const containerKey = Object.keys(this.source.equipmentContainers) .find((key) => this.source.equipmentContainers[key].containerName === name); const container = containerKey ? this.#getContainerData(containerKey) : null; const foundryId = foundry.utils.randomID(); if (container) { this.source.equipmentContainers[containerKey].foundryId = foundryId; } const item = { pbName: name, qty: e[1], added: false, addedId: null, addedAutoId: null, inContainer: e[2] !== "Invested" ? e[2] : null, container, foundryId, invested: e[2] === "Invested", }; this.parsed.equipment.push(item); }); this.source.armor .filter((e) => e && e !== "undefined") .forEach((e) => { const name = Seasoning.getFoundryEquipmentName(e.name); const item = mergeObject({ pbName: name, originalName: e.name, added: false, addedId: null, addedAutoId: null, }, e); this.parsed.armor.push(item); }); this.source.weapons .filter((e) => e && e !== "undefined") .forEach((e) => { const name = Seasoning.getFoundryEquipmentName(e.name); const item = mergeObject({ pbName: name, originalName: e.name, added: false, addedId: null, addedAutoId: null, }, e); this.parsed.weapons.push(item); }); src_logger.debug("Finished Equipment Rename"); let i = 0; src_logger.debug("Starting Special Rename"); [].concat(this.source.specials, SPECIAL_NAME_ADDITIONS(this.source.specials)) .filter((special) => special && special !== "undefined" && special !== "Not Selected" && special !== this.source.heritage ) .forEach((special) => { const name = this.getFoundryFeatureName(special).foundryName; if (!this.#processSpecialData(name) && !Seasoning.IGNORED_SPECIALS().includes(name)) { this.parsed.specials.push({ name, originalName: special, added: false, addedId: null, addedAutoId: null, rank: i }); i++; } }); src_logger.debug("Finished Special Rename"); let y = 0; src_logger.debug("Starting Feat Rename"); this.source.feats .filter((feat) => feat[0] && feat[0] !== "undefined" && feat[0] !== "Not Selected" // && feat[0] !== this.source.heritage ) .forEach((feat) => { const name = this.getFoundryFeatureName(feat[0]).foundryName; const data = { name, extra: feat[1], added: feat[0] === this.source.heritage, addedId: null, addedAutoId: null, type: feat[2], level: feat[3], originalName: feat[0], rank: y, }; this.parsed.feats.push(data); y++; }); src_logger.debug("Finished Feat Rename"); src_logger.debug("Name remapping results", { parsed: this.parsed, }); } #fixUps() { if (this.source.ancestry === "Dwarf" && !this.parsed.feats.some((f) => f.name === "Clan Pistol")) { const clanDagger = { name: "Clan Dagger", originalName: "Clan Dagger", added: false, addedId: null, addedAutoId: null, isChoice: true, rank: 0, }; this.parsed.specials.push(clanDagger); } const match = this.source.background.match(/(Magical Experiment) \((.*)\)$/); if (match) { this.parsed.specials.push({ name: match[2], originalName: `${this.source.background}`, added: false, addedId: null, addedAutoId: null, isChoice: true, rank: 0, }); this.source.background = match[1]; } } async #prepare() { await this.#loadCompendiumMatchers(); this.#nameMap(); this.#fixUps(); } async #processSenses() { const senses = []; this.source.specials.forEach((special) => { if (special === "Low-Light Vision") { senses.push({ type: "lowLightVision" }); } else if (special === "Darkvision") { senses.push({ type: "darkvision" }); } else if (special === "Scent") { senses.push({ type: "scent" }); } }); setProperty(this.result.character, "system.traits.senses", senses); } async #addDualClass(klass) { if (!game.settings.get("pf2e", "dualClassVariant")) { if (this.source.dualClass && this.source.dualClass !== "") { src_logger.warn(`Imported character is dual class but system is not configured for dual class`, { class: this.source.class, dualClass: this.source.dualClass, }); ui.notifications.warn(`Imported character is dual class but system is not configured for dual class`); } return; } if (!this.source.dualClass || this.source.dualClass === "") { src_logger.warn(`Imported character not dual class but system is configured for dual class`, { class: this.source.class, }); ui.notifications.warn(`Imported character not dual class but system is configured for dual class`); return; } // find the dual class const foundryName = this.getFoundryFeatureName(this.source.dualClass).foundryName; const indexMatch = this.compendiumMatchers["classes"].getMatch(this.source.dualClass, foundryName); if (!indexMatch) return; const doc = await indexMatch.pack.getDocument(indexMatch.i._id); const dualClass = doc.toObject(); src_logger.debug(`Dual Class ${dualClass.name} found, squashing things together.`); klass.name = `${klass.name} - ${dualClass.name}`; const ruleEntry = { domain: "all", key: "RollOption", option: `class:${dualClass.system.slug}`, }; // Attacks ["advanced", "martial", "simple", "unarmed"].forEach((key) => { if (dualClass.system.attacks[key] > klass.system.attacks[key]) { klass.system.attacks[key] = dualClass.system.attacks[key]; } }); if (klass.system.attacks.martial <= dualClass.system.attacks.other.rank) { if (dualClass.system.attacks.other.rank === klass.system.attacks.other.rank) { let mashed = `${klass.system.attacks.other.name}, ${dualClass.system.attacks.other.name}`; mashed = mashed.replace("and ", ""); klass.system.attacks.other.name = [...new Set(mashed.split(","))].join(","); } if (dualClass.system.attacks.other.rank > klass.system.attacks.other.rank) { klass.system.attacks.other.name = dualClass.system.attacks.other.name; klass.system.attacks.other.rank = dualClass.system.attacks.other.rank; } } if ( klass.system.attacks.martial >= dualClass.system.attacks.other.rank && klass.system.attacks.martial >= klass.system.attacks.other.rank ) { klass.system.attacks.other.rank = 0; klass.system.attacks.other.name = ""; } // Class DC if (dualClass.system.classDC > klass.system.classDC) { klass.system.classDC = dualClass.system.classDC; } // Defenses ["heavy", "light", "medium", "unarmored"].forEach((key) => { if (dualClass.system.defenses[key] > klass.system.defenses[key]) { klass.system.defenses[key] = dualClass.system.defenses[key]; } }); // Description klass.system.description.value = `${klass.system.description.value} ${dualClass.system.description.value}`; // HP if (dualClass.system.hp > klass.system.hp) { klass.system.hp = dualClass.system.hp; } // Items Object.entries(dualClass.system.items).forEach((i) => { if (Object.values(klass.system.items).some((x) => x.uuid === i[1].uuid && x.level > i[1].level)) { Object.values(klass.system.items).find((x) => x.uuid === i[1].uuid).level = i[1].level; } else if (!Object.values(klass.system.items).some((x) => x.uuid === i[1].uuid && x.level <= i[1].level)) { klass.system.items[i[0]] = i[1]; } }); // Key Ability dualClass.system.keyAbility.value.forEach((v) => { if (!klass.system.keyAbility.value.includes(v)) { klass.system.keyAbility.value.push(v); } }); // Perception if (dualClass.system.perception > klass.system.perception) klass.system.perception = dualClass.system.perception; // Rules klass.system.rules.push(ruleEntry); dualClass.system.rules.forEach((r) => { if (!klass.system.rules.includes(r)) { klass.system.rules.push(r); } }); klass.system.rules.forEach((r, i) => { if (r.path !== undefined) { const check = r.path.split("."); if ( check.includes("data") && check.includes("martial") && check.includes("rank") && klass.system.attacks.martial >= r.value ) { klass.system.rules.splice(i, 1); } } }); // Saving Throws ["fortitude", "reflex", "will"].forEach((key) => { if (dualClass.system.savingThrows[key] > klass.system.savingThrows[key]) { klass.system.savingThrows[key] = dualClass.system.savingThrows[key]; } }); // Skill Feat Levels dualClass.system.skillFeatLevels.value.forEach((v) => { klass.system.skillFeatLevels.value.push(v); }); klass.system.skillFeatLevels.value = [...new Set(klass.system.skillFeatLevels.value)].sort((a, b) => { return a - b; }); // Skill Increase Levels dualClass.system.skillIncreaseLevels.value.forEach((v) => { klass.system.skillIncreaseLevels.value.push(v); }); klass.system.skillIncreaseLevels.value = [...new Set(klass.system.skillIncreaseLevels.value)].sort((a, b) => { return a - b; }); // Trained Skills if (dualClass.system.trainedSkills.additional > klass.system.trainedSkills.additional) { klass.system.trainedSkills.additional = dualClass.system.trainedSkills.additional; } dualClass.system.trainedSkills.value.forEach((v) => { if (!klass.system.trainedSkills.value.includes(v)) { klass.system.trainedSkills.value.push(v); } }); this.result.dualClass = dualClass; } // eslint-disable-next-line class-methods-use-this async #processGenericCompendiumLookup(type, name, target) { src_logger.debug(`Checking for compendium documents for ${name} (${target}) in compendiums for ${type}`); const foundryName = this.getFoundryFeatureName(name).foundryName; const indexMatch = this.compendiumMatchers[type].getMatch(name, foundryName); if (indexMatch) { const doc = await indexMatch.pack.getDocument(indexMatch.i._id); const itemData = doc.toObject(); if (name.includes("(")) { const extra = name.split(")")[0].split("(").pop(); this.parsed.specials.push({ name: doc.name, originalName: name, added: true, extra, rank: 99 }); } if (target === "class") { itemData.system.keyAbility.selected = this.keyAbility; await this.#addDualClass(itemData); } itemData._id = foundry.utils.randomID(); // this.#generateGrantItemData(itemData); this.result[target].push(itemData); await this.#addGrantedItems(itemData, { applyFeatLocation: target !== "class" }); return true; } else { this.bad.push({ pbName: name, type: target, details: { name } }); return false; } } // for grants, e.g. ont he champion "Deity and Cause" where there are choices. // how do we determine and match these? should we? // "pf2e": { // "itemGrants": { // "adanye": { // "id": "4GHcp3iaREfj2ZgN", // "onDelete": "detach" // }, // "paladin": { // "id": "HGWkTEatliHgDaEu", // "onDelete": "detach" // } // } // } // "Paladin" (granted by deity and casue) // "pf2e": { // "grantedBy": { // "id": "xnrkrJa2YE1UOAVy", // "onDelete": "cascade" // }, // "itemGrants": { // "retributiveStrike": { // "id": "WVHbj9LljCTovdsv", // "onDelete": "detach" // } // } // } // retributive strike // "pf2e": { // "grantedBy": { // "id": "HGWkTEatliHgDaEu", // "onDelete": "cascade" // } #parsedFeatureMatch(type, document, slug, { ignoreAdded, isChoiceMatch = false, featType = null } = {}) { // console.warn(`Trying to find ${slug} in ${type}, ignoreAdded? ${ignoreAdded}`, this.parsed[type]); const parsedMatch = this.parsed[type].find((f) => (!ignoreAdded || (ignoreAdded && !f.added)) && ( featType === null || f.type === featType ) && !f.isChoice && (slug === Seasoning.slug(f.name) || slug === Seasoning.slug(Seasoning.getClassAdjustedSpecialNameLowerCase(f.name, this.source.class)) || slug === Seasoning.slug(Seasoning.getAncestryAdjustedSpecialNameLowerCase(f.name, this.source.ancestry)) || slug === Seasoning.slug(Seasoning.getHeritageAdjustedSpecialNameLowerCase(f.name, this.source.heritage)) || slug === Seasoning.slug(f.originalName) || slug === Seasoning.slug(Seasoning.getClassAdjustedSpecialNameLowerCase(f.originalName, this.source.class)) || slug === Seasoning.slug(Seasoning.getAncestryAdjustedSpecialNameLowerCase(f.originalName, this.source.ancestry)) || slug === Seasoning.slug(Seasoning.getHeritageAdjustedSpecialNameLowerCase(f.originalName, this.source.heritage)) || (game.settings.get("pf2e", "dualClassVariant") && (slug === Seasoning.slug(Seasoning.getDualClassAdjustedSpecialNameLowerCase(f.name, this.source.dualClass)) || slug === Seasoning.slug( Seasoning.getDualClassAdjustedSpecialNameLowerCase(f.originalName, this.source.dualClass) )))) ); if (parsedMatch || !document) return parsedMatch; const extraMatch = this.parsed[type].find((f) => // (!ignoreAdded || (ignoreAdded && !f.added)) f.extra && f.added && !f.isChoice && Seasoning.slug(f.name) === (document.system.slug ?? Seasoning.slug(document.name)) && Seasoning.slug(f.extra) === slug ); if (extraMatch) return extraMatch; if (isChoiceMatch) { // console.warn("Specials check", { // document, // type, // slug, // }); const choiceMatch = this.parsed[type].find((f) => f.isChoice && !f.added && Seasoning.slug(f.name) === slug); return choiceMatch; } return undefined; } #generatedResultMatch(type, slug) { const featMatch = this.result[type].find((f) => slug === f.system.slug); return featMatch; } #findAllFeatureMatch(document, slug, { ignoreAdded, isChoiceMatch = false, featType = null } = {}) { const featMatch = this.#parsedFeatureMatch("feats", document, slug, { ignoreAdded, featType }); if (featMatch) return featMatch; const specialMatch = this.#parsedFeatureMatch("specials", document, slug, { ignoreAdded, isChoiceMatch }); if (specialMatch) return specialMatch; const deityMatch = this.#generatedResultMatch("deity", slug); return deityMatch; // const classMatch = this.#generatedResultMatch("class", slug); // return classMatch; // const equipmentMatch = this.#generatedResultMatch("equipment", slug); // return equipmentMatch; } #createGrantedItem(document, parent, { originType = null, applyFeatLocation = false } = {}) { src_logger.debug(`Adding granted item flags to ${document.name} (parent ${parent.name}) with originType "${originType}", and will applyFeatLocation? ${applyFeatLocation}`); const camelCase = Seasoning.slugD(document.system.slug ?? document.name); setProperty(parent, `flags.pf2e.itemGrants.${camelCase}`, { id: document._id, onDelete: "detach" }); setProperty(document, "flags.pf2e.grantedBy", { id: parent._id, onDelete: "cascade" }); this.autoFeats.push(document); this.result.feats.push(document); const matchOptions = { ignoreAdded: true, featType: originType }; const featureMatch = this.#findAllFeatureMatch(document, document.system.slug ?? Seasoning.slug(document.name), matchOptions) ?? (document.name.includes("(") ? this.#findAllFeatureMatch(document, Seasoning.slug(document.name.split("(")[0].trim()), matchOptions) : undefined); if (featureMatch) { src_logger.debug(`Found feature match for ${document.name}`, { featureMatch }); if (hasProperty(featureMatch, "added")) { featureMatch.added = true; featureMatch.addedId = document._id; if (applyFeatLocation) this.#generateFoundryFeatLocation(document, featureMatch); } return; } if (document.type !== "action") src_logger.warn( `Unable to find parsed feature match for granted feature ${document.name}. This might not be an issue, but might indicate feature duplication.`, { document, parent } ); } static #getLowestChoiceRank(choices) { return choices.reduce((p, c) => { return p.rank > c.rank ? c : p; }); } async #featureChoiceMatch(document, choices, ignoreAdded, adjustName, choiceHint = null) { const matches = []; for (const choice of choices) { const doc = adjustName ? game.i18n.localize(choice.label) : await fromUuid(choice.value); if (!doc) continue; const slug = adjustName ? Seasoning.slug(doc) : doc.system.slug === null ? Seasoning.slug(doc.name) : doc.system.slug; const featMatch = this.#findAllFeatureMatch(document, slug, { ignoreAdded, isChoiceMatch: false }); if (featMatch) { matches.push({ slug, rank: featMatch.rank, choice, }); } } if (matches.length > 0) { if (choiceHint) { const hintMatch = matches.find((m) => m.slug === Seasoning.slug(choiceHint)); if (hintMatch) return hintMatch; } const match = Pathmuncher.#getLowestChoiceRank(matches); const featMatch = this.#findAllFeatureMatch(document, match.slug, { ignoreAdded }); if (adjustName && hasProperty(featMatch, "added")) { featMatch.added = true; featMatch.addedId = document._id; } src_logger.debug("Choices evaluated", { choices, document, featMatch, match, matches }); return match.choice; } else { return undefined; } } async #featureChoiceMatchNoUUID(document, choices, cleansedChoiceSet) { const matches = []; for (const choice of choices) { const featMatch = this.#findAllFeatureMatch(document, choice.value, { ignoreAdded: true, isChoiceMatch: true }); if (featMatch) { matches.push({ rank: featMatch.rank, choice, }); } } if (matches.length > 0) { const match = Pathmuncher.#getLowestChoiceRank(matches); const featMatch = this.#findAllFeatureMatch(document, match.choice.value, { ignoreAdded: true, isChoiceMatch: true }); if (featMatch) { featMatch.added = true; featMatch.addedId = document._id; match.choice.nouuid = true; } src_logger.debug("No UUID Choices evaluated", { choices, cleansedChoiceSet, document, featMatch, match, matches }); return match.choice; } else { return undefined; } } static getFlag(document, ruleSet) { return typeof ruleSet.flag === "string" && ruleSet.flag.length > 0 ? ruleSet.flag.replace(/[^-a-z0-9]/gi, "") : Seasoning.slugD(document.system.slug ?? document.system.name); } async #evaluateChoices(document, choiceSet, choiceHint) { src_logger.debug(`Evaluating choices for ${document.name}`, { document, choiceSet, choiceHint }); const tempActor = await this.#generateTempActor([document], false, false, true); const cleansedChoiceSet = deepClone(choiceSet); try { const item = tempActor.getEmbeddedDocument("Item", document._id); const choiceSetRules = isNewerVersion(game.version, 11) ? new game.pf2e.RuleElements.all.ChoiceSet(cleansedChoiceSet, { parent: item }) : new game.pf2e.RuleElements.all.ChoiceSet(cleansedChoiceSet, item); const rollOptions = [tempActor.getRollOptions(), item.getRollOptions("item")].flat(); const choices = isNewerVersion(game.version, 11) ? await choiceSetRules.inflateChoices(rollOptions, []) : (await choiceSetRules.inflateChoices()).filter((c) => c.predicate?.test(rollOptions) ?? true); src_logger.debug("Starting choice evaluation", { document, choiceSet, item, choiceSetRules, rollOptions, choices, }); if (cleansedChoiceSet.choices?.query) { const nonFilteredChoices = isNewerVersion(game.version, 11) ? await choiceSetRules.inflateChoices(rollOptions, [item]) : await choiceSetRules.inflateChoices(); const queryResults = await choiceSetRules.queryCompendium(cleansedChoiceSet.choices, rollOptions, [item]); src_logger.debug("Query Result", { queryResults, nonFilteredChoices }); } src_logger.debug("Evaluating choiceset", cleansedChoiceSet); const choiceMatch = await this.#featureChoiceMatch(document, choices, true, cleansedChoiceSet.adjustName, choiceHint); src_logger.debug("choiceMatch result", choiceMatch); if (choiceMatch) { choiceMatch.choiceQueryResults = deepClone(choices); return choiceMatch; } if (typeof cleansedChoiceSet.choices === "string" || Array.isArray(choices)) { const featureMatch = await this.#featureChoiceMatchNoUUID(document, choices, cleansedChoiceSet); if (featureMatch) { return featureMatch; } } let tempSet = deepClone(choiceSet); src_logger.debug(`Starting dynamic selection for ${document.name}`, { document, choiceSet, tempSet, Pathmuncher: this }); await choiceSetRules.preCreate({ itemSource: item, ruleSource: tempSet, pendingItems: [item] }); // console.warn("chociesetdata", { // choiceSetRules, // selection: choiceSetRules.selection, // choiceSet: deepClone(choiceSet), // tempSet: deepClone(tempSet), // }); if (tempSet.selection) { const lookedUpChoice = choices.find((c) => c.value === tempSet.selection); src_logger.debug("lookedUpChoice", lookedUpChoice); if (lookedUpChoice) lookedUpChoice.choiceQueryResults = deepClone(choices); // set some common lookups here, e.g. deities are often not set! if (lookedUpChoice && cleansedChoiceSet.flag === "deity") { if (lookedUpChoice.label && lookedUpChoice.label !== "") { setProperty(this.result.character, "system.details.deity.value", lookedUpChoice.label); await this.#processGenericCompendiumLookup("deities", lookedUpChoice.label, "deity"); const camelCase = Seasoning.slugD(this.result.deity[0].system.slug); setProperty(document, `flags.pf2e.itemGrants.${camelCase}`, { id: this.result.deity[0]._id, onDelete: "detach", }); setProperty(this.result.deity[0], "flags.pf2e.grantedBy", { id: document._id, onDelete: "cascade" }); this.autoAddedFeatureIds.add(`${lookedUpChoice.value.split(".").pop()}deity`); } } return lookedUpChoice; } } catch (err) { src_logger.error("Whoa! Something went major bad wrong during choice evaluation", { err, tempActor: tempActor.toObject(), document: duplicate(document), choiceSet: duplicate(cleansedChoiceSet), }); throw err; } finally { await Actor.deleteDocuments([tempActor._id]); } src_logger.debug("Evaluate Choices failed", { choiceSet: cleansedChoiceSet, tempActor, document }); return undefined; } async #resolveInjectedUuid(document, ruleEntry) { const tempActor = await this.#generateTempActor([document], false, false); const cleansedRuleEntry = deepClone(ruleEntry); try { const item = tempActor.getEmbeddedDocument("Item", document._id); // console.warn("creating grant item"); const grantItemRule = isNewerVersion(game.version, 11) ? new game.pf2e.RuleElements.all.GrantItem(cleansedRuleEntry, { parent: item }) : new game.pf2e.RuleElements.all.GrantItem(cleansedRuleEntry, item); // console.warn("Begining uuid resovle"); const uuid = grantItemRule.resolveInjectedProperties(grantItemRule.uuid, { warn: false }); src_logger.debug("uuid selection", { document, choiceSet: ruleEntry, item, grantItemRule, uuid, }); if (uuid) return uuid; } catch (err) { src_logger.error("Whoa! Something went major bad wrong during uuid evaluation", { err, tempActor: tempActor.toObject(), document: duplicate(document), ruleEntry: duplicate(cleansedRuleEntry), }); throw err; } finally { await Actor.deleteDocuments([tempActor._id]); } src_logger.debug("Evaluate UUID failed", { choiceSet: cleansedRuleEntry, tempActor, document }); return undefined; } async #checkRule(document, rule) { const tempActor = await this.#generateTempActor([document], true); const cleansedRule = deepClone(rule); try { const item = tempActor.getEmbeddedDocument("Item", document._id); const ruleElement = cleansedRule.key === "ChoiceSet" ? isNewerVersion(game.version, 11) ? new game.pf2e.RuleElements.all.ChoiceSet(cleansedRule, { parent: item }) : new game.pf2e.RuleElements.all.ChoiceSet(cleansedRule, item) : isNewerVersion(game.version, 11) ? new game.pf2e.RuleElements.all.GrantItem(cleansedRule, { parent: item }) : new game.pf2e.RuleElements.all.GrantItem(cleansedRule, item); const rollOptions = [tempActor.getRollOptions(), item.getRollOptions("item")].flat(); if (rule.predicate) { const predicate = ruleElement.resolveInjectedProperties(ruleElement.predicate); if (!predicate.test(rollOptions)) return false; } const choices = cleansedRule.key === "ChoiceSet" ? isNewerVersion(game.version, 11) ? await ruleElement.inflateChoices(rollOptions, [item]) : (await ruleElement.inflateChoices()).filter((c) => !c.predicate || c.predicate.test(rollOptions)) : [ruleElement.resolveValue()]; const isGood = cleansedRule.key === "ChoiceSet" ? (await this.#featureChoiceMatch(document, choices, false)) !== undefined : ruleElement.test(rollOptions); src_logger.debug("Checking rule", { tempActor, cleansedRule, item, ruleElement, rollOptions, choices, isGood, }); return isGood; } catch (err) { src_logger.error("Something has gone most wrong during rule checking", { document, rule: cleansedRule, tempActor, }); throw err; } finally { await Actor.deleteDocuments([tempActor._id]); } } async #checkRulePredicate(document, rule) { const tempActor = await this.#generateTempActor([document], true); const cleansedRule = deepClone(rule); try { const item = tempActor.getEmbeddedDocument("Item", document._id); const ruleElement = cleansedRule.key === "ChoiceSet" ? isNewerVersion(game.version, 11) ? new game.pf2e.RuleElements.all.ChoiceSet(cleansedRule, { parent: item }) : new game.pf2e.RuleElements.all.ChoiceSet(cleansedRule, item) : isNewerVersion(game.version, 11) ? new game.pf2e.RuleElements.all.GrantItem(cleansedRule, { parent: item }) : new game.pf2e.RuleElements.all.GrantItem(cleansedRule, item); const rollOptions = [tempActor.getRollOptions(), item.getRollOptions("item")].flat(); if (rule.predicate) { const predicate = ruleElement.resolveInjectedProperties(ruleElement.predicate); return predicate.test(rollOptions); } else { return true; } } catch (err) { src_logger.error("Something has gone most wrong during rule predicate checking", { document, rule: cleansedRule, tempActor, }); throw err; } finally { await Actor.deleteDocuments([tempActor._id]); } } static adjustDocumentName(featureName, label) { const localLabel = game.i18n.localize(label); if (featureName.trim().toLowerCase() === localLabel.trim().toLowerCase()) return featureName; const name = `${featureName} (${localLabel})`; const pattern = (() => { const escaped = RegExp.escape(localLabel); return new RegExp(`\\(${escaped}\\) \\(${escaped}\\)$`); })(); return name.replace(pattern, `(${localLabel})`); } // eslint-disable-next-line complexity, no-unused-vars async #addGrantedRules(document, originType = null, choiceHint = null) { if (document.system.rules.length === 0) return; src_logger.debug(`addGrantedRules for ${document.name}`, duplicate(document)); if ( hasProperty(document, "system.level.value") && document.system.level.value > this.result.character.system.details.level.value ) { return; } const rulesToKeep = []; this.allFeatureRules[document._id] = deepClone(document.system.rules); this.autoAddedFeatureRules[document._id] = []; this.promptRules[document._id] = []; let featureRenamed = false; for (const ruleEntry of document.system.rules) { src_logger.debug(`Ping ${document.name} rule key: ${ruleEntry.key}`, ruleEntry); if (!["ChoiceSet", "GrantItem"].includes(ruleEntry.key)) { // size work around due to Pathbuilder not always adding the right size to json if (ruleEntry.key === "CreatureSize") this.size = ruleEntry.value; this.autoAddedFeatureRules[document._id].push(ruleEntry); rulesToKeep.push(ruleEntry); continue; } src_logger.debug(`Checking ${document.name} rule key: ${ruleEntry.key}`, { ruleEntry, docRules: deepClone(document.system.rules), document: deepClone(document), }); if (ruleEntry.key === "ChoiceSet" && ruleEntry.predicate) { src_logger.debug(`Checking for predicates`, { ruleEntry, document, }); const testResult = await this.#checkRulePredicate(duplicate(document), ruleEntry); if (!testResult) { const data = { document, ruleEntry, testResult }; src_logger.debug( `The test failed for ${document.name} rule key: ${ruleEntry.key} (This is probably not a problem).`, data ); rulesToKeep.push(ruleEntry); continue; } } const choice = ruleEntry.key === "ChoiceSet" ? await this.#evaluateChoices(document, ruleEntry, choiceHint) : undefined; const uuid = ruleEntry.key === "GrantItem" ? await this.#resolveInjectedUuid(document, ruleEntry) : choice?.value; if (choice?.choiceQueryResults) { ruleEntry.choiceQueryResults = choice.choiceQueryResults; } const flagName = Pathmuncher.getFlag(document, ruleEntry); if (flagName && choice?.value && !hasProperty(document, `flags.pf2e.rulesSelections.${flagName}`)) { setProperty(document, `flags.pf2e.rulesSelections.${flagName}`, choice.value); } src_logger.debug(`UUID for ${document.name}: "${uuid}"`, { document, ruleEntry, choice, uuid }); const ruleFeature = uuid && typeof uuid === "string" ? await fromUuid(uuid) : undefined; // console.warn("ruleFeature", ruleFeature); if (ruleFeature) { const featureDoc = ruleFeature.toObject(); featureDoc._id = foundry.utils.randomID(); if (featureDoc.system.rules) this.allFeatureRules[featureDoc._id] = deepClone(featureDoc.system.rules); setProperty(featureDoc, "flags.pathmuncher.origin.uuid", uuid); src_logger.debug(`Found rule feature ${featureDoc.name} for ${document.name} for`, ruleEntry); if (choice) ruleEntry.selection = choice.value; if (ruleEntry.predicate && ruleEntry.key === "GrantItem") { src_logger.debug(`Checking for grantitem predicates`, { ruleEntry, document, featureDoc, }); const testResult = await this.#checkRule(featureDoc, ruleEntry); if (!testResult) { const data = { document, ruleEntry, featureDoc, testResult }; src_logger.debug( `The test failed for ${document.name} rule key: ${ruleEntry.key} (This is probably not a problem).`, data ); rulesToKeep.push(ruleEntry); // this.autoAddedFeatureRules[document._id].push(ruleEntry); continue; } else { src_logger.debug(`The test passed for ${document.name} rule key: ${ruleEntry.key}`, ruleEntry); // this.autoAddedFeatureRules[document._id].push(ruleEntry); // eslint-disable-next-line max-depth // if (!ruleEntry.flag) ruleEntry.flag = Seasoning.slugD(document.name); ruleEntry.pathmuncherImport = true; rulesToKeep.push(ruleEntry); } } // setProperty(ruleEntry, `preselectChoices.${ruleEntry.flag}`, ruleEntry.selection ?? ruleEntry.uuid); if (this.autoAddedFeatureIds.has(`${ruleFeature.id}${ruleFeature.type}`)) { src_logger.debug(`Feature ${featureDoc.name} found for ${document.name}, but has already been added (${ruleFeature.id})`, ruleFeature); // this.autoAddedFeatureRules[document._id].push(ruleEntry); // rulesToKeep.push(ruleEntry); continue; } else { src_logger.debug(`Feature ${featureDoc.name} not found for ${document.name}, adding (${ruleFeature.id})`, ruleFeature); if (ruleEntry.selection || ruleEntry.flag) { rulesToKeep.push(ruleEntry); } this.autoAddedFeatureIds.add(`${ruleFeature.id}${ruleFeature.type}`); featureDoc._id = foundry.utils.randomID(); this.#createGrantedItem(featureDoc, document, { applyFeatLocation: false }); if (hasProperty(featureDoc, "system.rules")) await this.#addGrantedRules(featureDoc); } } else if (getProperty(choice, "nouuid")) { src_logger.debug("Parsed no id rule", { choice, uuid, ruleEntry }); if (!ruleEntry.flag) ruleEntry.flag = Seasoning.slugD(document.name); ruleEntry.selection = choice.value; if (choice.label) document.name = `${document.name} (${choice.label})`; rulesToKeep.push(ruleEntry); } else if (choice && uuid && !hasProperty(ruleEntry, "selection")) { src_logger.debug("Parsed odd choice rule", { choice, uuid, ruleEntry }); // if (!ruleEntry.flag) ruleEntry.flag = Seasoning.slugD(document.name); ruleEntry.selection = choice.value; if ( ((!ruleEntry.adjustName && choice.label && typeof uuid === "object") || (!choice.adjustName && choice.label)) && !featureRenamed ) { document.name = Pathmuncher.adjustDocumentName(document.name, choice.label); featureRenamed = true; } rulesToKeep.push(ruleEntry); } else { src_logger.debug(`Final rule fallback for ${document.name}`, ruleEntry); const data = { uuid: ruleEntry.uuid, document, ruleEntry, choice, }; if ( ruleEntry.key === "GrantItem" && (ruleEntry.flag || ruleEntry.selection || ruleEntry.uuid.startsWith("Compendium")) ) { rulesToKeep.push(ruleEntry); } else if (ruleEntry.key === "ChoiceSet" && !hasProperty(ruleEntry, "flag")) { src_logger.debug("Prompting user for choices", ruleEntry); this.promptRules[document._id].push(ruleEntry); rulesToKeep.push(ruleEntry); } else if (ruleEntry.key === "ChoiceSet" && !choice && !uuid) { src_logger.warn("Unable to determine choice asking", data); rulesToKeep.push(ruleEntry); this.promptRules[document._id].push(ruleEntry); } src_logger.warn("Unable to determine granted rule feature, needs better parser", data); } if (ruleEntry.adjustName && choice?.label && !featureRenamed) { document.name = Pathmuncher.adjustDocumentName(document.name, choice.label); } this.autoAddedFeatureRules[document._id].push(ruleEntry); src_logger.debug(`End result for ${document.name} for a ${ruleEntry.key}`, { document: deepClone(document), rulesToKeep: deepClone(rulesToKeep), ruleEntry: deepClone(ruleEntry), choice: deepClone(choice), uuid: deepClone(uuid), }); } // eslint-disable-next-line require-atomic-updates document.system.rules = rulesToKeep; src_logger.debug(`Final status for ${document.name}`, { document: deepClone(document), rulesToKeep: deepClone(rulesToKeep), }); } async #addGrantedItems(document, { originType = null, applyFeatLocation = false, choiceHint = null } = {}) { const immediateDiveAdd = src_utils.setting("USE_IMMEDIATE_DEEP_DIVE"); const subRuleDocuments = []; if (hasProperty(document, "system.items")) { src_logger.debug(`addGrantedItems for ${document.name}`, duplicate(document)); if (!this.autoAddedFeatureItems[document._id]) { this.autoAddedFeatureItems[document._id] = duplicate(document.system.items); } const failedFeatureItems = {}; for (const [key, grantedItemFeature] of Object.entries(document.system.items).sort(([, a], [, b]) => a.level - b.level)) { src_logger.debug(`Checking ${document.name} granted item ${grantedItemFeature.name}, level(${grantedItemFeature.level}) with key: ${key}`, grantedItemFeature); if (grantedItemFeature.level > getProperty(this.result.character, "system.details.level.value")) continue; const feature = await fromUuid(grantedItemFeature.uuid); if (!feature) { const data = { uuid: grantedItemFeature.uuid, grantedFeature: grantedItemFeature, feature }; src_logger.warn("Unable to determine granted item feature, needs better parser", data); failedFeatureItems[key] = grantedItemFeature; continue; } this.autoAddedFeatureIds.add(`${feature.id}${feature.type}`); const featureDoc = feature.toObject(); featureDoc._id = foundry.utils.randomID(); setProperty(featureDoc.system, "location", document._id); this.#createGrantedItem(featureDoc, document, { originType, applyFeatLocation }); if (hasProperty(featureDoc, "system.rules")) { src_logger.debug(`Processing granted rules for granted item document ${featureDoc.name}`, duplicate(featureDoc)); if (immediateDiveAdd) { await this.#addGrantedItems(featureDoc, { originType, applyFeatLocation }); } else { subRuleDocuments.push(featureDoc); } } } // eslint-disable-next-line require-atomic-updates document.system.items = failedFeatureItems; if (!immediateDiveAdd) { for (const subRuleDocument of subRuleDocuments) { src_logger.debug( `Processing granted rules for granted item document ${subRuleDocument.name}`, duplicate(subRuleDocument) ); await this.#addGrantedItems(subRuleDocument, { originType, applyFeatLocation, choiceHint }); } } } if (hasProperty(document, "system.rules")) { src_logger.debug(`Processing granted rules for core document ${document.name}`, duplicate(document)); await this.#addGrantedRules(document, originType, choiceHint); } } #determineAbilityBoosts() { const boostLocation = foundry.utils.isNewerVersion(game.system.version, "5.3.0") ? "attributes" : "abilities"; const breakdown = getProperty(this.source, "abilities.breakdown"); const useCustomStats = breakdown && breakdown.ancestryFree.length === 0 && breakdown.ancestryBoosts.length === 0 && breakdown.ancestryFlaws.length === 0 && breakdown.backgroundBoosts.length === 0 && breakdown.classBoosts.length === 0; if (breakdown && !useCustomStats) { this.boosts.custom = false; const classBoostMap = {}; for (const [key, boosts] of Object.entries(this.source.abilities.breakdown.mapLevelledBoosts)) { if (key <= this.source.level) { classBoostMap[key] = boosts.map((ability) => ability.toLowerCase()); } } setProperty(this.result.character, `system.build.${boostLocation}.boosts`, classBoostMap); this.boosts.class = classBoostMap; // ancestry } else { this.boosts.custom = true; if (foundry.utils.isNewerVersion("5.3.0", game.system.version)) { ["str", "dex", "con", "int", "wis", "cha"].forEach((key) => { setProperty(this.result.character, `system.abilities.${key}.value`, this.source.abilities[key]); }); } else { ["str", "dex", "con", "int", "wis", "cha"].forEach((key) => { const mod = Math.min(Math.max(Math.trunc((this.source.abilities[key] - 10) / 2), -5), 10) || 0; setProperty(this.result.character, `system.abilities.${key}.mod`, mod); }); } } if (breakdown?.classBoosts.length > 0) { this.keyAbility = breakdown.classBoosts[0].toLowerCase(); } else { this.keyAbility = this.source.keyability; } setProperty(this.result.character, "system.details.keyability.value", this.keyAbility); } #generateBackgroundAbilityBoosts() { if (!this.result.background[0]) return; const breakdown = getProperty(this.source, "abilities.breakdown"); for (const boost of breakdown.backgroundBoosts) { for (const [key, boostSet] of Object.entries(this.result.background[0].system.boosts)) { if (this.result.background[0].system.boosts[key].selected) continue; if (boostSet.value.includes(boost.toLowerCase())) { this.result.background[0].system.boosts[key].selected = boost.toLowerCase(); break; } } } } #generateAncestryAbilityBoosts() { if (!this.result.ancestry[0]) return; const breakdown = getProperty(this.source, "abilities.breakdown"); const boosts = []; breakdown.ancestryBoosts.concat(breakdown.ancestryFree).forEach((boost) => { for (const [key, boostSet] of Object.entries(this.result.ancestry[0].system.boosts)) { if (this.result.ancestry[0].system.boosts[key].selected) continue; if (boostSet.value.includes(boost.toLowerCase())) { this.result.ancestry[0].system.boosts[key].selected = boost.toLowerCase(); boosts.push(boost.toLowerCase()); break; } } }); if (breakdown.ancestryBoosts.length === 0) { setProperty(this.result.ancestry[0], "system.alternateAncestryBoosts", boosts); } } #setAbilityBoosts() { if (this.boosts.custom) return; this.#generateBackgroundAbilityBoosts(); this.#generateAncestryAbilityBoosts(); this.result.class[0].system.boosts = this.boosts.class; } #setSkills() { setProperty(this.result.character, "system.skills.acr.rank", this.source.proficiencies.acrobatics / 2); setProperty(this.result.character, "system.skills.arc.rank", this.source.proficiencies.arcana / 2); setProperty(this.result.character, "system.skills.ath.rank", this.source.proficiencies.athletics / 2); setProperty(this.result.character, "system.skills.cra.rank", this.source.proficiencies.crafting / 2); setProperty(this.result.character, "system.skills.dec.rank", this.source.proficiencies.deception / 2); setProperty(this.result.character, "system.skills.dip.rank", this.source.proficiencies.diplomacy / 2); setProperty(this.result.character, "system.skills.itm.rank", this.source.proficiencies.intimidation / 2); setProperty(this.result.character, "system.skills.med.rank", this.source.proficiencies.medicine / 2); setProperty(this.result.character, "system.skills.nat.rank", this.source.proficiencies.nature / 2); setProperty(this.result.character, "system.skills.occ.rank", this.source.proficiencies.occultism / 2); setProperty(this.result.character, "system.skills.prf.rank", this.source.proficiencies.performance / 2); setProperty(this.result.character, "system.skills.rel.rank", this.source.proficiencies.religion / 2); setProperty(this.result.character, "system.skills.soc.rank", this.source.proficiencies.society / 2); setProperty(this.result.character, "system.skills.ste.rank", this.source.proficiencies.stealth / 2); setProperty(this.result.character, "system.skills.sur.rank", this.source.proficiencies.survival / 2); setProperty(this.result.character, "system.skills.thi.rank", this.source.proficiencies.thievery / 2); } #setSaves() { setProperty(this.result.character, "system.saves.fortitude.tank", this.source.proficiencies.fortitude / 2); setProperty(this.result.character, "system.saves.reflex.value", this.source.proficiencies.reflex / 2); setProperty(this.result.character, "system.saves.will.value", this.source.proficiencies.will / 2); } #setMartials() { setProperty(this.result.character, "system.martial.advanced.rank", this.source.proficiencies.advanced / 2); setProperty(this.result.character, "system.martial.heavy.rank", this.source.proficiencies.heavy / 2); setProperty(this.result.character, "system.martial.light.rank", this.source.proficiencies.light / 2); setProperty(this.result.character, "system.martial.medium.rank", this.source.proficiencies.medium / 2); setProperty(this.result.character, "system.martial.unarmored.rank", this.source.proficiencies.unarmored / 2); setProperty(this.result.character, "system.martial.martial.rank", this.source.proficiencies.martial / 2); setProperty(this.result.character, "system.martial.simple.rank", this.source.proficiencies.simple / 2); setProperty(this.result.character, "system.martial.unarmed.rank", this.source.proficiencies.unarmed / 2); } async #processCore() { setProperty(this.result.character, "name", this.source.name); setProperty(this.result.character, "prototypeToken.name", this.source.name); setProperty(this.result.character, "system.details.level.value", this.source.level); if (this.source.age !== "Not set") setProperty(this.result.character, "system.details.age.value", this.source.age); if (this.source.gender !== "Not set") setProperty(this.result.character, "system.details.gender.value", this.source.gender); setProperty(this.result.character, "system.details.alignment.value", this.source.alignment); if (this.source.deity !== "Not set") setProperty(this.result.character, "system.details.deity.value", this.source.deity); this.size = Seasoning.getSizeValue(this.source.size); setProperty(this.result.character, "system.traits.size.value", this.size); setProperty(this.result.character, "system.traits.languages.value", this.source.languages.map((l) => l.toLowerCase())); this.#processSenses(); this.#determineAbilityBoosts(); this.#setSaves(); this.#setMartials(); setProperty(this.result.character, "system.attributes.perception.rank", this.source.proficiencies.perception / 2); setProperty(this.result.character, "system.attributes.classDC.rank", this.source.proficiencies.classDC / 2); } #indexFind(index, arrayOfNameMatches) { for (const name of arrayOfNameMatches) { const indexMatch = index.find((i) => { const slug = i.system.slug ?? Seasoning.slug(i.name); return ( slug === Seasoning.slug(name) || slug === Seasoning.slug(Seasoning.getClassAdjustedSpecialNameLowerCase(name, this.source.class)) || slug === Seasoning.slug(Seasoning.getAncestryAdjustedSpecialNameLowerCase(name, this.source.ancestry)) || slug === Seasoning.slug(Seasoning.getHeritageAdjustedSpecialNameLowerCase(name, this.source.heritage)) || (game.settings.get("pf2e", "dualClassVariant") && slug === Seasoning.slug(Seasoning.getDualClassAdjustedSpecialNameLowerCase(name, this.source.dualClass))) ); }); if (indexMatch) return indexMatch; } return undefined; } #findInPackIndexes(type, arrayOfNameMatches) { const matcher = this.compendiumMatchers[type]; for (const [packName, index] of Object.entries(matcher.indexes)) { const indexMatch = this.#indexFind(index, arrayOfNameMatches); if (indexMatch) return { i: indexMatch, pack: matcher.packs[packName] }; } return undefined; } #sortParsedFeats() { // eslint-disable-next-line complexity this.parsed.feats.sort((f1, f2) => { const f1RefUndefined = !(typeof f1.type === "string" || f1.type instanceof String); const f2RefUndefined = !(typeof f2.type === "string" || f2.type instanceof String); if (f1RefUndefined || f2RefUndefined) { if (f1RefUndefined && f2RefUndefined) { return 0; } else if (f1RefUndefined) { return 1; } else { return -1; } } else if (f1.type === "Awarded Feat" && f2.type === "Awarded Feat") { return (f1.level ?? 20) - (f2.level ?? 20); } else if (f1.type === "Awarded Feat") { return 1; } else if (f2.type === "Awarded Feat") { return -1; } else if ((f1.level ?? 20) === (f2.level ?? 20)) { const f1Index = constants.FEAT_PRIORITY.indexOf(f1.type); const f2Index = constants.FEAT_PRIORITY.indexOf(f2.type); if (f1Index > f2Index) { return 1; } else if (f1Index < f2Index) { return -1; } else { return 0; } } else { return (f1.level ?? 20) - (f2.level ?? 20); } }); } async #generateFeatItems(type, { levelCap = null, parsedFilter = null } = {}) { src_logger.debug(`Generate feat items for ${type} with level cap "${levelCap}" and filter "${parsedFilter}"`); for (const featArray of [this.parsed.feats, this.parsed.specials]) { for (const pBFeat of featArray) { if (pBFeat.added) continue; if (levelCap && (pBFeat.level ?? 20) > levelCap) continue; if (parsedFilter && pBFeat.type !== parsedFilter) continue; src_logger.debug("Generating feature for", pBFeat); const indexMatch = this.#findInPackIndexes(type, [pBFeat.name, pBFeat.originalName]); const displayName = pBFeat.extra ? Pathmuncher.adjustDocumentName(pBFeat.name, pBFeat.extra) : pBFeat.name; if (!indexMatch) { src_logger.debug(`Unable to match feat ${displayName}`, { displayName, name: pBFeat.name, extra: pBFeat.extra, pBFeat, type, }); this.check[pBFeat.originalName] = { name: displayName, type: "feat", details: { displayName, name: pBFeat.name, originalName: pBFeat.originalName, extra: pBFeat.extra, pBFeat, type, }, }; continue; } if (this.check[pBFeat.originalName]) delete this.check[pBFeat.originalName]; pBFeat.added = true; if (this.autoAddedFeatureIds.has(`${indexMatch._id}${indexMatch.type}`)) { src_logger.debug("Feat included in class features auto add", { displayName, pBFeat, type }); pBFeat.addedAutoId = `${indexMatch._id}_${indexMatch.type}`; continue; } const doc = await indexMatch.pack.getDocument(indexMatch.i._id); const docData = doc.toObject(); docData._id = foundry.utils.randomID(); pBFeat.addedId = docData._id; // docData.name = displayName; this.#generateFoundryFeatLocation(docData, pBFeat); this.result.feats.push(docData); const options = { originType: parsedFilter, applyFeatLocation: false, choiceHint: pBFeat.extra && pBFeat.extra !== "" ? pBFeat.extra : null, }; await this.#addGrantedItems(docData, "feat", options); } } } async #generateSpecialItems(type) { for (const special of this.parsed.specials) { if (special.added) continue; src_logger.debug("Generating special for", special); const indexMatch = this.#findInPackIndexes(type, [special.name, special.originalName]); if (!indexMatch) { src_logger.debug(`Unable to match special ${special.name}`, { special: special.name, type }); this.check[special.originalName] = { name: special.name, type: "special", details: { displayName: special.name, name: special.name, originalName: special.originalName, special }, }; continue; } special.added = true; if (this.check[special.originalName]) delete this.check[special.originalName]; if (this.autoAddedFeatureIds.has(`${indexMatch._id}${indexMatch.type}`)) { src_logger.debug("Special included in class features auto add", { special: special.name, type }); special.addedAutoId = `${indexMatch._id}_${indexMatch.type}`; continue; } const doc = await indexMatch.pack.getDocument(indexMatch.i._id); const docData = doc.toObject(); docData._id = foundry.utils.randomID(); special.addedId = docData._id; this.result.feats.push(docData); await this.#addGrantedItems(docData, { applyFeatLocation: true }); } } #resizeItem(item) { if (Seasoning.isPhysicalItemType(item.type)) { const resizeItem = item.type !== "treasure" && !["med", "sm"].includes(this.size); if (resizeItem) item.system.size = this.size; } } async #generateAdventurersPack() { const defaultCompendium = game.packs.get("pf2e.equipment-srd"); const index = await defaultCompendium.getIndex({ fields: ["name", "type", "system.slug"] }); const adventurersPack = this.parsed.equipment.find((e) => e.pbName === "Adventurer's Pack"); if (adventurersPack) { const compendiumBackpack = await defaultCompendium.getDocument("3lgwjrFEsQVKzhh7"); const backpackInstance = compendiumBackpack.toObject(); adventurersPack.added = true; backpackInstance._id = foundry.utils.randomID(); adventurersPack.addedId = backpackInstance._id; this.result.adventurersPack.item = adventurersPack; this.result.equipment.push(backpackInstance); for (const content of this.result.adventurersPack.contents) { const indexMatch = index.find((i) => i.system.slug === content.slug); if (!indexMatch) { src_logger.error(`Unable to match adventurers kit item ${content.name}`, content); continue; } const doc = await defaultCompendium.getDocument(indexMatch._id); const itemData = doc.toObject(); itemData._id = foundry.utils.randomID(); itemData.system.quantity = content.qty; itemData.system.containerId = backpackInstance?._id; this.#resizeItem(itemData); this.result.equipment.push(itemData); } } } async #generateContainers() { for (const [key, data] of Object.entries(this.source.equipmentContainers)) { if (data.foundryId) continue; const name = Seasoning.getFoundryEquipmentName(data.containerName); const indexMatch = this.compendiumMatchers["equipment"].getMatch(data.containerName, name); const id = foundry.utils.randomID(); const doc = indexMatch ? await indexMatch.pack.getDocument(indexMatch.i._id) : await Item.create({ name: data.containerName, type: "backpack" }, { temporary: true }); const itemData = doc.toObject(); itemData._id = id; this.#resizeItem(itemData); this.result["equipment"].push(itemData); this.parsed.equipment.push({ pbName: data.containerName, name, qty: 1, added: true, inContainer: undefined, container: this.#getContainerData(key), foundryId: id, }); } } async #generateEquipmentItems() { for (const e of this.parsed.equipment) { if (e.pbName === "Adventurer's Pack") continue; if (e.added) continue; if (Seasoning.IGNORED_EQUIPMENT().includes(e.pbName)) { e.added = true; e.addedAutoId = "ignored"; continue; } src_logger.debug("Generating item for", e); const indexMatch = this.compendiumMatchers["equipment"].getMatch(e.pbName, e.pbName); if (!indexMatch) { src_logger.error(`Unable to match ${e.pbName}`, e); this.bad.push({ pbName: e.pbName, type: "equipment", details: { e } }); continue; } const doc = await indexMatch.pack.getDocument(indexMatch.i._id); if (doc.type != "kit") { const itemData = doc.toObject(); itemData._id = e.foundryId || foundry.utils.randomID(); itemData.system.quantity = e.qty; const type = doc.type === "treasure" ? "treasure" : "equipment"; if (e.inContainer) { const containerMatch = this.parsed.equipment.find((con) => con.container?.id === e.inContainer); if (containerMatch) { itemData.system.containerId = containerMatch.foundryId; itemData.system.equipped.carryType = "stowed"; } } if (e.invested) { itemData.system.equipped.carryType = "worn"; itemData.system.equipped.invested = true; itemData.system.equipped.inSlot = true; itemData.system.equipped.handsHeld = 0; } this.#resizeItem(itemData); this.result[type].push(itemData); e.addedId = itemData._id; } // eslint-disable-next-line require-atomic-updates e.added = true; } } async #processEquipmentItems() { // just in case it's in the equipment, pathbuilder should have translated this to items await this.#generateAdventurersPack(); await this.#generateContainers(); await this.#generateEquipmentItems(); } static applyRunes(parsedItem, itemData, type) { itemData.system.potencyRune.value = parsedItem.pot; if (type === "weapon") { itemData.system.strikingRune.value = parsedItem.str; } else if (type === "armor") { itemData.system.resiliencyRune.value = parsedItem.res; } if (type === "armor" && parsedItem.worn && ((Number.isInteger(parsedItem.pot) && parsedItem.pot > 0) || (parsedItem.res && parsedItem.res !== "") ) ) { itemData.system.equipped.invested = true; } if (parsedItem.runes[0]) itemData.system.propertyRune1.value = Seasoning.slugD(parsedItem.runes[0]); if (parsedItem.runes[1]) itemData.system.propertyRune2.value = Seasoning.slugD(parsedItem.runes[1]); if (parsedItem.runes[2]) itemData.system.propertyRune3.value = Seasoning.slugD(parsedItem.runes[2]); if (parsedItem.runes[3]) itemData.system.propertyRune4.value = Seasoning.slugD(parsedItem.runes[3]); if (parsedItem.mat) { const material = parsedItem.mat.split(" (")[0]; itemData.system.preciousMaterial.value = Seasoning.slugD(material); itemData.system.preciousMaterialGrade.value = Seasoning.getMaterialGrade(parsedItem.mat); } } async #generateWeaponItems() { for (const w of this.parsed.weapons) { if (Seasoning.IGNORED_EQUIPMENT().includes(w.pbName)) { w.added = true; w.addedAutoId = "ignored"; continue; } src_logger.debug("Generating weapon for", w); const indexMatch = this.compendiumMatchers["equipment"].getMatch(w.pbName, w.pbName); if (!indexMatch) { src_logger.error(`Unable to match weapon item ${w.name}`, w); this.bad.push({ pbName: w.pbName, type: "weapon", details: { w } }); continue; } const doc = await indexMatch.pack.getDocument(indexMatch.i._id); const itemData = doc.toObject(); itemData._id = foundry.utils.randomID(); itemData.system.quantity = w.qty; // because some shields don't have damage dice, but come in as weapons on pathbuilder if (itemData.type === "weapon") { itemData.system.damage.die = w.die; Pathmuncher.applyRunes(w, itemData, "weapon"); } if (w.display) itemData.name = w.display; this.#resizeItem(itemData); this.result.weapons.push(itemData); w.added = true; w.addedId = itemData._id; } } async #generateArmorItems() { for (const a of this.parsed.armor) { if (Seasoning.IGNORED_EQUIPMENT().includes(a.pbName)) { a.added = true; a.addedAutoId = "ignored"; continue; } src_logger.debug("Generating armor for", a); const indexMatch = this.compendiumMatchers["equipment"].getMatch(`${a.pbName} Armor`, a.pbName); if (!indexMatch) { src_logger.error(`Unable to match armor kit item ${a.name}`, a); this.bad.push({ pbName: a.pbName, type: "armor", details: { a } }); continue; } const doc = await indexMatch.pack.getDocument(indexMatch.i._id); const itemData = doc.toObject(); itemData._id = foundry.utils.randomID(); itemData.system.equipped.value = a.worn ?? false; if (!Seasoning.RESTRICTED_EQUIPMENT().some((i) => itemData.name.startsWith(i))) { itemData.system.equipped.inSlot = a.worn ?? false; itemData.system.quantity = a.qty; itemData.system.category = a.prof; const isShield = itemData.system.category === "shield"; itemData.system.equipped.handsHeld = isShield && a.worn ? 1 : 0; itemData.system.equipped.carryType = isShield && a.worn ? "held" : "worn"; Pathmuncher.applyRunes(a, itemData, "armor"); } if (a.display) itemData.name = a.display; this.#resizeItem(itemData); this.result.armor.push(itemData); // eslint-disable-next-line require-atomic-updates a.added = true; a.addedId = itemData._id; } } getClassSpellCastingType(dual = false) { const classCaster = dual ? this.source.spellCasters.find((caster) => caster.name === this.source.dualClass) : this.source.spellCasters.find((caster) => caster.name === this.source.class); const type = classCaster?.spellcastingType; if (type || this.source.spellCasters.length === 0) return type ?? "spontaneous"; // if no type and multiple spell casters, then return the first spell casting type return this.source.spellCasters[0].spellcastingType ?? "spontaneous"; } // aims to determine the class magic tradition for a spellcasting block getClassMagicTradition(caster) { const classCaster = [this.source.class, this.source.dualClass].includes(caster.name); const tradition = classCaster ? caster?.magicTradition : undefined; // if a caster tradition or no spellcasters, return divine if (tradition || this.source.spellCasters.length === 0) return tradition ?? "divine"; // not a focus traditions if (caster.magicTradition !== "focus" && ["divine", "occult", "primal", "arcane"].includes(caster.magicTradition)) { return caster.magicTradition; } // this spell caster type is not a class, determine class tradition based on ability const abilityTradition = this.source.spellCasters.find((c) => [this.source.class, this.source.dualClass].includes(c.name) && c.ability === caster.ability ); if (abilityTradition) return abilityTradition.magicTradition; // if no type and multiple spell casters, then return the first spell casting type return this.source.spellCasters[0].magicTradition && this.source.spellCasters[0].magicTradition !== "focus" ? this.source.spellCasters[0].magicTradition : "divine"; } #applySpellBlending(spellcastingEntity, caster) { if (caster.blendedSpells.length === 0) return; const remove = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; const add = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; // find adjustments caster.blendedSpells.forEach((slot) => { remove[slot.levelFrom]++; add[slot.LevelTo]++; }); for (let i = 0; i <= 10; i++) { const toAdd = this.options.adjustBlendedSlots ? 0 : Math.floor(add[i] / 2); const toRemove = this.options.adjustBlendedSlots ? remove[i] : 0; const adjustment = 0 - toRemove - toAdd; src_logger.debug("Adjusting spells for spell blending", { i, adjustment, add, remove, toAdd, max: spellcastingEntity.slots[`slot${i}`].max }); spellcastingEntity.slots[`slot${i}`].max += adjustment; spellcastingEntity.slots[`slot${i}`].value += adjustment; } } #generateSpellCaster(caster) { const isFocus = caster.magicTradition === "focus"; const magicTradition = this.getClassMagicTradition(caster); const spellcastingType = isFocus ? "focus" : caster.spellcastingType; const flexible = false; // placeholder const name = isFocus ? `${src_utils.capitalize(magicTradition)} ${caster.name}` : caster.name; const spellcastingEntity = { ability: { value: caster.ability, }, proficiency: { value: caster.proficiency / 2, }, spelldc: { item: 0, }, tradition: { value: magicTradition, }, prepared: { value: spellcastingType, flexible, }, slots: {}, showUnpreparedSpells: { value: true }, showSlotlessLevels: { value: true }, }; // apply slot data for (let i = 0; i <= 10; i++) { spellcastingEntity.slots[`slot${i}`] = { max: caster.perDay[i], prepared: {}, value: caster.perDay[i], }; } // adjust slots for spell blended effects this.#applySpellBlending(spellcastingEntity, caster); const data = { _id: foundry.utils.randomID(), name, type: "spellcastingEntry", system: spellcastingEntity, }; this.result.casters.push(data); return data; } #generateFocusSpellCaster(proficiency, ability, tradition) { const data = { _id: foundry.utils.randomID(), name: `${src_utils.capitalize(tradition)} Focus Tradition`, type: "spellcastingEntry", system: { ability: { value: ability, }, proficiency: { value: proficiency / 2, }, spelldc: { item: 0, }, tradition: { value: tradition, }, prepared: { value: "focus", flexible: false, }, showUnpreparedSpells: { value: true }, }, }; this.result.casters.push(data); return data; } async #loadSpell(spell, casterId, debugData) { const spellName = spellRename(spell.split("(")[0].trim()); src_logger.debug("focus spell details", { spell, spellName, debugData }); const indexMatch = this.compendiumMatchers["spells"].getMatch(spell, spellName, true); if (!indexMatch) { if (debugData.psychicAmpSpell) return undefined; src_logger.error(`Unable to match focus spell ${spell}`, { spell, spellName, debugData }); this.bad.push({ pbName: spell, type: "spell", details: { originalName: spell, name: spellName, debugData } }); return undefined; } const doc = await indexMatch.pack.getDocument(indexMatch.i._id); const itemData = doc.toObject(); itemData._id = foundry.utils.randomID(); itemData.system.location.value = casterId; return itemData; } // eslint-disable-next-line complexity async #processCasterSpells(instance, caster, spellEnhancements, forcePrepare = false) { const spellNames = {}; for (const spellSelection of caster.spells) { const level = spellSelection.spellLevel; const preparedAtLevel = caster.prepared?.length > 0 ? (caster.prepared.find((p) => p.spellLevel === level)?.list ?? []) : []; let preparedValue = 0; // const preparedMap = preparedAtLevel.reduce((acc, e) => acc.set(e, (acc.get(e) || 0) + 1), new Map()); for (const [i, spell] of spellSelection.list.entries()) { src_logger.debug(`Checking spell at ${i} for level ${level}`, { spell }); const itemData = await this.#loadSpell(spell, instance._id, { spellSelection, list: spellSelection.list, level, instance, }); if (itemData) { itemData.system.location.heightenedLevel = level; spellNames[spell] = itemData._id; this.result.spells.push(itemData); // if the caster is prepared we don't prepare spells as all known spells come through in JSON if (instance.system.prepared.value !== "prepared" || spellEnhancements?.preparePBSpells || forcePrepare || (caster.spellcastingType === "prepared" && preparedAtLevel.length === 0 && spellSelection.list.length <= caster.perDay[level]) ) { src_logger.debug(`Preparing spell ${itemData.name} for level ${level}`, { spell }); // eslint-disable-next-line require-atomic-updates instance.system.slots[`slot${level}`].prepared[preparedValue] = { id: itemData._id }; preparedValue++; } } } for (const spell of preparedAtLevel) { // if (spellNames.includes(spellName)) continue; const parsedSpell = getProperty(spellNames, spell); const itemData = parsedSpell ? this.result.spells.find((s) => s._id === parsedSpell) : await this.#loadSpell(spell, instance._id, { spellSelection, level, instance, }); if (itemData) { itemData.system.location.heightenedLevel = level; if (itemData && !parsedSpell) { spellNames[spell] = itemData._id; this.result.spells.push(itemData); } src_logger.debug(`Preparing spell ${itemData.name} for level ${level}`, { spellName: spell }); // eslint-disable-next-line require-atomic-updates instance.system.slots[`slot${level}`].prepared[preparedValue] = { id: itemData._id }; preparedValue++; } else { src_logger.warn(`Unable to find spell ${spell}`); } } if (spellEnhancements?.knownSpells) { for (const spell of spellEnhancements.knownSpells) { const itemData = await this.#loadSpell(spell, instance._id, { spellEnhancements, instance, }); if (itemData && !hasProperty(spellNames, itemData.name)) { itemData.system.location.heightenedLevel = level; spellNames[spell] = itemData._id; this.result.spells.push(itemData); } } } } } async #processFocusSpells(instance, spells) { for (const spell of spells) { const itemData = await this.#loadSpell(spell, instance._id, { instance, spells, spell, }); if (itemData) this.result.spells.push(itemData); if (spell.endsWith("(Amped)")) { const psychicSpell = spell.replace("(Amped)", "(Psychic)"); const psychicItemData = await this.#loadSpell(psychicSpell, instance._id, { instance, spells, spell: psychicSpell, psychicAmpSpell: true, }); if (psychicItemData) { this.result.spells.push(psychicItemData); } } } } async #processRituals() { if (!this.source.rituals) return; const ritualCompendium = new CompendiumMatcher({ type: "spells", indexFields: ["name", "type", "system.slug", "system.category.value"], }); await ritualCompendium.loadCompendiums(); const ritualFilters = { "system.category.value": "ritual", }; for (const ritual of this.source.rituals) { const ritualName = ritual.split("(")[0].trim(); src_logger.debug("focus spell details", { ritual, spellName: ritualName }); const indexMatch = this.compendiumMatchers["spells"].getNameMatchWithFilter(ritualName, ritualName, ritualFilters); if (!indexMatch) { src_logger.error(`Unable to match ritual spell ${ritual}`, { spell: ritual, spellName: ritualName }); this.bad.push({ pbName: ritual, type: "spell", details: { originalName: ritual, name: ritualName } }); continue; } const doc = await indexMatch.pack.getDocument(indexMatch.i._id); const itemData = doc.toObject(); itemData._id = foundry.utils.randomID(); this.result.spells.push(itemData); } } async #processSpells() { for (const caster of this.source.spellCasters) { src_logger.debug("Generating caster for", caster); if (Number.isInteger(parseInt(caster.focusPoints))) this.result.focusPool += caster.focusPoints; const instance = this.#generateSpellCaster(caster); src_logger.debug("Generated caster instance", instance); const spellEnhancements = Seasoning.getSpellCastingFeatureAdjustment(caster.name); let forcePrepare = false; if (hasProperty(spellEnhancements, "showSlotless")) { instance.system.showSlotlessLevels.value = getProperty(spellEnhancements, "showSlotless"); } else if ( caster.spellcastingType === "prepared" && ![this.source.class, this.source.dualClass].includes(caster.name) ) { const slotToPreparedMatch = caster.spells.every((spellBlock) => { const spellCount = spellBlock.list.length; const perDay = caster.perDay[spellBlock.spellLevel]; return perDay === spellCount; }); src_logger.debug(`Setting ${caster.name} show all slots to ${!slotToPreparedMatch}`); instance.system.showSlotlessLevels.value = !slotToPreparedMatch; forcePrepare = slotToPreparedMatch; } await this.#processCasterSpells(instance, caster, spellEnhancements, forcePrepare); } for (const tradition of ["occult", "primal", "divine", "arcane"]) { const traditionData = getProperty(this.source, `focus.${tradition}`); src_logger.debug(`Checking for focus tradition ${tradition}`); if (!traditionData) continue; for (const ability of ["str", "dex", "con", "int", "wis", "cha"]) { const abilityData = getProperty(traditionData, ability); src_logger.debug(`Checking for focus tradition ${tradition} with ability ${ability}`); if (!abilityData) continue; src_logger.debug("Generating focus spellcasting ", { tradition, traditionData, ability }); const instance = this.#generateFocusSpellCaster(abilityData.proficiency, ability, tradition); if (abilityData.focusCantrips && abilityData.focusCantrips.length > 0) { await this.#processFocusSpells(instance, abilityData.focusCantrips); } if (abilityData.focusSpells && abilityData.focusSpells.length > 0) { await this.#processFocusSpells(instance, abilityData.focusSpells); } } } setProperty(this.result.character, "system.resources.focus.max", this.source.focusPoints); setProperty(this.result.character, "system.resources.focus.value", this.source.focusPoints); } async #generateLores() { for (const lore of this.source.lores) { const data = { name: lore[0], type: "lore", system: { proficient: { value: lore[1] / 2, }, featType: "", mod: { value: 0, }, item: { value: 0, }, }, }; this.result.lores.push(data); } } async #generateMoney() { const compendium = game.packs.get("pf2e.equipment-srd"); const index = await compendium.getIndex({ fields: ["name", "type", "system.slug"] }); const moneyLookup = [ { slug: "platinum-pieces", type: "pp" }, { slug: "gold-pieces", type: "gp" }, { slug: "silver-pieces", type: "sp" }, { slug: "copper-pieces", type: "cp" }, ]; for (const lookup of moneyLookup) { const indexMatch = index.find((i) => i.system.slug === lookup.slug); if (indexMatch) { const doc = await compendium.getDocument(indexMatch._id); const itemData = doc.toObject(); itemData._id = foundry.utils.randomID(); itemData.system.quantity = this.source.money[lookup.type]; this.result.money.push(itemData); } } } async #processFormulas() { const uuids = []; for (const formulaSource of this.source.formula) { for (const formulaName of formulaSource.known) { const indexMatch = this.compendiumMatchers["formulas"].getMatch(formulaName, formulaName); if (!indexMatch) { src_logger.error(`Unable to match formula ${formulaName}`, { formulaSource, name: formulaName }); this.bad.push({ pbName: formulaName, type: "formula", details: { formulaSource, name: formulaName } }); continue; } const doc = await indexMatch.pack.getDocument(indexMatch.i._id); uuids.push({ uuid: doc.uuid }); } } setProperty(this.result.character, "system.crafting.formulas", uuids); } async #processFeats() { this.#sortParsedFeats(); // pre pass await this.#generateFeatItems("feats", { parsedFilter: "Ancestry Feat" }); await this.#generateFeatItems("feats", { parsedFilter: "Skill Feat" }); await this.#generateFeatItems("feats", { parsedFilter: "Class Feat" }); this.#statusUpdate(1, 5, "Feats"); await this.#generateFeatItems("feats"); this.#statusUpdate(2, 5, "Feats"); await this.#generateFeatItems("ancestryFeatures"); this.#statusUpdate(3, 5, "Feats"); await this.#generateSpecialItems("ancestryFeatures"); this.#statusUpdate(4, 5, "Feats"); await this.#generateSpecialItems("classFeatures"); this.#statusUpdate(5, 5, "Feats"); await this.#generateSpecialItems("actions"); } async #processEquipment() { this.#statusUpdate(1, 4, "Equipment"); await this.#processEquipmentItems(); this.#statusUpdate(2, 4, "Weapons"); await this.#generateWeaponItems(); this.#statusUpdate(3, 4, "Armor"); await this.#generateArmorItems(); this.#statusUpdate(2, 4, "Money"); await this.#generateMoney(); } async #generateTempActor(documents = [], includePassedDocumentsRules = false, includeGrants = false, includeFlagsOnly = false) { const actorData = mergeObject({ type: "character" }, this.result.character); actorData.name = `Mr Temp (${this.result.character.name})`; if (documents.map((d) => d.name.split("(")[0].trim().toLowerCase()).includes("skill training")) { delete actorData.system.skills; } const actor = await Actor.create(actorData); const currentState = duplicate(this.result); // console.warn("Initial temp actor", deepClone(actor)); const currentItems = [ ...currentState.deity, ...currentState.ancestry, ...currentState.heritage, ...currentState.background, ...currentState.class, ...currentState.lores, ...currentState.feats, ...currentState.casters, // ...currentState.spells, // ...currentState.equipment, // ...currentState.weapons, // ...currentState.armor, // ...currentState.treasure, // ...currentState.money, ]; for (const doc of documents) { if (!currentItems.some((d) => d._id === doc._id)) { currentItems.push(deepClone(doc)); } } try { // if the rule selected is an object, id doesn't take on import const ruleUpdates = []; for (const i of deepClone(currentItems)) { if (!i.system.rules || i.system.rules.length === 0) continue; const isPassedDocument = documents.some((d) => d._id === i._id); if (isPassedDocument && !includePassedDocumentsRules && !includeFlagsOnly) continue; const objectSelectionRules = i.system.rules .filter((r) => { const evaluateRules = ["RollOption", "ChoiceSet"].includes(r.key) && r.selection; return !includeFlagsOnly || evaluateRules; // && ["RollOption", "GrantItem", "ChoiceSet", "ActiveEffectLike"].includes(r.key); // || (["ChoiceSet"].includes(r.key) && r.selection); }) .map((r) => { r.ignored = false; return r; }); if (objectSelectionRules.length > 0) { ruleUpdates.push({ _id: i._id, system: { rules: objectSelectionRules, }, }); } } // console.warn("Rule updates", duplicate(ruleUpdates)); const items = duplicate(currentItems).map((i) => { if (i.system.items) i.system.items = []; if (i.system.rules) { i.system.rules = i.system.rules .filter((r) => { const isPassedDocument = documents.some((d) => d._id === i._id); const isChoiceSetSelection = ["ChoiceSet"].includes(r.key) && r.selection; // const choiceSetSelectionObject = isChoiceSetSelection && utils.isObject(r.selection); const choiceSetSelectionNotObject = isChoiceSetSelection && !src_utils.isObject(r.selection); // const grantRuleWithFlag = includeGrants && ["GrantItem"].includes(r.key) && r.flag; const grantRuleWithoutFlag = includeGrants && ["GrantItem"].includes(r.key) && !r.flag; // const genericDiscardRule = ["ChoiceSet", "GrantItem", "ActiveEffectLike", "Resistance", "Strike", "AdjustModifier"].includes(r.key); const genericDiscardRule = ["ChoiceSet", "GrantItem"].includes(r.key); const grantRuleFromItemFlag = includeGrants && ["GrantItem"].includes(r.key) && r.uuid.startsWith("{item|flags"); const rollOptionsRule = ["RollOption"].includes(r.key); const notPassedDocumentRules = !isPassedDocument && (choiceSetSelectionNotObject // || grantRuleWithFlag || grantRuleWithoutFlag || !genericDiscardRule); const passedDocumentRules = isPassedDocument && includePassedDocumentsRules && (isChoiceSetSelection || grantRuleWithoutFlag || grantRuleFromItemFlag || rollOptionsRule); return notPassedDocumentRules || passedDocumentRules; }) .map((r) => { // if choices is a string or an object then we replace with the query string results if ((src_utils.isString(r.choices) || src_utils.isObject(r.choices)) && r.choiceQueryResults) { r.choices = r.choiceQueryResults; } r.ignored = false; return r; }); } return i; }); // const items2 = duplicate(currentItems).map((i) => { // if (i.system.items) i.system.items = []; // if (i.system.rules) i.system.rules = i.system.rules.filter((r) => // (!documents.some((d) => d._id === i._id) // && ((["ChoiceSet",].includes(r.key) && r.selection) // // || (["GrantItem"].includes(r.key) && r.flag) // || !["ChoiceSet", "GrantItem"].includes(r.key) // )) // || (includePassedDocumentsRules && documents.some((d) => d._id === i._id) && ["ChoiceSet",].includes(r.key) && r.selection) // ).map((r) => { // if ((typeof r.choices === 'string' || r.choices instanceof String) // || (typeof r.choices === 'object' && !Array.isArray(r.choices) && r.choices !== null && r.choiceQueryResults) // ) { // r.choices = r.choiceQueryResults; // } // r.ignored = false; // return r; // }); // return i; // }); // console.warn("temp items", { // documents: deepClone(currentItems), // items: deepClone(items), // // items2: deepClone(items2), // // diff: diffObject(items, items2), // includePassedDocumentsRules, // includeGrants, // }); await actor.createEmbeddedDocuments("Item", items, { keepId: true }); // console.warn("restoring selection rules to temp items", ruleUpdates); await actor.updateEmbeddedDocuments("Item", ruleUpdates); const itemUpdates = []; for (const [key, value] of Object.entries(this.autoAddedFeatureItems)) { itemUpdates.push({ _id: `${key}`, system: { items: deepClone(value), }, }); } // console.warn("restoring feature items to temp items", itemUpdates); await actor.updateEmbeddedDocuments("Item", itemUpdates); src_logger.debug("Final temp actor", actor); } catch (err) { src_logger.error("Temp actor creation failed", { actor, documents, thisData: deepClone(this.result), actorData, err, currentItems, this: this, }); } return actor; } async processCharacter() { if (!this.source) return; await this.#prepare(); this.#statusUpdate(1, 12, "Character"); await this.#processCore(); this.#statusUpdate(2, 12, "Formula"); await this.#processFormulas(); this.#statusUpdate(3, 12, "Deity"); await this.#processGenericCompendiumLookup("deities", this.source.deity, "deity"); this.#statusUpdate(4, 12, "Ancestry"); await this.#processGenericCompendiumLookup("ancestries", this.source.ancestry, "ancestry"); this.#statusUpdate(5, 12, "Heritage"); await this.#processGenericCompendiumLookup("heritages", this.source.heritage, "heritage"); this.#statusUpdate(6, 12, "Background"); await this.#processGenericCompendiumLookup("backgrounds", this.source.background, "background"); this.#setSkills(); this.#statusUpdate(7, 12, "Class"); await this.#processGenericCompendiumLookup("classes", this.source.class, "class"); this.#setAbilityBoosts(); this.#statusUpdate(8, 12, "FeatureRec"); await this.#processFeats(); this.#statusUpdate(10, 12, "Equipment"); await this.#processEquipment(); this.#statusUpdate(11, 12, "Spells"); await this.#processSpells(); this.#statusUpdate(11, 12, "Rituals"); await this.#processRituals(); this.#statusUpdate(12, 12, "Lores"); await this.#generateLores(); } async #removeDocumentsToBeUpdated() { const moneyIds = this.actor.items.filter((i) => i.type === "treasure" && ["Platinum Pieces", "Gold Pieces", "Silver Pieces", "Copper Pieces"].includes(i.name) ); const classIds = this.actor.items.filter((i) => i.type === "class").map((i) => i._id); const deityIds = this.actor.items.filter((i) => i.type === "deity").map((i) => i._id); const backgroundIds = this.actor.items.filter((i) => i.type === "background").map((i) => i._id); const heritageIds = this.actor.items.filter((i) => i.type === "heritage").map((i) => i._id); const ancestryIds = this.actor.items.filter((i) => i.type === "ancestry").map((i) => i._id); const treasureIds = this.actor.items .filter((i) => i.type === "treasure" && !moneyIds.includes(i.id)) .map((i) => i._id); const featIds = this.actor.items.filter((i) => i.type === "feat").map((i) => i._id); const actionIds = this.actor.items.filter((i) => i.type === "action").map((i) => i._id); const equipmentIds = this.actor.items .filter((i) => i.type === "equipment" || i.type === "backpack" || i.type === "consumable") .map((i) => i._id); const weaponIds = this.actor.items.filter((i) => i.type === "weapon").map((i) => i._id); const armorIds = this.actor.items.filter((i) => i.type === "armor").map((i) => i._id); const loreIds = this.actor.items.filter((i) => i.type === "lore").map((i) => i._id); const spellIds = this.actor.items .filter((i) => i.type === "spell" || i.type === "spellcastingEntry") .map((i) => i._id); const formulaIds = this.actor.system.formulas; src_logger.debug("ids", { moneyIds, deityIds, classIds, backgroundIds, heritageIds, ancestryIds, treasureIds, featIds, actionIds, equipmentIds, weaponIds, armorIds, loreIds, spellIds, formulaIds, }); // eslint-disable-next-line complexity const keepIds = this.actor.items.filter((i) => (!this.options.addMoney && moneyIds.includes(i._id)) || (!this.options.addClass && classIds.includes(i._id)) || (!this.options.addDeity && deityIds.includes(i._id)) || (!this.options.addBackground && backgroundIds.includes(i._id)) || (!this.options.addHeritage && heritageIds.includes(i._id)) || (!this.options.addAncestry && ancestryIds.includes(i._id)) || (!this.options.addTreasure && treasureIds.includes(i._id)) || (!this.options.addFeats && (featIds.includes(i._id) || actionIds.includes(i._id))) || (!this.options.addEquipment && equipmentIds.includes(i._id)) || (!this.options.addWeapons && weaponIds.includes(i._id)) || (!this.options.addArmor && armorIds.includes(i._id)) || (!this.options.addLores && loreIds.includes(i._id)) || (!this.options.addSpells && spellIds.includes(i._id)) ).map((i) => i._id); const deleteIds = this.actor.items.filter((i) => !keepIds.includes(i._id)).map((i) => i._id); src_logger.debug("ids", { deleteIds, keepIds, }); await this.actor.deleteEmbeddedDocuments("Item", deleteIds); } async #createAndUpdateItemsWithRuleRestore(items) { const ruleUpdates = []; const newItems = deepClone(items); for (const item of newItems) { if (item.system.rules?.length > 0) { ruleUpdates.push({ _id: item._id, system: { rules: deepClone(item.system.rules).map((r) => { delete r.choiceQueryResults; return r; }), }, }); item.system.rules = item.system.rules .filter((r) => { const excludedKeys = ["ActiveEffectLike", "AdjustModifier", "Resistance", "Strike"].includes(r.key); const grantItemWithFlags = ["GrantItem"].includes(r.key) && (hasProperty(r, "flag") || getProperty(r, "pathmuncherImport")); const objectSelection = ["ChoiceSet"].includes(r.key) && src_utils.isObject(r.selection); return !excludedKeys && !grantItemWithFlags && !objectSelection; }) .map((r) => { if (r.key === "ChoiceSet") { if ((src_utils.isString(r.choices) || src_utils.isObject(r.choices)) && r.choiceQueryResults) { r.choices = r.choiceQueryResults; } } if (r.pathmuncherImport) delete r.pathmuncherImport; return r; }); } } src_logger.debug("Creating items", newItems); await this.actor.createEmbeddedDocuments("Item", newItems, { keepId: true }); src_logger.debug("Rule updates", ruleUpdates); await this.actor.updateEmbeddedDocuments("Item", ruleUpdates); } async #updateItems(type) { src_logger.debug(`Updating ${type}`, this.result[type]); await this.actor.updateEmbeddedDocuments("Item", this.result[type]); } async #createActorEmbeddedDocuments() { this.#statusUpdate(1, 12, "Character", "Eating"); if (this.options.addDeity) await this.#createAndUpdateItemsWithRuleRestore(this.result.deity); if (this.options.addAncestry) await this.#createAndUpdateItemsWithRuleRestore(this.result.ancestry); if (this.options.addHeritage) await this.#createAndUpdateItemsWithRuleRestore(this.result.heritage); if (this.options.addBackground) await this.#createAndUpdateItemsWithRuleRestore(this.result.background); if (this.options.addClass) await this.#createAndUpdateItemsWithRuleRestore(this.result.class); if (this.options.addLores) await this.#createAndUpdateItemsWithRuleRestore(this.result.lores); const featNums = this.result.feats.length; if (this.options.addFeats) { for (const [i, feat] of this.result.feats.entries()) { // console.warn(`creating ${feat.name}`, feat); this.#statusUpdate(i, featNums, "Feats", "Eating"); await this.#createAndUpdateItemsWithRuleRestore([feat]); } } // if (this.options.addFeats) await this.#createAndUpdateItemsWithRuleRestore(this.result.feats); if (this.options.addSpells) { this.#statusUpdate(3, 12, "Spells", "Eating"); await this.#createAndUpdateItemsWithRuleRestore(this.result.casters); await this.#createAndUpdateItemsWithRuleRestore(this.result.spells); } this.#statusUpdate(4, 12, "Equipment", "Eating"); if (this.options.addEquipment) { await this.#createAndUpdateItemsWithRuleRestore(this.result.equipment); await this.#updateItems("equipment"); } if (this.options.addWeapons) await this.#createAndUpdateItemsWithRuleRestore(this.result.weapons); if (this.options.addArmor) { await this.#createAndUpdateItemsWithRuleRestore(this.result.armor); await this.actor.updateEmbeddedDocuments("Item", this.result.armor); } if (this.options.addTreasure) await this.#createAndUpdateItemsWithRuleRestore(this.result.treasure); if (this.options.addMoney) await this.#createAndUpdateItemsWithRuleRestore(this.result.money); } async #restoreEmbeddedRuleLogic() { const importedItems = this.actor.items.map((i) => i._id); // Loop back over items and add rule and item progression data back in. src_logger.debug("Restoring logic", { currentActor: duplicate(this.actor) }); const itemUpdates = []; for (const [key, value] of Object.entries(this.autoAddedFeatureItems)) { if (importedItems.includes(key)) { itemUpdates.push({ _id: `${key}`, system: { items: deepClone(value), }, }); } } this.#statusUpdate(1, 12, "Feats", "Clearing"); src_logger.debug("Restoring granted item logic", itemUpdates); await this.actor.updateEmbeddedDocuments("Item", itemUpdates); await this.actor.update({ "system.resources.focus": this.result.character.system.resources.focus, }); } async updateActor() { await this.#removeDocumentsToBeUpdated(); if (!this.options.addName) { delete this.result.character.name; delete this.result.character.prototypeToken.name; } if (!this.options.addFormulas) { delete this.result.character.system.formulas; } if (!this.boosts.custom) { ["abilities"].forEach((location) => { const abilityTargets = ["str", "dex", "con", "int", "wis", "cha"] .filter((ability) => hasProperty(this.actor, `system.${location}.${ability}`)); const abilityDeletions = abilityTargets .reduce( (accumulated, ability) => ({ ...accumulated, [`-=${ability}`]: null, }), {} ); setProperty(this.result.character, `system.${location}`, abilityDeletions); }); } src_logger.debug("Generated result", this.result); await this.actor.update(this.result.character); await this.#createActorEmbeddedDocuments(); await this.#restoreEmbeddedRuleLogic(); } async postImportCheck() { const badClass = this.options.addClass ? this.bad.filter((b) => b.type === "class").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Class")}: ${b.pbName}
    • `) : []; const badHeritage = this.options.addHeritage ? this.bad.filter((b) => b.type === "heritage").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Heritage")}: ${b.pbName}
    • `) : []; const badAncestry = this.options.addAncestry ? this.bad.filter((b) => b.type === "ancestry").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Ancestry")}: ${b.pbName}
    • `) : []; const badBackground = this.options.addBackground ? this.bad.filter((b) => b.type === "background").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Background")}: ${b.pbName}
    • `) : []; const badDeity = this.options.addDeity ? this.bad.filter((b) => b.type === "deity" && b.pbName !== "Not set").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Deity")}: ${b.pbName}
    • `) : []; const badFeats = this.options.addFeats ? this.bad.filter((b) => b.type === "feat").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Feats")}: ${b.pbName}
    • `) : []; const badFeats2 = this.options.addFeats ? Object.values(this.check).filter((b) => b.type === "feat" && this.parsed.feats.some((f) => f.name === b.details.name && !f.added) ).map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Feats")}: ${b.details.name}
    • `) : []; const badSpecials = this.options.addFeats ? Object.values(this.check).filter((b) => (b.type === "special") && this.parsed.specials.some((f) => f.name === b.details.name && !f.added) ).map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Specials")}: ${b.details.name}
    • `) : []; const badEquipment = this.options.addEquipment ? this.bad.filter((b) => b.type === "equipment").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Equipment")}: ${b.pbName}
    • `) : []; const badWeapons = this.options.addWeapons ? this.bad.filter((b) => b.type === "weapons").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Weapons")}: ${b.pbName}
    • `) : []; const badArmor = this.options.addArmor ? this.bad.filter((b) => b.type === "armor").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Armor")}: ${b.pbName}
    • `) : []; const badSpellcasting = this.options.addSpells ? this.bad.filter((b) => b.type === "spellcasting").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Spellcasting")}: ${b.pbName}
    • `) : []; const badSpells = this.options.addSpells ? this.bad.filter((b) => b.type === "spells").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Spells")}: ${b.pbName}
    • `) : []; const badFamiliars = this.options.addFamiliars ? this.bad.filter((b) => b.type === "familiars").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Familiars")}: ${b.pbName}
    • `) : []; const badFormulas = this.options.addFormulas ? this.bad.filter((b) => b.type === "formulas").map((b) => `
  • ${game.i18n.localize("pathmuncher.Labels.Formulas")}: ${b.pbName}
    • `) : []; const totalBad = [ ...badClass, ...badAncestry, ...badHeritage, ...badBackground, ...badDeity, ...badFeats, ...badFeats2, ...badSpecials, ...badEquipment, ...badWeapons, ...badArmor, ...badSpellcasting, ...badSpells, ...badFamiliars, ...badFormulas, ]; let warning = ""; if (totalBad.length > 0) { warning += `

    ${game.i18n.localize("pathmuncher.Dialogs.Pathmuncher.MissingItemsOpen")}


    `; } src_logger.debug("Bad thing check", { badClass, badAncestry, badHeritage, badBackground, badDeity, badFeats, badFeats2, badSpecials, badEquipment, badWeapons, badArmor, badSpellcasting, badSpells, badFamiliars, badFormulas, totalBad, count: totalBad.length, focusPool: this.result.focusPool, warning, }); if (totalBad.length > 0) { ui.notifications.warn(game.i18n.localize("pathmuncher.Dialogs.Pathmuncher.CompletedWithNotes")); new Dialog({ title: game.i18n.localize("pathmuncher.Dialogs.Pathmuncher.ImportNotes"), content: warning, buttons: { yes: { icon: "", label: game.i18n.localize("pathmuncher.Labels.Finished"), }, }, default: "yes", }).render(true); } else { ui.notifications.info(game.i18n.localize("pathmuncher.Dialogs.Pathmuncher.CompletedSuccess")); } } } ;// CONCATENATED MODULE: ./src/app/PetShop.js /* eslint-disable no-await-in-loop */ /* eslint-disable no-continue */ /** * The PetShop class looks for familiars in a Pathmunch data set and creates/updates as appropriate. */ class PetShop { constructor ({ type = "familiar", parent, pathbuilderJson } = {}) { this.parent = parent; this.pathbuilderJson = pathbuilderJson; this.type = type; this.result = { pets: [], features: {}, }; this.bad = {}; this.folders = {}; } async ensureFolder(type) { const folderName = game.i18n.localize(`${constants.FLAG_NAME}.Folders.${type}`); this.folders[type] = await src_utils.getOrCreateFolder(this.parent.folder, "Actor", folderName); } async #existingPetCheck(petName, type) { const existingPet = game.actors.find((a) => a.type === type.toLowerCase() && a.name === petName && a.system.master.id === this.parent._id ); if (existingPet) return existingPet.toObject(); const actorData = { type: type.toLowerCase(), name: petName, system: { master: { id: this.parent._id, ability: this.parent.system.details.keyability.value, }, }, prototypeToken: { name: petName, }, folder: this.folders[type].id, }; const actor = await Actor.create(actorData); return actor.toObject(); } #buildCore(petData) { setProperty(petData, "system.attributes.value", this.parent.system.details.level.value * 5); return petData; } async #generatePetFeatures(pet, json) { const compendium = game.packs.get("pf2e.familiar-abilities"); const index = await compendium.getIndex({ fields: ["name", "type", "system.slug"] }); this.result.features[pet._id] = []; this.bad[pet._id] = []; for (const featureName of json.abilities) { const indexMatch = index.find((i) => i.system.slug === game.pf2e.system.sluggify(featureName)); if (!indexMatch) { src_logger.warn(`Unable to match pet feature ${featureName}`, { pet, json, name: featureName }); this.bad[pet._id].push({ pbName: featureName, type: "feature", details: { pet, json, name: featureName } }); continue; } const doc = (await compendium.getDocument(indexMatch._id)).toObject(); doc._id = foundry.utils.randomID(); this.result.features[pet._id].push(doc); } } async buildPet(json) { const name = json.name === json.type || !json.name.includes("(") ? `${this.parent.name}'s ${json.type}` : json.name.split("(")[1].split(")")[0]; const petData = await this.#existingPetCheck(name, json.type); const pet = this.#buildCore(petData); await this.#generatePetFeatures(pet, json); this.result.pets.push(pet); } async updatePets() { for (const petData of this.result.pets) { const actor = game.actors.get(petData._id); await actor.deleteEmbeddedDocuments("Item", [], { deleteAll: true }); await actor.update(petData); await actor.createEmbeddedDocuments("Item", this.result.features[petData._id], { keepId: true }); } } async processPets() { const petData = this.type === "familiar" && this.pathbuilderJson.familiars ? this.pathbuilderJson.familiars : this.pathbuilderJson.pets.filter((p) => this.type === p.type.toLowerCase()); await this.ensureFolder(src_utils.capitalize(this.type)); for (const petJson of petData) { await this.buildPet(petJson); } await this.updatePets(); src_logger.debug("Pets", { results: this.results, bad: this.bad, }); } async addPetEffects() { const features = []; for (const petData of this.result.pets) { for (const feature of this.result.features[petData._id].filter((f) => f.system.rules?.some((r) => r.key === "ActiveEffectLike"))) { if (!this.parent.items.some((i) => i.type === "effect" && i.system.slug === feature.system.slug)) { features.push(feature); } } } await this.parent.createEmbeddedDocuments("Item", features); } } ;// CONCATENATED MODULE: ./src/app/PathmuncherImporter.js class PathmuncherImporter extends FormApplication { constructor(options, actor) { super(options); this.actor = game.actors.get(actor.id ? actor.id : actor._id); this.backup = duplicate(this.actor); this.mode = "number"; } static get defaultOptions() { const options = super.defaultOptions; options.title = game.i18n.localize(`${constants.FLAG_NAME}.Dialogs.PathmuncherImporter.Title`); options.template = `${constants.PATH}/templates/pathmuncher.hbs`; options.classes = ["pathmuncher"]; options.id = "pathmuncher"; options.width = 400; options.closeOnSubmit = false; options.tabs = [{ navSelector: ".tabs", contentSelector: "form", initial: "number" }]; return options; } /** @override */ async getData() { const flags = src_utils.getFlags(this.actor); return { flags, id: flags?.pathbuilderId ?? "", actor: this.actor, }; } /** @override */ activateListeners(html) { super.activateListeners(html); $("#pathmuncher").css("height", "auto"); $(html) .find('.item') .on("click", (event) => { if (!event.target?.dataset?.tab) return; this.mode = event.target.dataset.tab; }); } static _updateProgress(total, count, type, prefixLabel = "Cooking") { const localizedType = game.i18n.localize(`pathmuncher.Labels.${type}`); const progressBar = document.getElementById("pathmuncher-status"); progressBar.style.width = `${Math.trunc((count / total) * 100)}%`; progressBar.innerHTML = `${game.i18n.localize(`pathmuncher.Labels.${prefixLabel}`)} (${localizedType})...`; } async _updateObject(event, formData) { document.getElementById("pathmuncher-button").disabled = true; const pathbuilderId = formData.textBoxBuildID; const options = { pathbuilderId, addMoney: formData.checkBoxMoney, addFeats: formData.checkBoxFeats, addSpells: formData.checkBoxSpells, adjustBlendedSlots: formData.checkBoxBlendedSlots, addEquipment: formData.checkBoxEquipment, addTreasure: formData.checkBoxTreasure, addLores: formData.checkBoxLores, addWeapons: formData.checkBoxWeapons, addArmor: formData.checkBoxArmor, addDeity: formData.checkBoxDeity, addName: formData.checkBoxName, addClass: formData.checkBoxClass, addBackground: formData.checkBoxBackground, addHeritage: formData.checkBoxHeritage, addAncestry: formData.checkBoxAncestry, addFamiliars: formData.checkBoxFamiliars, addFormulas: formData.checkBoxFormulas, statusCallback: PathmuncherImporter._updateProgress.bind(this), }; src_logger.debug("Pathmuncher options", options); await src_utils.setFlags(this.actor, options); const statusBar = document.getElementById("pathmuncher-import-progress"); statusBar.classList.toggle("import-hidden"); const pathmuncher = new Pathmuncher(this.actor, options); if (this.mode === "number") { await pathmuncher.fetchPathbuilder(pathbuilderId); } else if (this.mode === "json") { try { const jsonData = JSON.parse(formData.textBoxBuildJSON.trim()); pathmuncher.source = jsonData.build; } catch (err) { ui.notifications.error("Unable to parse JSON data"); return; } } src_logger.debug("Pathmuncher Source", pathmuncher.source); await pathmuncher.processCharacter(); src_logger.debug("Post processed character", pathmuncher); await pathmuncher.updateActor(); src_logger.debug("Final import details", { actor: this.actor, pathmuncher, options, pathbuilderSource: pathmuncher.source, pathbuilderId, }); if (options.addFamiliars) { const petShop = new PetShop({ type: "familiar", parent: this.actor, pathbuilderJson: pathmuncher.source }); await petShop.processPets(); await petShop.addPetEffects(); } this.close(); await pathmuncher.postImportCheck(); } } ;// CONCATENATED MODULE: ./src/hooks/api.js function registerAPI() { game.modules.get(constants.MODULE_NAME).api = { Pathmuncher: Pathmuncher, PathmuncherImporter: PathmuncherImporter, PetShop: PetShop, CompendiumMatcher: CompendiumMatcher, Seasoning: Seasoning, CompendiumSelector: CompendiumSelector, data: { generateFeatMap: FEAT_RENAME_MAP, equipment: EQUIPMENT_RENAME_MAP, restrictedEquipment: RESTRICTED_EQUIPMENT, feats: FEAT_RENAME_MAP(), }, utils: src_utils, CONSTANTS: constants, }; } ;// CONCATENATED MODULE: ./src/hooks/settings.js async function resetSettings() { for (const [name, data] of Object.entries(constants.GET_DEFAULT_SETTINGS())) { // eslint-disable-next-line no-await-in-loop await game.settings.set(constants.MODULE_NAME, name, data.default); } window.location.reload(); } class ResetSettingsDialog extends FormApplication { constructor(...args) { super(...args); // eslint-disable-next-line no-constructor-return return new Dialog({ title: game.i18n.localize(`${constants.FLAG_NAME}.Dialogs.ResetSettings.Title`), content: `

    ${game.i18n.localize( `${constants.FLAG_NAME}.Dialogs.ResetSettings.Content` )}

    `, buttons: { confirm: { icon: '', label: game.i18n.localize(`${constants.FLAG_NAME}.Dialogs.ResetSettings.Confirm`), callback: () => { resetSettings(); }, }, cancel: { icon: '', label: game.i18n.localize(`${constants.FLAG_NAME}.Dialogs.ResetSettings.Cancel`), }, }, default: "cancel", }); } } function registerSettings() { game.settings.registerMenu(constants.MODULE_NAME, "resetToDefaults", { name: `${constants.FLAG_NAME}.Settings.Reset.Title`, label: `${constants.FLAG_NAME}.Settings.Reset.Label`, hint: `${constants.FLAG_NAME}.Settings.Reset.Hint`, icon: "fas fa-refresh", type: ResetSettingsDialog, restricted: true, }); for (const [name, data] of Object.entries(constants.GET_DEFAULT_SETTINGS())) { game.settings.register(constants.MODULE_NAME, name, data); } game.settings.registerMenu(constants.MODULE_NAME, "selectCustomCompendiums", { name: `${constants.FLAG_NAME}.Settings.UseCustomCompendiumMappings.Title`, label: `${constants.FLAG_NAME}.Settings.UseCustomCompendiumMappings.Label`, hint: `${constants.FLAG_NAME}.Settings.UseCustomCompendiumMappings.Hint`, icon: "fas fa-book", type: CompendiumSelector, restricted: true, }); } ;// CONCATENATED MODULE: ./src/hooks/sheets.js function registerSheetButton() { const trustedUsersOnly = src_utils.setting("RESTRICT_TO_TRUSTED"); if (trustedUsersOnly && !game.user.isTrusted) return; /** * Character sheets */ const pcSheetNames = Object.values(CONFIG.Actor.sheetClasses.character) .map((sheetClass) => sheetClass.cls) .map((sheet) => sheet.name); pcSheetNames.forEach((sheetName) => { Hooks.on("render" + sheetName, (app, html, data) => { // only for GMs or the owner of this character if (!data.owner || !data.actor) return; const button = $(` ${constants.MODULE_FULL_NAME}`); button.click(() => { if (game.user.can("ACTOR_CREATE")) { const muncher = new PathmuncherImporter(PathmuncherImporter.defaultOptions, data.actor); muncher.render(true); } else { ui.notifications.warn(game.i18n.localize(`${constants.FLAG_NAME}.Notifications.CreateActorPermission`), { permanent: true }); } }); html.closest('.app').find('.pathmuncher-open').remove(); let titleElement = html.closest('.app').find('.window-title'); if (!app._minimized) button.insertAfter(titleElement); }); }); } ;// CONCATENATED MODULE: ./src/module.js Hooks.once("init", () => { registerSettings(); }); Hooks.once("ready", () => { registerSheetButton(); registerAPI(); }); /******/ })() ; //# sourceMappingURL=main.js.map