pallando/foundryvtt-wh4-lang-fr-fr
0
0
Fork 0
forked from public/foundryvtt-wh4-lang-fr-fr
Code Pull Requests Activity
0b286ac994
foundryvtt-wh4-lang-fr-fr/modules/fr-actor-wfrp4e.js

3610 lines
152 KiB
JavaScript
Raw Blame History

/**
* Provides the main Actor data computation and organization.
*
* ActorWfrp4e contains all the preparation data and methods used for preparing an actor:
* going through each Owned Item, preparing them for display based on characteristics.
* Additionally, it handles all the different types of roll requests, setting up the
* test dialog, how each test is displayed, etc.
*
*
* @see ActorSheetWfrp4e - Base sheet class
* @see ActorSheetWfrp4eCharacter - Character sheet class
* @see ActorSheetWfrp4eNPC - NPC sheet class
* @see ActorSheetWfrp4eCreature - Creature sheet class
* @see DiceWFRP4e - Sends test data to roll tests.
*/
export default class ActorWfrp4e_fr extends Actor {
/**
* Override the create() function to provide additional WFRP4e functionality.
*
* This overrided create() function adds initial items and flags to an actor
* upon creation. Namely: Basic skills, the 3 default coin values (brass
* pennies, silver shillings, gold crowns) at a quantity of 0, and setting
* up the default Automatic Calculation flags to be true. We still want to
* use the upstream create method, so super.create() is called at the end.
* Additionally - See the preCreateActor hook for more initial settings
* upon creation
*
* @param {Object} data Barebones actor data which this function adds onto.
* @param {Object} options (Unused) Additional options which customize the creation workflow.
*
*/
static async create(data, options) {
// If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
if (data.items) {
return super.create(data, options);
}
// Initialize empty items
data.items = [];
// Default auto calculation to true
data.flags =
{
autoCalcRun: true,
autoCalcWalk: true,
autoCalcWounds: true,
autoCalcCritW: true,
autoCalcCorruption: true,
autoCalcEnc: true,
autoCalcSize: true,
}
let basicSkills = await game.wfrp4e.utility.allBasicSkills() || [];
let moneyItems = await game.wfrp4e.utility.allMoneyItems() || [];
moneyItems = moneyItems.sort((a, b) => (a.data.coinValue.value > b.data.coinValue.value) ? -1 : 1);
// If character, automatically add basic skills and money items
if (data.type == "character") {
data.items = data.items.concat(basicSkills);
// Set all money items to 0, add to actor
data.items = data.items.concat(moneyItems.map(m => {
m.data.quantity.value = 0
return m
}))
super.create(data, options); // Follow through the the rest of the Actor creation process upstream
}
// If not a character, ask the user whether they want to add basic skills / money
else if (data.type == "npc" || data.type == "creature") {
new Dialog({
title: game.i18n.localize("ACTOR.BasicSkillsTitle"),
content: `<p>${game.i18n.localize("ACTOR.BasicSkillsPrompt")}</p>`,
buttons: {
yes: {
label: game.i18n.localize("Yes"),
callback: async dlg => {
data.items = data.items.concat(basicSkills);
// Set all money items to 0, add to actor
data.items = data.items.concat(moneyItems.map(m => {
m.data.quantity.value = 0
return m
}))
super.create(data, options); // Follow through the the rest of the Actor creation process upstream
}
},
no: {
label: game.i18n.localize("No"),
callback: async dlg => {
super.create(data, options); // Do not add new items, continue with the rest of the Actor creation process upstream
}
},
},
default: 'yes'
}).render(true);
}
}
prepareBaseData() {
// For each characteristic, calculate the total and bonus value
for (let ch of Object.values(this.data.data.characteristics)) {
ch.value = ch.initial + ch.advances + (ch.modifier || 0);
ch.bonus = Math.floor(ch.value / 10)
ch.cost = game.wfrp4e.utility._calculateAdvCost(ch.advances, "characteristic")
}
}
/**
* Calculates simple dynamic data when actor is updated.
*
* prepareData() is called when actor data is updated to recalculate values such as Characteristic totals, bonus (e.g.
* this is how Strength total and Strength Bonus gets updated whenever the user changes the Strength characteristic),
* movement values, and encumbrance. Some of these may or may not actually be calculated, depending on the user choosing
* not to have them autocalculated. These values are relatively simple, more complicated calculations that require items
* can be found in the sheet's getData() function.
*
* NOTE: NOT TO BE CONFUSED WITH prepare() - that function is called upon rendering to organize and process actor data
*
* @see ActorSheetWfrp4e.getData()
*/
prepareData() {
try {
super.prepareData();
const data = this.data;
if (this.data.type == "character")
this.prepareCharacter();
if (this.data.type == "creature")
this.prepareCreature();
// Only characters have experience
if (data.type === "character")
data.data.details.experience.current = data.data.details.experience.total - data.data.details.experience.spent;
// Auto calculation values - only calculate if user has not opted to enter ther own values
if (data.flags.autoCalcWalk)
data.data.details.move.walk = parseInt(data.data.details.move.value) * 2;
if (data.flags.autoCalcRun)
data.data.details.move.run = parseInt(data.data.details.move.value) * 4;
if (data.flags.autoCalcEnc)
data.data.status.encumbrance.max = data.data.characteristics.t.bonus + data.data.characteristics.s.bonus;
if (game.settings.get("wfrp4e", "capAdvantageIB"))
data.data.status.advantage.max = data.data.characteristics.i.bonus
else
data.data.status.advantage.max = 10;
if (!hasProperty(this, "data.flags.autoCalcSize"))
data.flags.autoCalcSize = true;
// Find size based on Traits/Talents
let size;
let trait = data.items.find(t => t.type == "trait" && t.name.toLowerCase().includes(game.i18n.localize("NAME.Size").toLowerCase()));
if (this.data.type == "creature") {
trait = data.items.find(t => t.type == "trait" && t.included && t.name.toLowerCase().includes(game.i18n.localize("NAME.Size").toLowerCase()))
}
if (trait)
size = trait.data.specification.value;
else {
size = data.items.find(x => x.type == "talent" && x.name.toLowerCase() == game.i18n.localize("NAME.Small").toLowerCase());
if (size)
size = size.name;
else
size = game.i18n.localize("SPEC.Average")
}
// If the size has been changed since the last known value, update the value
data.data.details.size.value = game.wfrp4e.utility.findKey(size, game.wfrp4e.config.actorSizes) || "avg"
// Now that we have size, calculate wounds and token size
if (data.flags.autoCalcWounds) {
let wounds = this._calculateWounds()
if (data.data.status.wounds.max != wounds) // If change detected, reassign max and current wounds
{
data.data.status.wounds.max = wounds;
data.data.status.wounds.value = wounds;
}
}
if (data.flags.autoCalcSize) {
//let tokenSize = WFRP4E.tokenSizes[data.data.details.size.value]
let tokenSize = game.wfrp4e.config.tokenSizes[data.data.details.size.value]
if (this.isToken) {
this.token.update({"height" : tokenSize, "width" : tokenSize });
}
data.token.height = tokenSize;
data.token.width = tokenSize;
}
// Auto calculation flags - if the user hasn't disabled various autocalculated values, calculate them
if (data.flags.autoCalcRun) {
// This is specifically for the Stride trait
if (data.items.find(t => t.type == "trait" && t.name.toLowerCase() == game.i18n.localize("NAME.Stride").toLowerCase()))
data.data.details.move.run += data.data.details.move.walk;
}
let talents = data.items.filter(t => t.type == "talent")
// talentTests is used to easily reference talent bonuses (e.g. in setupTest function and dialog)
// instead of iterating through every item again to find talents when rolling
data.flags.talentTests = [];
for (let talent of talents) // For each talent, if it has a Tests value, push it to the talentTests array
if (talent.data.tests.value)
data.flags.talentTests.push({ talentName: talent.name, test: talent.data.tests.value, SL: talent.data.advances.value });
// ------------------------ Talent Modifications ------------------------
// These consist of Strike Mighty Blow, Accurate Shot, and Robust. Each determines
// how many advances there are according to preparedData, then modifies the flag value
// if there's any difference.
// Strike Mighty Blow Talent
let smb = talents.filter(t => t.name.toLowerCase() == game.i18n.localize("NAME.SMB").toLowerCase()).reduce((advances, talent) => advances + talent.data.advances.value, 0)
if (smb)
data.flags.meleeDamageIncrease = smb
else if (!smb)
data.flags.meleeDamageIncrease = 0
// Accurate Shot Talent
let accshot = talents.filter(t => t.name.toLowerCase() == game.i18n.localize("NAME.AS").toLowerCase()).reduce((advances, talent) => advances + talent.data.advances.value, 0)
if (accshot)
data.flags.rangedDamageIncrease = accshot;
else if (!accshot)
data.flags.rangedDamageIncrease = 0
// Robust Talent
let robust = talents.filter(t => t.name.toLowerCase() == game.i18n.localize("NAME.Robust").toLowerCase()).reduce((advances, talent) => advances + talent.data.advances.value, 0)
if (robust)
data.flags.robust = robust;
else
data.flags.robust = 0
let ambi = talents.filter(t => t.name.toLowerCase() == game.i18n.localize("NAME.Ambi").toLowerCase()).reduce((advances, talent) => advances + talent.data.advances.value, 0)
data.flags.ambi = ambi;
}
catch (error) {
console.error("Something went wrong with preparing actor data: " + error)
ui.notifications.error(game.i18n.localize("ACTOR.PreparationError") + error)
}
}
/**
* Augments actor preparation with additional calculations for Characters.
*
* Characters have more features and so require more calculation. Specifically,
* this will add pure soul talent advances to max corruption, as well as display
* current career values (details, advancement indicatiors, etc.).
*
* Note that this functions requires actorData to be prepared, by this.prepare().
*
* @param {Object} actorData prepared actor data to augment
*/
prepareCharacter() {
if (this.data.type != "character")
return;
let tb = this.data.data.characteristics.t.bonus;
let wpb = this.data.data.characteristics.wp.bonus;
// If the user has not opted out of auto calculation of corruption, add pure soul value
if (this.data.flags.autoCalcCorruption) {
this.data.data.status.corruption.max = tb + wpb;
let pureSoulTalent = this.data.items.find(x => x.type == "talent" && x.name.toLowerCase() == (game.i18n.localize("NAME.PS")).toLowerCase())
if (pureSoulTalent)
this.data.data.status.corruption.max += pureSoulTalent.data.advances.value;
}
}
prepareNPC() {
}
/**
* Augments actor preparation with additional calculations for Creatures.
*
* preparing for Creatures mainly involves excluding traits that were marked to be excluded,
* then replacing the traits array with only the included traits (which is used by prepare()).
*
* Note that this functions requires actorData to be prepared, by this.prepare().
*
* @param {Object} actorData prepared actor data to augment
*/
prepareCreature() {
if (this.data.type != "creature")
return;
// mark each trait as included or not
for (let trait of this.data.items.filter(i => i.type == "trait")) {
if (this.data.data.excludedTraits.includes(trait._id))
trait.included = false;
else
trait.included = true;
}
}
/* --------------------------------------------------------------------------------------------------------- */
/* Setting up Rolls
/*
/* All "setup______" functions gather the data needed to roll a certain test. These are in 3 main objects.
/* These 3 objects are then given to DiceWFRP.setupDialog() to show the dialog, see that function for its usage.
/*
/* The 3 Main objects:
/* testData - Data associated with modifications to rolling the test itself, or results of the test.
/* Examples of this are whether hit locations are found, Weapon qualities that may cause
criticals/fumbles more often or ingredients for spells that cancel miscasts.
dialogOptions - Data for rendering the dialog that's important for a specific test type.
Example: when casting or channelling, there should be an option for Malignant
Influences, but only for those tests.
cardOptions - Which card to use, the title of the card, the name of the actor, etc.
/* --------------------------------------------------------------------------------------------------------- */
/**
* Setup a Characteristic Test.
*
* Characteristics tests are the simplest test, all that needs considering is the target number of the
* characteristic being tested, and any modifiers the user enters.
*
* @param {String} characteristicId The characteristic id (e.g. "ws") - id's can be found in config.js
*
*/
setupCharacteristic(characteristicId, options = {}) {
let char = this.data.data.characteristics[characteristicId];
let title = game.i18n.localize(char.label) + " " + game.i18n.localize("Test");
let testData = {
target: char.value,
hitLocation: false,
extra: {
size : this.data.data.details.size.value,
actor : this.data,
options: options
}
};
if (options.rest)
testData.extra.options["tb"] = char.bonus;
// Default a WS or BS test to have hit location checked
if (characteristicId == "ws" || characteristicId == "bs")
testData.hitLocation = true;
// Setup dialog data: title, template, buttons, prefilled data
let dialogOptions = {
title: title,
template: "/systems/wfrp4e/templates/dialog/characteristic-dialog.html",
// Prefilled dialog data
data: {
hitLocation: testData.hitLocation,
talents: this.data.flags.talentTests,
advantage: this.data.data.status.advantage.value || 0,
rollMode: options.rollMode
},
callback: (html) => {
// When dialog confirmed, fill testData dialog information
// Note that this does not execute until DiceWFRP.setupDialog() has finished and the user confirms the dialog
cardOptions.rollMode = html.find('[name="rollMode"]').val();
testData.testModifier = Number(html.find('[name="testModifier"]').val());
testData.testDifficulty = game.wfrp4e.config.difficultyModifiers[html.find('[name="testDifficulty"]').val()];
testData.successBonus = Number(html.find('[name="successBonus"]').val());
testData.slBonus = Number(html.find('[name="slBonus"]').val());
// Target value is the final value being tested against, after all modifiers and bonuses are added
testData.target = testData.target + testData.testModifier + testData.testDifficulty;
testData.hitLocation = html.find('[name="hitLocation"]').is(':checked');
let talentBonuses = html.find('[name = "talentBonuses"]').val();
// Combine all Talent Bonus values (their times taken) into one sum
testData.successBonus += talentBonuses.reduce(function (prev, cur) {
return prev + Number(cur)
}, 0)
return { testData, cardOptions };
}
};
if (options.corruption) {
title = `Corrupting Influence - ${game.i18n.localize(char.label)} Test`
dialogOptions.title = title;
dialogOptions.data.testDifficulty = "challenging"
}
if (options.mutate) {
title = `Dissolution of Body and Mind - ${game.i18n.localize(char.label)} Test`
dialogOptions.title = title;
dialogOptions.data.testDifficulty = "challenging"
}
if (options.rest) {
dialogOptions.data.testDifficulty = "average"
}
// Call the universal cardOptions helper
let cardOptions = this._setupCardOptions("systems/wfrp4e/templates/chat/roll/characteristic-card.html", title)
// Provide these 3 objects to setupDialog() to create the dialog and assign the roll function
return game.wfrp4e.dice.setupDialog({
dialogOptions: dialogOptions,
testData: testData,
cardOptions: cardOptions
});
}
/**
* Setup a Skill Test.
*
* Skill tests are much like Characteristic Tests in their simplicity, just with another layer of modifiers (skill advances).
* However, there is more complication if the skill is instead for an Income test, which adds computation after the roll is
* completed.
*
* @param {Object} skill The skill item being tested. Skill items contain the advancements and the base characteristic, see template.json for more information.
* @param {bool} income Whether or not the skill is being tested to determine Income.
*/
setupSkill(skill, options = {}) {
let title = skill.name + " " + game.i18n.localize("Test");
let testData = {
hitLocation: false,
income: options.income,
target: this.data.data.characteristics[skill.data.characteristic.value].value + skill.data.advances.value,
extra: {
size: this.data.data.details.size.value,
actor : this.data,
options: options,
skill: skill
}
};
// Default a WS, BS, Melee, or Ranged to have hit location checked
if (skill.data.characteristic.value == "ws" ||
skill.data.characteristic.value == "bs" ||
skill.name.includes(game.i18n.localize("NAME.Melee")) ||
skill.name.includes(game.i18n.localize("NAME.Ranged"))) {
testData.hitLocation = true;
}
// Setup dialog data: title, template, buttons, prefilled data
let dialogOptions = {
title: title,
template: "/systems/wfrp4e/templates/dialog/skill-dialog.html",
// Prefilled dialog data
data: {
hitLocation: testData.hitLocation,
talents: this.data.flags.talentTests,
characteristicList: game.wfrp4e.config.characteristics,
characteristicToUse: skill.data.characteristic.value,
advantage: this.data.data.status.advantage.value || 0,
rollMode: options.rollMode
},
callback: (html) => {
// When dialog confirmed, fill testData dialog information
// Note that this does not execute until DiceWFRP.setupDialog() has finished and the user confirms the dialog
cardOptions.rollMode = html.find('[name="rollMode"]').val();
testData.testModifier = Number(html.find('[name="testModifier"]').val());
testData.testDifficulty = game.wfrp4e.config.difficultyModifiers[html.find('[name="testDifficulty"]').val()];
testData.successBonus = Number(html.find('[name="successBonus"]').val());
testData.slBonus = Number(html.find('[name="slBonus"]').val());
let characteristicToUse = html.find('[name="characteristicToUse"]').val();
// Target value is the final value being tested against, after all modifiers and bonuses are added
testData.target =
this.data.data.characteristics[characteristicToUse].value
+ testData.testModifier
+ testData.testDifficulty
+ skill.data.advances.value
+ skill.data.modifier.value
testData.hitLocation = html.find('[name="hitLocation"]').is(':checked');
let talentBonuses = html.find('[name = "talentBonuses"]').val();
// Combine all Talent Bonus values (their times taken) into one sum
testData.successBonus += talentBonuses.reduce(function (prev, cur) {
return prev + Number(cur)
}, 0)
return { testData, cardOptions };
}
};
// If Income, use the specialized income roll handler and set testDifficulty to average
if (testData.income) {
dialogOptions.data.testDifficulty = "average";
}
if (options.corruption) {
title = `Corrupting Influence - ${skill.name} Test`
dialogOptions.title = title;
dialogOptions.data.testDifficulty = "challenging"
}
if (options.mutate) {
title = `Dissolution of Body and Mind - ${skill.name} Test`
dialogOptions.title = title;
dialogOptions.data.testDifficulty = "challenging"
}
// If Rest & Recover, set testDifficulty to average
if (options.rest) { dialogOptions.data.testDifficulty = "average"; }
// Call the universal cardOptions helper
let cardOptions = this._setupCardOptions("systems/wfrp4e/templates/chat/roll/skill-card.html", title)
if (options.corruption)
cardOptions.rollMode = "gmroll"
// Provide these 3 objects to setupDialog() to create the dialog and assign the roll function
return game.wfrp4e.dice.setupDialog({
dialogOptions: dialogOptions,
testData: testData,
cardOptions: cardOptions
});
}
/**
* Setup a Weapon Test.
*
* Probably the most complicated type of Test, weapon tests' complexity comes from all the different
* factors and variables of the different weapons available and how they might affect test results,
* as well as ammo usage, the effects of using different skills etc.
*
* @param {Object} weapon The weapon Item being used.
* @param {bool} event The event that called this Test, used to determine if attack is melee or ranged.
*/
setupWeapon(weapon, options = {}) {
let skillCharList = []; // This array is for the different options available to roll the test (Skills and characteristics)
let slBonus = 0 // Used when wielding Defensive weapons
let modifier = 0; // Used when attacking with Accurate weapons
let successBonus = 0;
let title = game.i18n.localize("WeaponTest") + " - " + weapon.name;
// Prepare the weapon to have the complete data object, including qualities/flaws, damage value, etc.
let wep = this.prepareWeaponCombat(duplicate(weapon));
let testData = {
target: 0,
hitLocation: true,
extra: { // Store this extra weapon/ammo data for later use
weapon: wep,
size: this.data.data.details.size.value,
actor : this.data,
champion: !!this.items.find(i => i.data.name.toLowerCase() == game.i18n.localize("NAME.Champion").toLowerCase() && i.type == "trait"),
riposte: !!this.items.find(i => i.data.name.toLowerCase() == game.i18n.localize("NAME.Riposte").toLowerCase() && i.type == "talent"),
options: options
}
};
if (wep.attackType == "melee")
skillCharList.push(game.i18n.localize("Weapon Skill"))
else if (wep.attackType == "ranged") {
// If Ranged, default to Ballistic Skill, but check to see if the actor has the specific skill for the weapon
skillCharList.push(game.i18n.localize("Ballistic Skill"))
if (weapon.data.weaponGroup.value != "throwing" && weapon.data.weaponGroup.value != "explosives" && weapon.data.weaponGroup.value != "entangling") {
// Check to see if they have ammo if appropriate
testData.extra.ammo = duplicate(this.getEmbeddedEntity("OwnedItem", weapon.data.currentAmmo.value))
if (!testData.extra.ammo || weapon.data.currentAmmo.value == 0 || testData.extra.ammo.data.quantity.value == 0) {
AudioHelper.play({ src: "systems/wfrp4e/sounds/no.wav" }, false)
ui.notifications.error(game.i18n.localize("Error.NoAmmo"))
return
}
}
else if (weapon.data.weaponGroup.value != "entangling" && weapon.data.quantity.value == 0) {
// If this executes, it means it uses its own quantity for ammo (e.g. throwing), which it has none of
AudioHelper.play({ src: "systems/wfrp4e/sounds/no.wav" }, false)
ui.notifications.error(game.i18n.localize("Error.NoAmmo"))
return;
}
else {
// If this executes, it means it uses its own quantity for ammo (e.g. throwing)
testData.extra.ammo = weapon;
}
}
let defaultSelection // The default skill/characteristic being used
if (wep.skillToUse) {
// If the actor has the appropriate skill, default to that.
skillCharList.push(wep.skillToUse.name)
defaultSelection = skillCharList.indexOf(wep.skillToUse.name)
testData.target = this.data.data.characteristics[wep.skillToUse.data.characteristic.value].value + wep.skillToUse.data.advances.value;
}
// Bypass macro default values
if (!testData.target)
testData.target = wep.attackType == "melee" ? this.data.data.characteristics["ws"].value : this.data.data.characteristics["bs"].value
// ***** Automatic Test Data Fill Options ******
// If offhand and should apply offhand penalty (should apply offhand penalty = not parry, not defensive, and not twohanded)
if (getProperty(wep, "data.offhand.value") && !wep.data.twohanded.value && !(weapon.data.weaponGroup.value == "parry" && wep.properties.qualities.includes(game.i18n.localize("PROPERTY.Defensive"))))
{
modifier = -20
modifier += Math.min(20, this.data.flags.ambi * 10)
}
// Try to automatically fill the dialog with values based on context
// If the auto-fill setting is true, and there is combat....
if (game.settings.get("wfrp4e", "testAutoFill") && (game.combat && game.combat.data.round != 0 && game.combat.turns)) {
try {
let currentTurn = game.combat.turns[game.combat.current.turn]
// If actor is a token
if (this.data.token.actorLink) {
// If it is NOT the actor's turn
if (currentTurn && this.data.token != currentTurn.token)
slBonus = this.data.flags.defensive; // Prefill Defensive values (see prepareItems() for how defensive flags are assigned)
else // If it is the actor's turn
{
// Prefill dialog according to qualities/flaws
if (wep.properties.qualities.includes(game.i18n.localize("PROPERTY.Accurate")))
modifier += 10;
if (wep.properties.qualities.includes(game.i18n.localize("PROPERTY.Precise")))
successBonus += 1;
if (wep.properties.flaws.includes(game.i18n.localize("PROPERTY.Imprecise")))
slBonus -= 1;
}
}
else // If the actor is not a token
{
// If it is NOT the actor's turn
if (currentTurn && currentTurn.tokenId != this.token.data._id)
slBonus = this.data.flags.defensive;
else // If it is the actor's turn
{
// Prefill dialog according to qualities/flaws
if (wep.properties.qualities.includes(game.i18n.localize("PROPERTY.Accurate")))
modifier += 10;
if (wep.properties.qualities.includes(game.i18n.localize("PROPERTY.Precise")))
successBonus += 1;
if (wep.properties.flaws.includes(game.i18n.localize("PROPERTY.Imprecise")))
slBonus -= 1;
}
}
}
catch // If something went wrong, default to 0 for all prefilled data
{
slBonus = 0;
successBonus = 0;
modifier = 0;
}
}
// Setup dialog data: title, template, buttons, prefilled data
let dialogOptions = {
title: title,
template: "/systems/wfrp4e/templates/dialog/weapon-dialog.html",
// Prefilled dialog data
data: {
hitLocation: testData.hitLocation,
talents: this.data.flags.talentTests,
skillCharList: skillCharList,
slBonus: slBonus || 0,
successBonus: successBonus || 0,
testDifficulty: options.difficulty,
modifier: modifier || 0,
defaultSelection: defaultSelection,
advantage: this.data.data.status.advantage.value || 0,
rollMode: options.rollMode
},
callback: (html) => {
// When dialog confirmed, fill testData dialog information
// Note that this does not execute until DiceWFRP.setupDialog() has finished and the user confirms the dialog
cardOptions.rollMode = html.find('[name="rollMode"]').val();
testData.testModifier = Number(html.find('[name="testModifier"]').val());
testData.testDifficulty = game.wfrp4e.config.difficultyModifiers[html.find('[name="testDifficulty"]').val()];
testData.successBonus = Number(html.find('[name="successBonus"]').val());
testData.slBonus = Number(html.find('[name="slBonus"]').val());
let skillSelected = skillCharList[Number(html.find('[name="skillSelected"]').val())];
// Determine final target if a characteristic was selected
if (skillSelected == game.i18n.localize("CHAR.WS") || skillSelected == game.i18n.localize("CHAR.BS")) {
if (skillSelected == game.i18n.localize("CHAR.WS"))
testData.target = this.data.data.characteristics.ws.value
else if (skillSelected == game.i18n.localize("CHAR.BS"))
testData.target = this.data.data.characteristics.bs.value
testData.target += testData.testModifier + testData.testDifficulty;
}
else // If a skill was selected
{
// If using the appropriate skill, set the target number to characteristic value + advances + modifiers
// Target value is the final value being tested against, after all modifiers and bonuses are added
let skillUsed = testData.extra.weapon.skillToUse;
testData.target =
this.data.data.characteristics[skillUsed.data.characteristic.value].value
+ testData.testModifier
+ testData.testDifficulty
+ skillUsed.data.advances.value
+ skillUsed.data.modifier.value
}
testData.hitLocation = html.find('[name="hitLocation"]').is(':checked');
let talentBonuses = html.find('[name = "talentBonuses"]').val();
// Combine all Talent Bonus values (their times taken) into one sum
testData.successBonus += talentBonuses.reduce(function (prev, cur) {
return prev + Number(cur)
}, 0)
return { testData, cardOptions };
}
};
// Call the universal cardOptions helper
let cardOptions = this._setupCardOptions("systems/wfrp4e/templates/chat/roll/weapon-card.html", title)
// Provide these 3 objects to setupDialog() to create the dialog and assign the roll function
return game.wfrp4e.dice.setupDialog({
dialogOptions: dialogOptions,
testData: testData,
cardOptions: cardOptions
});
}
/**
* Setup a Casting Test.
*
* Casting tests are more complicated due to the nature of spell miscasts, ingredients, etc. Whatever ingredient
* is selected will automatically be used and negate one miscast. For the spell rolling logic, see DiceWFRP.rollCastTest
* where all this data is passed to in order to calculate the roll result.
*
* @param {Object} spell The spell Item being Casted. The spell item has information like CN, lore, and current ingredient ID
*
*/
setupCast(spell, options = {}) {
let title = game.i18n.localize("CastingTest") + " - " + spell.name;
// castSkill array holds the available skills/characteristics to cast with - Casting: Intelligence
let castSkills = [{ key: "int", name: game.i18n.localize("CHAR.Int") }]
// if the actor has Language (Magick), add it to the array.
castSkills = castSkills.concat(this.items.filter(i => i.name.toLowerCase() == `${game.i18n.localize("Language")} (${game.i18n.localize("Magick")})`.toLowerCase() && i.type == "skill"))
// Default to Language Magick if it exists
let defaultSelection = castSkills.findIndex(i => i.name.toLowerCase() == `${game.i18n.localize("Language")} (${game.i18n.localize("Magick")})`.toLowerCase())
// Whether the actor has Instinctive Diction is important in the test rolling logic
let instinctiveDiction = (this.data.flags.talentTests.findIndex(x => x.talentName.toLowerCase() == game.i18n.localize("NAME.ID").toLowerCase()) > -1) // instinctive diction boolean
// Prepare the spell to have the complete data object, including damage values, range values, CN, etc.
let preparedSpell = this.prepareSpellOrPrayer(spell);
let testData = {
target: 0,
extra: { // Store this data to be used by the test logic
spell: preparedSpell,
malignantInfluence: false,
ingredient: false,
ID: instinctiveDiction,
size: this.data.data.details.size.value,
actor : this.data,
options: options
}
};
// If the spell does damage, default the hit location to checked
if (preparedSpell.damage)
testData.hitLocation = true;
// Setup dialog data: title, template, buttons, prefilled data
let dialogOptions = {
title: title,
template: "/systems/wfrp4e/templates/dialog/spell-dialog.html",
// Prefilled dialog data
data: {
hitLocation: testData.hitLocation,
malignantInfluence: testData.malignantInfluence,
talents: this.data.flags.talentTests,
advantage: this.data.data.status.advantage.value || 0,
defaultSelection: defaultSelection,
castSkills: castSkills,
rollMode: options.rollMode
},
callback: (html) => {
// When dialog confirmed, fill testData dialog information
// Note that this does not execute until DiceWFRP.setupDialog() has finished and the user confirms the dialog
cardOptions.rollMode = html.find('[name="rollMode"]').val();
testData.testModifier = Number(html.find('[name="testModifier"]').val());
testData.testDifficulty = game.wfrp4e.config.difficultyModifiers[html.find('[name="testDifficulty"]').val()];
testData.successBonus = Number(html.find('[name="successBonus"]').val());
testData.slBonus = Number(html.find('[name="slBonus"]').val());
let skillSelected = castSkills[Number(html.find('[name="skillSelected"]').val())];
// If an actual skill (Language Magick) was selected, use that skill to calculate the target number
if (skillSelected.key != "int") {
testData.target = this.data.data.characteristics[skillSelected.data.data.characteristic.value].value
+ skillSelected.data.data.advances.value
+ skillSelected.data.data.modifier.value
+ testData.testDifficulty
+ testData.testModifier;
}
else // if a characteristic was selected, use just the characteristic
{
testData.target = this.data.data.characteristics.int.value
+ testData.testDifficulty
+ testData.testModifier;
}
testData.hitLocation = html.find('[name="hitLocation"]').is(':checked');
testData.extra.malignantInfluence = html.find('[name="malignantInfluence"]').is(':checked');
let talentBonuses = html.find('[name = "talentBonuses"]').val();
// Combine all Talent Bonus values (their times taken) into one sum
testData.successBonus += talentBonuses.reduce(function (prev, cur) {
return prev + Number(cur)
}, 0)
return { testData, cardOptions };
}
};
// Call the universal cardOptions helper
let cardOptions = this._setupCardOptions("systems/wfrp4e/templates/chat/roll/spell-card.html", title)
// Provide these 3 objects to setupDialog() to create the dialog and assign the roll function
return game.wfrp4e.dice.setupDialog({
dialogOptions: dialogOptions,
testData: testData,
cardOptions: cardOptions
});
}
/**
* Setup a Channelling Test.
*
* Channelling tests are more complicated due to the nature of spell miscasts, ingredients, etc. Whatever ingredient
* is selected will automatically be used and mitigate miscasts. For the spell rolling logic, see DiceWFRP.rollChannellTest
* where all this data is passed to in order to calculate the roll result.
*
* @param {Object} spell The spell Item being Channelled. The spell item has information like CN, lore, and current ingredient ID
* This spell SL will then be updated accordingly.
*
*/
setupChannell(spell, options = {}) {
let title = game.i18n.localize("ChannellingTest") + " - " + spell.name;
// channellSkills array holds the available skills/characteristics to with - Channelling: Willpower
let channellSkills = [{ key: "wp", name: game.i18n.localize("CHAR.WP") }]
// if the actor has any channel skills, add them to the array.
channellSkills = channellSkills.concat(this.items.filter(i => i.name.toLowerCase().includes(game.i18n.localize("NAME.Channelling").toLowerCase()) && i.type == "skill"))
// Find the spell lore, and use that to determine the default channelling selection
let spellLore = spell.data.lore.value;
let defaultSelection
if (spell.data.wind && spell.data.wind.value) {
defaultSelection = channellSkills.indexOf(channellSkills.find(x => x.name.includes(spell.data.wind.value)))
if (defaultSelection == -1) {
let customChannellSkill = this.items.find(i => i.name.toLowerCase().includes(spell.data.wind.value.toLowerCase()) && i.type == "skill");
if (customChannellSkill) {
channellSkills.push(customChannellSkill)
defaultSelection = channellSkills.length - 1
}
}
}
else {
defaultSelection = channellSkills.indexOf(channellSkills.find(x => x.name.includes(game.wfrp4e.config.magicWind[spellLore])));
}
if (spellLore == "witchcraft")
defaultSelection = channellSkills.indexOf(channellSkills.find(x => x.name.toLowerCase().includes(game.i18n.localize("NAME.Channelling").toLowerCase())))
// Whether the actor has Aethyric Attunement is important in the test rolling logic
let aethyricAttunement = (this.data.flags.talentTests.findIndex(x => x.talentName.toLowerCase() == game.i18n.localize("NAME.AA").toLowerCase()) > -1) // aethyric attunement boolean
let testData = {
target: 0,
extra: { // Store data to be used by the test logic
spell: this.prepareSpellOrPrayer(spell),
malignantInfluence: false,
actor : this.data,
ingredient: false,
AA: aethyricAttunement,
size: this.data.data.details.size.value,
options: options
}
};
// Setup dialog data: title, template, buttons, prefilled data
let dialogOptions = {
title: title,
template: "/systems/wfrp4e/templates/dialog/channel-dialog.html",
// Prefilled dialog data
data: {
malignantInfluence: testData.malignantInfluence,
channellSkills: channellSkills,
defaultSelection: defaultSelection,
talents: this.data.flags.talentTests,
advantage: "N/A",
rollMode: options.rollMode
},
callback: (html) => {
// When dialog confirmed, fill testData dialog information
// Note that this does not execute until DiceWFRP.setupDialog() has finished and the user confirms the dialog
cardOptions.rollMode = html.find('[name="rollMode"]').val();
testData.testModifier = Number(html.find('[name="testModifier"]').val());
testData.testDifficulty = game.wfrp4e.config.difficultyModifiers[html.find('[name="testDifficulty"]').val()];
testData.successBonus = Number(html.find('[name="successBonus"]').val());
testData.slBonus = Number(html.find('[name="slBonus"]').val());
testData.extra.malignantInfluence = html.find('[name="malignantInfluence"]').is(':checked');
let skillSelected = channellSkills[Number(html.find('[name="skillSelected"]').val())];
// If an actual Channelling skill was selected, use that skill to calculate the target number
if (skillSelected.key != "wp") {
testData.target = testData.testModifier + testData.testDifficulty
+ this.data.data.characteristics[skillSelected.data.data.characteristic.value].value
+ skillSelected.data.data.advances.value
+ skillSelected.data.data.modifier.value
testData.extra.channellSkill = skillSelected.data
}
else // if the ccharacteristic was selected, use just the characteristic
testData.target = testData.testModifier + testData.testDifficulty + this.data.data.characteristics.wp.value
let talentBonuses = html.find('[name = "talentBonuses"]').val();
// Combine all Talent Bonus values (their times taken) into one sum
testData.successBonus += talentBonuses.reduce(function (prev, cur) {
return prev + Number(cur)
}, 0)
return { testData, cardOptions };
}
};
// Call the universal cardOptions helper
let cardOptions = this._setupCardOptions("systems/wfrp4e/templates/chat/roll/channel-card.html", title)
// Provide these 3 objects to setupDialog() to create the dialog and assign the roll function
return game.wfrp4e.dice.setupDialog({
dialogOptions: dialogOptions,
testData: testData,
cardOptions: cardOptions
});
}
/**
* Setup a Prayer Test.
*
* Prayer tests are fairly simple, with the main complexity coming from sin and wrath of the gods,
* the logic of which can be found in DiceWFRP.rollPrayerTest, where all this data here is passed
* to in order to calculate the roll result.
*
* @param {Object} prayer The prayer Item being used, compared to spells, not much information
* from the prayer itself is needed.
*/
setupPrayer(prayer, options = {}) {
let title = game.i18n.localize("PrayerTest") + " - " + prayer.name;
// ppraySkills array holds the available skills/characteristics to pray with - Prayers: Fellowship
let praySkills = [{ key: "fel", name: game.i18n.localize("CHAR.Fel") }]
// if the actor has the Pray skill, add it to the array.
praySkills = praySkills.concat(this.items.filter(i => i.name.toLowerCase() == game.i18n.localize("NAME.Pray").toLowerCase() && i.type == "skill"));
// Default to Pray skill if available
let defaultSelection = praySkills.findIndex(i => i.name.toLowerCase() == game.i18n.localize("NAME.Pray").toLowerCase())
// Prepare the prayer to have the complete data object, including damage values, range values, etc.
let preparedPrayer = this.prepareSpellOrPrayer(prayer);
let testData = { // Store this data to be used in the test logic
target: 0,
hitLocation: false,
target: defaultSelection != -1 ? this.data.data.characteristics[praySkills[defaultSelection].data.data.characteristic.value].value + praySkills[defaultSelection].data.data.advances.value : this.data.data.characteristics.fel.value,
extra: {
prayer: preparedPrayer,
size: this.data.data.details.size.value,
actor : this.data,
sin: this.data.data.status.sin.value,
options: options,
rollMode: options.rollMode
}
};
// If the spell does damage, default the hit location to checked
if (preparedPrayer.damage)
testData.hitLocation = true;
// Setup dialog data: title, template, buttons, prefilled data
let dialogOptions = {
title: title,
template: "/systems/wfrp4e/templates/dialog/prayer-dialog.html",
// Prefilled dialog data
data: {
hitLocation: testData.hitLocation,
talents: this.data.flags.talentTests,
advantage: this.data.data.status.advantage.value || 0,
praySkills: praySkills,
defaultSelection: defaultSelection
},
callback: (html) => {
// When dialog confirmed, fill testData dialog information
// Note that this does not execute until DiceWFRP.setupDialog() has finished and the user confirms the dialog
cardOptions.rollMode = html.find('[name="rollMode"]').val();
testData.testModifier = Number(html.find('[name="testModifier"]').val());
testData.testDifficulty = game.wfrp4e.config.difficultyModifiers[html.find('[name="testDifficulty"]').val()];
testData.successBonus = Number(html.find('[name="successBonus"]').val());
testData.slBonus = Number(html.find('[name="slBonus"]').val());
let skillSelected = praySkills[Number(html.find('[name="skillSelected"]').val())];
// If an actual skill (Pray) was selected, use that skill to calculate the target number
if (skillSelected.key != "fel") {
testData.target = this.data.data.characteristics[skillSelected.data.data.characteristic.value].value
+ skillSelected.data.data.advances.value
+ testData.testDifficulty
+ testData.testModifier;
+ skillSelected.data.data.modifier.value
}
else // if a characteristic was selected, use just the characteristic
{
testData.target = this.data.data.characteristics.fel.value
+ testData.testDifficulty
+ testData.testModifier;
}
testData.hitLocation = html.find('[name="hitLocation"]').is(':checked');
let talentBonuses = html.find('[name = "talentBonuses"]').val();
// Combine all Talent Bonus values (their times taken) into one sum
testData.successBonus += talentBonuses.reduce(function (prev, cur) {
return prev + Number(cur)
}, 0)
return { testData, cardOptions };
}
};
// Call the universal cardOptions helper
let cardOptions = this._setupCardOptions("systems/wfrp4e/templates/chat/roll/prayer-card.html", title)
// Provide these 3 objects to setupDialog() to create the dialog and assign the roll function
return game.wfrp4e.dice.setupDialog({
dialogOptions: dialogOptions,
testData: testData,
cardOptions: cardOptions
});
}
/**
* Setup a Trait Test.
*
* Some traits are rollable, and so are assigned a rollable characteristic, this is where
* rolling those characteristics is setup. Additonally, sometimes these traits have a
* "Bonus characteristic" which in most all cases means what characteristic bonus to add
* to determine damage. See the logic in traitTest.
*
* @param {Object} trait The trait Item being used, containing which characteristic/bonus characteristic to use
*/
setupTrait(trait, options = {}) {
if (!trait.data.rollable.value)
return;
let title = game.wfrp4e.config.characteristics[trait.data.rollable.rollCharacteristic] + ` ${game.i18n.localize("Test")} - ` + trait.name;
let testData = {
hitLocation: false,
target: this.data.data.characteristics[trait.data.rollable.rollCharacteristic].value,
extra: { // Store this trait data for later use
trait: trait,
size: this.data.data.details.size.value,
actor : this.data,
champion: !!this.items.find(i => i.data.name.toLowerCase() == game.i18n.localize("NAME.Champion").toLowerCase()),
options: options,
rollMode: options.rollMode
}
};
// Default hit location checked if the rollable trait's characteristic is WS or BS
if (trait.data.rollable.rollCharacteristic == "ws" || trait.data.rollable.rollCharacteristic == "bs")
testData.hitLocation = true;
// Setup dialog data: title, template, buttons, prefilled data
let dialogOptions = {
title: title,
template: "/systems/wfrp4e/templates/dialog/skill-dialog.html", // Reuse skill dialog
// Prefilled dialog data
data: {
hitLocation: testData.hitLocation,
talents: this.data.flags.talentTests,
characteristicList: game.wfrp4e.config.characteristics,
characteristicToUse: trait.data.rollable.rollCharacteristic,
advantage: this.data.data.status.advantage.value || 0,
testDifficulty: trait.data.rollable.defaultDifficulty
},
callback: (html) => {
// When dialog confirmed, fill testData dialog information
// Note that this does not execute until DiceWFRP.setupDialog() has finished and the user confirms the dialog
cardOptions.rollMode = html.find('[name="rollMode"]').val();
testData.testModifier = Number(html.find('[name="testModifier"]').val());
testData.testDifficulty = game.wfrp4e.config.difficultyModifiers[html.find('[name="testDifficulty"]').val()];
testData.successBonus = Number(html.find('[name="successBonus"]').val());
testData.slBonus = Number(html.find('[name="slBonus"]').val());
let characteristicToUse = html.find('[name="characteristicToUse"]').val();
// Target value is the final value being tested against, after all modifiers and bonuses are added
testData.target = this.data.data.characteristics[characteristicToUse].value
+ testData.testModifier
+ testData.testDifficulty
testData.hitLocation = html.find('[name="hitLocation"]').is(':checked');
let talentBonuses = html.find('[name = "talentBonuses"]').val();
// Combine all Talent Bonus values (their times taken) into one sum
testData.successBonus += talentBonuses.reduce(function (prev, cur) {
return prev + Number(cur)
}, 0)
return { testData, cardOptions };
}
};
// Call the universal cardOptions helper
let cardOptions = this._setupCardOptions("systems/wfrp4e/templates/chat/roll/skill-card.html", title)
// Provide these 3 objects to setupDialog() to create the dialog and assign the roll function
return game.wfrp4e.dice.setupDialog({
dialogOptions: dialogOptions,
testData: testData,
cardOptions: cardOptions
});
}
/**
* Universal card options for setup functions.
*
* The setup_____() functions all use the same cardOptions, just different templates. So this is
* a standardized helper function to maintain DRY code.
*
* @param {string} template Fileptah to the template being used
* @param {string} title Title of the Test to be displayed on the dialog and card
*/
_setupCardOptions(template, title) {
let cardOptions = {
speaker: {
alias: this.data.token.name,
actor: this.data._id,
},
title: title,
template: template,
flags: { img: this.data.token.randomImg ? this.data.img : this.data.token.img }
// img to be displayed next to the name on the test card - if it's a wildcard img, use the actor image
}
// If the test is coming from a token sheet
if (this.token) {
cardOptions.speaker.alias = this.token.data.name; // Use the token name instead of the actor name
cardOptions.speaker.token = this.token.data._id;
cardOptions.speaker.scene = canvas.scene._id
cardOptions.flags.img = this.token.data.img; // Use the token image instead of the actor image
}
else // If a linked actor - use the currently selected token's data if the actor id matches
{
let speaker = ChatMessage.getSpeaker()
if (speaker.actor == this.data._id) {
cardOptions.speaker.alias = speaker.alias
cardOptions.speaker.token = speaker.token
cardOptions.speaker.scene = speaker.scene
cardOptions.flags.img = speaker.token ? canvas.tokens.get(speaker.token).data.img : cardOptions.flags.img
}
}
return cardOptions
}
/* --------------------------------------------------------------------------------------------------------- */
/* --------------------------------------------- Roll Overides --------------------------------------------- */
/* --------------------------------------------------------------------------------------------------------- */
/**
* Roll overrides are specialized functions for different types of rolls. In each override, DiceWFRP is called
* to perform the test logic, which has its own specialized functions for different types of tests. For exapmle,
* weaponTest() calls DiceWFRP.rollWeaponTest(). Additionally, any post-roll logic that needs to be performed
* is done here. For example, Income tests use incomeTest, which determines how much money is made after the
* roll is completed. A normal Skill Test does not go through this process, instead using basicTest override,
* however both overrides just use the standard DiceWFRP.rollTest().
*
/* --------------------------------------------------------------------------------------------------------- */
/**
* Default Roll override, the standard rolling method for general tests.
*
* basicTest is the default roll override (see DiceWFRP.setupDialog() for where it's assigned). This follows
* the basic steps. Call DiceWFRP.rollTest for standard test logic, send the result and display data to
* if(!options.suppressMessage)
DiceWFRP.renderRollCard() as well as handleOpposedTarget().
*
* @param {Object} testData All the data needed to evaluate test results - see setupSkill/Characteristic
* @param {Object} cardOptions Data for the card display, title, template, etc.
* @param {Object} rerenderMessage The message to be updated (used if editing the chat card)
*/
async basicTest({ testData, cardOptions }, options = {}) {
testData = await game.wfrp4e.dice.rollDices(testData, cardOptions);
let result = game.wfrp4e.dice.rollTest(testData);
result.postFunction = "basicTest";
if (testData.extra)
mergeObject(result, testData.extra);
if (result.options.corruption) {
this.handleCorruptionResult(result);
}
if (result.options.mutate) {
this.handleMutationResult(result)
}
if (result.options.extended)
{
this.handleExtendedTest(result)
}
try {
let contextAudio = await game.wfrp4e.audio.MatchContextAudio(game.wfrp4e.audio.FindContext(result))
cardOptions.sound = contextAudio.file || cardOptions.sound
}
catch
{ }
Hooks.call("wfrp4e:rollTest", result, cardOptions)
if (game.user.targets.size) {
cardOptions.title += ` - ${game.i18n.localize("Opposed")}`;
cardOptions.isOpposedTest = true
}
if (!options.suppressMessage)
if (!options.suppressMessage)
game.wfrp4e.dice.renderRollCard(cardOptions, result, options.rerenderMessage).then(msg => {
game.wfrp4e.opposed.handleOpposedTarget(msg) // Send to handleOpposed to determine opposed status, if any.
})
return {result, cardOptions};
}
/**
* incomeTest is used to add income calculation to Skill tests.
*
* Normal skill Tests just use basicTest() override, however, when testing Income, this override is used instead
* because it adds 'post processing' in the form of determining how much money was earned. See this.setupSkill()
* for how this override is assigned.
*
* @param {Object} testData All the data needed to evaluate test results - see setupSkill()
* @param {Object} cardOptions Data for the card display, title, template, etc.
* @param {Object} rerenderMessage The message to be updated (used if editing the chat card)
*/
async incomeTest({ testData, cardOptions }, options = {}) {
testData = await game.wfrp4e.dice.rollDices(testData, cardOptions);
let result = game.wfrp4e.dice.rollTest(testData);
result.postFunction = "incomeTest"
Hooks.call("wfrp4e:rollIncomeTest", result, cardOptions)
if (game.user.targets.size) {
cardOptions.title += ` - ${game.i18n.localize("Opposed")}`,
cardOptions.isOpposedTest = true
}
let status = testData.income.value.split(' ')
let dieAmount = game.wfrp4e.config.earningValues[game.wfrp4e.utility.findKey(status[0], game.wfrp4e.config.statusTiers)][0] // b, s, or g maps to 2d10, 1d10, or 1 respectively (takes the first letter)
dieAmount = Number(dieAmount) * status[1]; // Multilpy that first letter by your standing (Brass 4 = 8d10 pennies)
let moneyEarned;
if (game.wfrp4e.utility.findKey(status[0], game.wfrp4e.config.statusTiers) != "g") // Don't roll for gold, just use standing value
{
dieAmount = dieAmount + "d10";
moneyEarned = new Roll(dieAmount).roll().total;
}
else
moneyEarned = dieAmount;
// After rolling, determined how much, if any, was actually earned
if (result.description.includes("Success")) {
result.incomeResult = game.i18n.localize("INCOME.YouEarn") + " " + moneyEarned;
switch (game.wfrp4e.utility.findKey(status[0], game.wfrp4e.config.statusTiers)) {
case "b":
result.incomeResult += ` ${game.i18n.localize("NAME.BPPlural").toLowerCase()}.`
break;
case "s":
result.incomeResult += ` ${game.i18n.localize("NAME.SSPlural").toLowerCase()}.`
break;
case "g":
if (moneyEarned > 1)
result.incomeResult += ` ${game.i18n.localize("NAME.GC").toLowerCase()}.`
else
result.incomeResult += ` ${game.i18n.localize("NAME.GCPlural").toLowerCase()}.`
break;
}
}
else if (Number(result.SL) > -6) {
moneyEarned /= 2;
result.incomeResult = game.i18n.localize("INCOME.YouEarn") + " " + moneyEarned;
switch (game.wfrp4e.utility.findKey(status[0], game.wfrp4e.config.statusTiers)) {
case "b":
result.incomeResult += ` ${game.i18n.localize("NAME.BPPlural").toLowerCase()}.`
break;
case "s":
result.incomeResult += ` ${game.i18n.localize("NAME.SSPlural").toLowerCase()}.`
break;
case "g":
if (moneyEarned > 1)
result.incomeResult += ` ${game.i18n.localize("NAME.GC").toLowerCase()}.`
else
result.incomeResult += ` ${game.i18n.localize("NAME.GCPlural").toLowerCase()}.`
break;
}
}
else {
result.incomeResult = game.i18n.localize("INCOME.Failure")
moneyEarned = 0;
}
// let contextAudio = await WFRP_Audio.MatchContextAudio(WFRP_Audio.FindContext(result))
// cardOptions.sound = contextAudio.file || cardOptions.sound
result.moneyEarned = moneyEarned + game.wfrp4e.utility.findKey(status[0], game.wfrp4e.config.statusTiers);
if (!options.suppressMessage)
game.wfrp4e.dice.renderRollCard(cardOptions, result, options.rerenderMessage).then(msg => {
game.wfrp4e.opposed.handleOpposedTarget(msg)
})
return {result, cardOptions};
}
/**
* weaponTest is used for weapon tests, see setupWeapon for how it's assigned.
*
* weaponTest doesn't add any special functionality, it's main purpose being to call
* DiceWFRP.rollWeaponTest() instead of the generic DiceWFRP.rollTest()
*
* @param {Object} testData All the data needed to evaluate test results - see setupWeapon()
* @param {Object} cardOptions Data for the card display, title, template, etc.
* @param {Object} rerenderMessage The message to be updated (used if editing the chat card)
*/
async weaponTest({ testData, cardOptions }, options = {}) {
if (game.user.targets.size) {
cardOptions.title += ` - ${game.i18n.localize("Opposed")}`,
cardOptions.isOpposedTest = true
}
testData = await game.wfrp4e.dice.rollDices(testData, cardOptions);
let result = game.wfrp4e.dice.rollWeaponTest(testData);
result.postFunction = "weaponTest";
// Reduce ammo if necessary
if (result.ammo && result.weapon.data.weaponGroup.value != game.i18n.localize("SPEC.Entangling").toLowerCase()) {
result.ammo.data.quantity.value--;
this.updateEmbeddedEntity("OwnedItem", { _id: result.ammo._id, "data.quantity.value": result.ammo.data.quantity.value });
}
try {
let contextAudio = await game.wfrp4e.audio.MatchContextAudio(game.wfrp4e.audio.FindContext(result))
cardOptions.sound = contextAudio.file || cardOptions.sound
}
catch
{ }
Hooks.call("wfrp4e:rollWeaponTest", result, cardOptions)
if (!options.suppressMessage)
game.wfrp4e.dice.renderRollCard(cardOptions, result, options.rerenderMessage).then(msg => {
game.wfrp4e.opposed.handleOpposedTarget(msg) // Send to handleOpposed to determine opposed status, if any.
})
return {result, cardOptions};
}
/**
* castTest is used for casting tests, see setupCast for how it's assigned.
*
* The only special functionality castTest adds is reseting spell SL channelled back to 0, other than that,
* it's main purpose is to call DiceWFRP.rollCastTest() instead of the generic DiceWFRP.rollTest().
*
* @param {Object} testData All the data needed to evaluate test results - see setupCast()
* @param {Object} cardOptions Data for the card display, title, template, etc.
* @param {Object} rerenderMessage The message to be updated (used if editing the chat card)
*/
async castTest({ testData, cardOptions }, options = {}) {
if (game.user.targets.size) {
cardOptions.title += ` - ${game.i18n.localize("Opposed")}`,
cardOptions.isOpposedTest = true
}
testData = await game.wfrp4e.dice.rollDices(testData, cardOptions);
let result = game.wfrp4e.dice.rollCastTest(testData);
result.postFunction = "castTest";
// Find ingredient being used, if any
let ing = duplicate(this.getEmbeddedEntity("OwnedItem", testData.extra.spell.data.currentIng.value))
if (ing) {
// Decrease ingredient quantity
testData.extra.ingredient = true;
ing.data.quantity.value--;
this.updateEmbeddedEntity("OwnedItem", ing);
}
// If quantity of ingredient is 0, disregard the ingredient
else if (!ing || ing.data.data.quantity.value <= 0)
testData.extra.ingredient = false;
try {
let contextAudio = await game.wfrp4e.audio.MatchContextAudio(game.wfrp4e.audio.FindContext(result))
cardOptions.sound = contextAudio.file || cardOptions.sound
}
catch
{ }
Hooks.call("wfrp4e:rollCastTest", result, cardOptions)
// Update spell to reflect SL from channelling resetting to 0
game.wfrp4e.utility.getSpeaker(cardOptions.speaker).updateEmbeddedEntity("OwnedItem", { _id: testData.extra.spell._id, 'data.cn.SL': 0 });
if (!options.suppressMessage)
game.wfrp4e.dice.renderRollCard(cardOptions, result, options.rerenderMessage).then(msg => {
game.wfrp4e.opposed.handleOpposedTarget(msg) // Send to handleOpposed to determine opposed status, if any.
})
return {result, cardOptions};
}
/**
* channelTest is used for casting tests, see setupCast for how it's assigned.
*
* channellOveride doesn't add any special functionality, it's main purpose being to call
* DiceWFRP.rollChannellTest() instead of the generic DiceWFRP.rollTest()
*
* @param {Object} testData All the data needed to evaluate test results - see setupChannell()
* @param {Object} cardOptions Data for the card display, title, template, etc.
* @param {Object} rerenderMessage The message to be updated (used if editing the chat card)
*/
async channelTest({ testData, cardOptions }, options = {}) {
if (game.user.targets.size) {
cardOptions.title += ` - ${game.i18n.localize("Opposed")}`,
cardOptions.isOpposedTest = true
}
testData = await game.wfrp4e.dice.rollDices(testData, cardOptions);
let result = game.wfrp4e.dice.rollChannellTest(testData, game.wfrp4e.utility.getSpeaker(cardOptions.speaker));
result.postFunction = "channelTest";
// Find ingredient being used, if any
let ing = duplicate(this.getEmbeddedEntity("OwnedItem", testData.extra.spell.data.currentIng.value))
if (ing) {
// Decrease ingredient quantity
testData.extra.ingredient = true;
ing.data.quantity.value--;
this.updateEmbeddedEntity("OwnedItem", ing);
}
// If quantity of ingredient is 0, disregard the ingredient
else if (!ing || ing.data.data.quantity.value <= 0)
testData.extra.ingredient = false;
try {
let contextAudio = await game.wfrp4e.audio.MatchContextAudio(game.wfrp4e.audio.FindContext(result))
cardOptions.sound = contextAudio.file || cardOptions.sound
}
catch
{ }
Hooks.call("wfrp4e:rollChannelTest", result, cardOptions)
if (!options.suppressMessage)
DiceWFRP.renderRollCard(cardOptions, result, options.rerenderMessage).then(msg => {
game.wfrp4e.opposed.handleOpposedTarget(msg) // Send to handleOpposed to determine opposed status, if any.
})
return {result, cardOptions};
}
/**
* prayerTest is used for casting tests, see setupCast for how it's assigned.
*
* prayerTest doesn't add any special functionality, it's main purpose being to call
* DiceWFRP.rollPrayerTest() instead of the generic DiceWFRP.rollTest()
*
* @param {Object} testData All the data needed to evaluate test results - see setupPrayer()
* @param {Object} cardOptions Data for the card display, title, template, etc.
* @param {Object} rerenderMessage The message to be updated (used if editing the chat card)
*/
async prayerTest({ testData, cardOptions }, options = {}) {
if (game.user.targets.size) {
cardOptions.title += ` - ${game.i18n.localize("Opposed")}`,
cardOptions.isOpposedTest = true
}
testData = await game.wfrp4e.dice.rollDices(testData, cardOptions);
let result = game.wfrp4e.dice.rollPrayTest(testData, game.wfrp4e.utility.getSpeaker(cardOptions.speaker));
result.postFunction = "prayerTest";
try {
let contextAudio = await game.wfrp4e.audio.MatchContextAudio(game.wfrp4e.audio.FindContext(result))
cardOptions.sound = contextAudio.file || cardOptions.sound
}
catch
{ }
Hooks.call("wfrp4e:rollPrayerTest", result, cardOptions)
if (!options.suppressMessage)
game.wfrp4e.dice.renderRollCard(cardOptions, result, options.rerenderMessage).then(msg => {
game.wfrp4e.opposed.handleOpposedTarget(msg) // Send to handleOpposed to determine opposed status, if any.
})
return {result, cardOptions};
}
/**
* traitTest is used for Trait tests, see setupTrait for how it's assigned.
*
* Since traitTest calls the generic DiceWFRP.rollTest(), which does not consider damage,
* some post processing must be done to calculate damage values.
*
* @param {Object} testData All the data needed to evaluate test results - see setupTrait()
* @param {Object} cardOptions Data for the card display, title, template, etc.
* @param {Object} rerenderMessage The message to be updated (used if editing the chat card)
*/
async traitTest({ testData, cardOptions }, options = {}) {
if (game.user.targets.size) {
cardOptions.title += ` - ${game.i18n.localize("Opposed")}`,
cardOptions.isOpposedTest = true
}
testData = await game.wfrp4e.dice.rollDices(testData, cardOptions);
let result = game.wfrp4e.dice.rollTest(testData);
result.postFunction = "traitTest";
try {
// If the specification of a trait is a number, it's probably damage. (Animosity (Elves) - not a number specification: no damage)
if (!isNaN(testData.extra.trait.data.specification.value) || testData.extra.trait.data.rollable.rollCharacteristic == "ws" || testData.extra.trait.data.rollabble.rollCharacteristic == "bs") // (Bite 7 - is a number specification, do damage)
{
testData.extra.damage = Number(result.SL) // Start damage off with SL
testData.extra.damage += Number(testData.extra.trait.data.specification.value) || 0
if (testData.extra.trait.data.rollable.bonusCharacteristic) // Add the bonus characteristic (probably strength)
testData.extra.damage += Number(this.data.data.characteristics[testData.extra.trait.data.rollable.bonusCharacteristic].bonus) || 0;
}
}
catch (error) {
ui.notifications.error(game.i18n.localize("CHAT.DamageError") + " " + error)
} // If something went wrong calculating damage, do nothing and still render the card
if (testData.extra)
mergeObject(result, testData.extra);
try {
let contextAudio = await game.wfrp4e.audio.MatchContextAudio(game.wfrp4e.audio.FindContext(result))
cardOptions.sound = contextAudio.file || cardOptions.sound
}
catch
{ }
Hooks.call("wfrp4e:rollTraitTest", result, cardOptions)
if (!options.suppressMessage)
game.wfrp4e.dice.renderRollCard(cardOptions, result, options.rerenderMessage).then(msg => {
game.wfrp4e.opposed.handleOpposedTarget(msg) // Send to handleOpposed to determine opposed status, if any.
})
return {result, cardOptions};
}
/* --------------------------------------------------------------------------------------------------------- */
/* --------------------------------- Preparation & Calculation Functions ----------------------------------- */
/* --------------------------------------------------------------------------------------------------------- */
/**
* Preparation function takes raw item data and processes it with actor data, typically using the calculate
* functions to do so. For example, A weapon passed into prepareWeaponCombat will turn the weapon's damage
* from "SB + 4" to the actual damage value by using the actor's strength bonus. See the specific functions
* below for more details on what exactly is processed. These functions are used when rolling a test
* (determining a weapon's base damage) or setting up the actor sheet to be displayed (displaying the damage
* in the combat tab).
*
/* --------------------------------------------------------------------------------------------------------- */
/**
* Prepares actor data for display and other features.
*
* prepare() is the principal function behind taking every aspect of an actor and processing them
* for display (getData() - see ActorSheetWfrp4e) and other needs. This is where all items (call to
* prepareItems()) are prepared and organized, then used to calculate different Actor features,
* such as the Size trait influencing wounds and token size, or how talents might affect damage.
* In many areas here, these talents/traits that affect some calculation are updated only if a
* difference is detected to avoid infinite loops, I would like an alternative but I'm not sure
* where to go instead.
*
* NOTE: THIS FUNCTION IS NOT TO BE CONFUSED WITH prepareData(). That function is called upon updating
* an actor. This function is called whenever the sheet is rendered.
*/
prepare() {
let preparedData = duplicate(this.data)
// Call prepareItems first to organize and process OwnedItems
mergeObject(preparedData, this.prepareItems())
// Add speciality functions for each Actor type
if (preparedData.type == "character")
this.prepareCharacter(preparedData)
if (preparedData.type == "npc")
this.prepareNPC(preparedData)
if (preparedData.type == "creature")
this.prepareCreature(preparedData)
return preparedData;
}
/**
* Iterates through the Owned Items, processes them and organizes them into containers.
*
* This behemoth of a function goes through all Owned Items, separating them into individual arrays
* that the html templates use. Before adding them into the array, they are typically processed with
* the actor data, which can either be a large function itself (see prepareWeaponCombat) or not, such
* as career items which have minimal processing. These items, as well as some auxiliary data (e.g.
* encumbrance, AP) are bundled into an return object
*
*/
prepareItems() {
let actorData = duplicate(this.data)
// These containers are for the various different tabs
const careers = [];
const basicSkills = [];
const advancedOrGroupedSkills = [];
const talents = [];
const traits = [];
const weapons = [];
const armour = [];
const injuries = [];
const grimoire = [];
const petty = [];
const blessings = [];
const miracles = [];
const psychology = [];
const mutations = [];
const diseases = [];
const criticals = [];
const extendedTests = [];
let penalties = {
[game.i18n.localize("Armour")]: {
value: ""
},
[game.i18n.localize("Injury")]: {
value: ""
},
[game.i18n.localize("Mutation")]: {
value: ""
},
[game.i18n.localize("Criticals")]: {
value: ""
},
};
const AP = {
head: {
value: 0,
layers: [],
label : game.i18n.localize("Head"),
show: true,
},
body: {
value: 0,
layers: [],
label : game.i18n.localize("Body"),
show: true
},
rArm: {
value: 0,
layers: [],
label : game.i18n.localize("Left Arm"),
show: true
},
lArm: {
value: 0,
layers: [],
label : game.i18n.localize("Right Arm"),
show: true
},
rLeg: {
value: 0,
layers: [],
label : game.i18n.localize("Right Leg"),
show: true
},
lLeg: {
value: 0,
layers: [],
label : game.i18n.localize("Left Leg"),
show: true
},
shield: 0
}
for(let loc in AP)
{
if (loc == "shield")
continue
let row = game.wfrp4e.tables[actorData.data.details.hitLocationTable.value].rows.find(r => r.result == loc)
if (row)
AP[loc].label = game.i18n.localize(row.description)
else
AP[loc].show = false;
}
// Inventory object is for the Trappings tab - each sub object is for an individual inventory section
const inventory = {
weapons: {
label: game.i18n.localize("WFRP4E.TrappingType.Weapon"), // Label - what is displayed in the inventory section header
items: [], // Array of items in the section
toggle: true, // Is there a toggle in the section? (Equipped, worn, etc.)
toggleName: game.i18n.localize("Equipped"), // What is the name of the toggle in the header
show: false, // Should this section be shown (if an item exists in this list, it is set to true)
dataType: "weapon" // What type of FVTT Item is in this section (used by the + button to add an item of this type)
},
armor: {
label: game.i18n.localize("WFRP4E.TrappingType.Armour"),
items: [],
toggle: true,
toggleName: game.i18n.localize("Worn"),
show: false,
dataType: "armour"
},
ammunition: {
label: game.i18n.localize("WFRP4E.TrappingType.Ammunition"),
items: [],
show: false,
dataType: "ammunition"
},
clothingAccessories: {
label: game.i18n.localize("WFRP4E.TrappingType.ClothingAccessories"),
items: [],
toggle: true,
toggleName: game.i18n.localize("Worn"),
show: false,
dataType: "trapping"
},
booksAndDocuments: {
label: game.i18n.localize("WFRP4E.TrappingType.BooksDocuments"),
items: [],
show: false,
dataType: "trapping"
},
toolsAndKits: {
label: game.i18n.localize("WFRP4E.TrappingType.ToolsKits"),
items: [],
show: false,
dataType: "trapping"
},
foodAndDrink: {
label: game.i18n.localize("WFRP4E.TrappingType.FoodDrink"),
items: [],
show: false,
dataType: "trapping"
},
drugsPoisonsHerbsDraughts: {
label: game.i18n.localize("WFRP4E.TrappingType.DrugsPoisonsHerbsDraughts"),
items: [],
show: false,
dataType: "trapping"
},
misc: {
label: game.i18n.localize("WFRP4E.TrappingType.Misc"),
items: [],
show: true,
dataType: "trapping"
}
};
// Money and ingredients are not in inventory object because they need more customization - note in actor-inventory.html that they do not exist in the main inventory loop
const ingredients = {
label: game.i18n.localize("WFRP4E.TrappingType.Ingredient"),
items: [],
show: false,
dataType: "trapping"
};
const money = {
coins: [],
total: 0, // Total coinage value
show: true
};
const containers = {
items: [],
show: false
};
const inContainers = []; // inContainers is the temporary storage for items within a container
let totalEnc = 0; // Total encumbrance of items
let hasSpells = false; // if the actor has atleast a single spell - used to display magic tab
let hasPrayers = false; // if the actor has atleast a single prayer - used to display religion tab
let showOffhand = true; // Show offhand checkboxes if no offhand equipped
let defensiveCounter = 0; // Counter for weapons with the defensive quality
actorData.items = actorData.items.sort((a, b) => (a.sort || 0) - (b.sort || 0))
// Iterate through items, allocating to containers
// Items that need more intense processing are sent to a specialized function (see preparation functions below)
// Physical items are also placed into containers instead of the inventory object if their 'location' is not 0
// A location of 0 means not in a container, otherwise, the location corresponds to the id of the container the item is in
for (let i of actorData.items) {
try {
i.img = i.img || DEFAULT_TOKEN;
// *********** TALENTS ***********
if (i.type === "talent") {
this.prepareTalent(i, talents);
}
// *********** Skills ***********
else if (i.type === "skill") {
this.prepareSkill(i);
if (i.data.grouped.value == "isSpec" || i.data.advanced.value == "adv")
advancedOrGroupedSkills.push(i)
else
basicSkills.push(i);
}
// *********** Ammunition ***********
else if (i.type === "ammunition") {
i.encumbrance = (i.data.encumbrance.value * i.data.quantity.value).toFixed(2);
if (i.data.location.value == 0) {
inventory.ammunition.items.push(i);
inventory.ammunition.show = true
totalEnc += Number(i.encumbrance);
}
else {
inContainers.push(i);
}
}
// *********** Weapons ***********
// Weapons are "processed" at the end for efficency
else if (i.type === "weapon") {
i.encumbrance = Math.floor(i.data.encumbrance.value * i.data.quantity.value);
if (i.data.location.value == 0) {
i.toggleValue = i.data.equipped || false;
inventory.weapons.items.push(i);
inventory.weapons.show = true;
totalEnc += i.encumbrance;
}
else {
inContainers.push(i);
}
}
// *********** Armour ***********
// Armour is prepared only if it is worn, otherwise, it is just pushed to inventory and encumbrance is calculated
else if (i.type === "armour") {
i.encumbrance = Math.floor(i.data.encumbrance.value * i.data.quantity.value);
if (i.data.location.value == 0) {
i.toggleValue = i.data.worn.value || false;
if (i.data.worn.value) {
i.encumbrance = i.encumbrance - 1;
i.encumbrance = i.encumbrance < 0 ? 0 : i.encumbrance;
}
inventory.armor.items.push(i);
inventory.armor.show = true;
totalEnc += i.encumbrance;
}
else {
inContainers.push(i);
}
if (i.data.worn.value)
armour.push(this.prepareArmorCombat(i, AP));
}
// *********** Injuries ***********
else if (i.type == "injury") {
injuries.push(i);
penalties[game.i18n.localize("Injury")].value += i.data.penalty.value;
}
// *********** Criticals ***********
else if (i.type == "critical") {
criticals.push(i);
penalties[game.i18n.localize("Criticals")].value += i.data.modifier.value;
}
// *********** Containers ***********
// Items within containers are organized at the end
else if (i.type === "container") {
i.encumbrance = i.data.encumbrance.value;
if (i.data.location.value == 0) {
if (i.data.worn.value) {
i.encumbrance = i.encumbrance - 1;
i.encumbrance = i.encumbrance < 0 ? 0 : i.encumbrance;
}
totalEnc += i.encumbrance;
}
else {
inContainers.push(i);
}
containers.items.push(i);
containers.show = true;
}
// *********** Trappings ***********
// Trappings have several sub-categories, most notably Ingredients
// The trappings tab does not have a "Trappings" section, but sections for each type of trapping instead
else if (i.type === "trapping") {
i.encumbrance = i.data.encumbrance.value * i.data.quantity.value;
if (i.data.location.value == 0) {
// Push ingredients to a speciality array for futher customization in the trappings tab
if (i.data.trappingType.value == "ingredient") {
ingredients.items.push(i)
}
// The trapping will fall into one of these if statements and set the array accordingly
else if (i.data.trappingType.value == "clothingAccessories") {
i.toggleValue = i.data.worn || false;
inventory[i.data.trappingType.value].items.push(i);
inventory[i.data.trappingType.value].show = true;
if (i.data.worn) {
i.encumbrance = i.encumbrance - 1; // Since some trappings are worn, they need special treatment
i.encumbrance = i.encumbrance < 0 ? 0 : i.encumbrance; // This if statement is specific to worn clothing Trappings
}
}
else if (i.data.trappingType.value == "tradeTools") {
inventory["toolsAndKits"].items.push(i) // I decided not to separate "Trade Tools" and "Tools and Kits"
inventory["toolsAndKits"].show = true; // Instead, merging them both into "Tools and Kits"
}
else if (i.data.trappingType.value) {
inventory[i.data.trappingType.value].items.push(i); // Generic - add anything else to their appropriate array
inventory[i.data.trappingType.value].show = true;
}
else {
inventory.misc.items.push(i); // If somehow it didn't fall into the other categories (it should)
inventory.misc.show = true; // Just push it to miscellaneous
}
totalEnc += i.encumbrance;
}
else {
inContainers.push(i);
}
}
// *********** Spells ***********
// See this.prepareSpellOrPrayer() for how these items are processed
else if (i.type === "spell") {
hasSpells = true;
if (i.data.lore.value == "petty")
petty.push(this.prepareSpellOrPrayer(i));
else
grimoire.push(this.prepareSpellOrPrayer(i));
}
// *********** Prayers ***********
// See this.prepareSpellOrPrayer() for how these items are processed
else if (i.type === "prayer") {
hasPrayers = true;
if (i.data.type.value == "blessing")
blessings.push(this.prepareSpellOrPrayer(i));
else
miracles.push(this.prepareSpellOrPrayer(i));
}
// *********** Careers ***********
else if (i.type === "career") {
careers.push(i);
}
// *********** Trait ***********
// Display Traits as Trait-Name (Specification)
// Such as Animosity (Elves)
else if (i.type === "trait") {
if (i.data.specification.value) {
if (i.data.rollable.bonusCharacteristic) // Bonus characteristic adds to the specification (Weapon +X includes SB for example)
{
i.data.specification.value = parseInt(i.data.specification.value) || 0
i.data.specification.value += actorData.data.characteristics[i.data.rollable.bonusCharacteristic].bonus;
}
i.name = i.name + " (" + i.data.specification.value + ")";
}
traits.push(i);
}
// *********** Psychologies ***********
else if (i.type === "psychology") {
psychology.push(i);
}
// *********** Diseases ***********
// .roll is the roll result. If it doesn't exist, show the formula instead
else if (i.type === "disease") {
i.data.incubation.roll = i.data.incubation.roll || i.data.incubation.value;
i.data.duration.roll = i.data.duration.roll || i.data.duration.value;
diseases.push(i);
}
// *********** Mutations ***********
// Some mutations have modifiers - see the penalties section below
else if (i.type === "mutation") {
mutations.push(i);
if (i.data.modifiesSkills.value)
penalties[game.i18n.localize("Mutation")].value += i.data.modifier.value;
}
// *********** Money ***********
// Keep a running total of the coin value the actor has outside of containers
else if (i.type === "money") {
i.encumbrance = (i.data.encumbrance.value * i.data.quantity.value).toFixed(2);
if (i.data.location.value == 0) {
money.coins.push(i);
totalEnc += Number(i.encumbrance);
}
else {
inContainers.push(i);
}
money.total += i.data.quantity.value * i.data.coinValue.value;
}
else if (i.type === "extendedTest") {
i.pct = 0;
if (i.data.SL.target > 0)
i.pct = i.data.SL.current / i.data.SL.target * 100
if (i.pct > 100)
i.pct = 100
if (i.pct < 0)
i.pct = 0;
extendedTests.push(i);
}
}
catch (error) {
console.error("Something went wrong with preparing item " + i.name + ": " + error)
ui.notifications.error("Something went wrong with preparing item " + i.name + ": " + error)
// ui.notifications.error("Deleting " + i.name);
// this.deleteEmbeddedEntity("OwnedItem", i._id);
}
} // END ITEM SORTING
// Prepare weapons for combat after items passthrough for efficiency - weapons need to know the ammo possessed, so instead of iterating through
// all items to find, iterate through the inventory.ammo array we just made
let totalShieldDamage = 0; // Used for damage tooltip
let eqpPoints = 0 // Weapon equipment value, only 2 one handed weapons or 1 two handed weapon
for (let wep of inventory.weapons.items) {
// We're only preparing equipped items here - this is for displaying weapons in the combat tab after all
if (wep.data.equipped) {
if (getProperty(wep, "data.offhand.value"))
showOffhand = false; // Don't show offhand checkboxes if a weapon is offhanded
// Process weapon taking into account actor data, skills, and ammo
weapons.push(this.prepareWeaponCombat(wep, inventory.ammo, basicSkills.concat(advancedOrGroupedSkills)));
// Add shield AP to AP object
let shieldProperty = wep.properties.qualities.find(q => q.toLowerCase().includes(game.i18n.localize("PROPERTY.Shield").toLowerCase()))
if (shieldProperty) {
let shieldDamage = wep.data.APdamage || 0;
AP.shield += (parseInt(shieldProperty.split(" ")[1]) - shieldDamage);
totalShieldDamage += shieldDamage;
}
// Keep a running total of defensive weapons equipped
if (wep.properties.qualities.find(q => q.toLowerCase().includes(game.i18n.localize("PROPERTY.Defensive").toLowerCase()))) {
defensiveCounter++;
}
eqpPoints += wep.data.twohanded.value ? 2 : 1
}
}
this.data.flags.eqpPoints = eqpPoints
// If you have no spells, just put all ingredients in the miscellaneous section, otherwise, setup the ingredients to be available
if (grimoire.length > 0 && ingredients.items.length > 0) {
ingredients.show = true;
// For each spell, set available ingredients to ingredients that have been assigned to that spell
for (let s of grimoire)
s.data.ingredients = ingredients.items.filter(i => i.data.spellIngredient.value == s._id && i.data.quantity.value > 0)
}
else
inventory.misc.items = inventory.misc.items.concat(ingredients.items);
// ******************************** Container Setup ***********************************
// containerMissing is an array of items whose container does not exist (needed for when a container is deleted)
var containerMissing = inContainers.filter(i => !containers.items.find(c => c._id == i.data.location.value));
for (var itemNoContainer of containerMissing) // Reset all items without container references (items that were removed from a contanier)
itemNoContainer.data.location.value = 0;
// If there were missing containers, reset the items that are orphaned
if (containerMissing.length)
this.updateEmbeddedEntity("OwnedItem", containerMissing)
for (var cont of containers.items) // For each container
{
// All items referencing (inside) that container
var itemsInside = inContainers.filter(i => i.data.location.value == cont._id);
itemsInside.map(function (item) { // Add category of item to be displayed
if (item.type == "trapping")
item.type = game.wfrp4e.config.trappingCategories[item.data.trappingType.value];
else
item.type = game.wfrp4e.config.trappingCategories[item.type];
})
cont["carrying"] = itemsInside.filter(i => i.type != "Container"); // cont.carrying -> items the container is carrying
cont["packsInside"] = itemsInside.filter(i => i.type == "Container"); // cont.packsInside -> containers the container is carrying
cont["holding"] = itemsInside.reduce(function (prev, cur) { // cont.holding -> total encumbrance the container is holding
return Number(prev) + Number(cur.encumbrance);
}, 0);
cont.holding = Math.floor(cont.holding)
}
containers.items = containers.items.filter(c => c.data.location.value == 0); // Do not show containers inside other containers as top level (a location value of 0 means not inside a container)
// ******************************** Penalties Setup ***********************************
// Penalties box setup
// If too much text, divide the penalties into groups
let penaltyOverflow = false;
penalties[game.i18n.localize("Armour")].value += this.calculateArmorPenalties(armour);
if ((penalties[game.i18n.localize("Armour")].value + penalties[game.i18n.localize("Mutation")].value + penalties[game.i18n.localize("Injury")].value + penalties[game.i18n.localize("Criticals")].value).length > 50) // ~50 characters is when the text box overflows
{ // When that happens, break it up into categories
penaltyOverflow = true;
for (let penaltyType in penalties) {
if (penalties[penaltyType].value)
penalties[penaltyType].show = true;
else
penalties[penaltyType].show = false; // Don't show categories without any penalties
}
}
// Penalties flag is teh string that shows when the actor's turn in combat starts
let penaltiesFlag = penalties[game.i18n.localize("Armour")].value + " " + penalties[game.i18n.localize("Mutation")].value + " " + penalties[game.i18n.localize("Injury")].value + " " + penalties[game.i18n.localize("Criticals")].value + " " + this.data.data.status.penalties.value
penaltiesFlag = penaltiesFlag.trim();
// This is for the penalty string in flags, for combat turn message
if (this.data.flags.modifier != penaltiesFlag)
this.update({ "flags.modifier": penaltiesFlag })
// Add armor trait to AP object
let armorTrait = traits.find(t => t.name.toLowerCase().includes(game.i18n.localize("NAME.Armour").toLowerCase()))
if (armorTrait && (!this.data.data.excludedTraits || !this.data.data.excludedTraits.includes(armorTrait._id))) {
for (let loc in AP) {
try {
let traitDamage = 0;
if (armorTrait.APdamage)
traitDamage = armorTrait.APdamage[loc] || 0;
if (loc != "shield")
AP[loc].value += (parseInt(armorTrait.data.specification.value) || 0) - traitDamage;
}
catch {//ignore armor traits with invalid values
}
}
}
// keep defensive counter in flags to use for test auto fill (see setupWeapon())
this.data.flags.defensive = defensiveCounter;
// Encumbrance is initially calculated in prepareItems() - this area augments it based on talents
if (actorData.flags.autoCalcEnc) {
let strongBackTalent = talents.find(t => t.name.toLowerCase() == game.i18n.localize("NAME.StrongBack").toLowerCase())
let sturdyTalent = talents.find(t => t.name.toLowerCase() == game.i18n.localize("NAME.Sturdy").toLowerCase())
if (strongBackTalent)
actorData.data.status.encumbrance.max += strongBackTalent.data.advances.value;
if (sturdyTalent)
actorData.data.status.encumbrance.max += sturdyTalent.data.advances.value * 2;
}
// enc used for encumbrance bar in trappings tab
let enc;
totalEnc = Math.floor(totalEnc);
enc = {
max: actorData.data.status.encumbrance.max,
value: Math.round(totalEnc * 10) / 10,
};
// percentage of the bar filled
enc.pct = Math.min(enc.value * 100 / enc.max, 100);
enc.state = enc.value / enc.max; // state is how many times over you are max encumbrance
if (enc.state > 3) {
enc["maxEncumbered"] = true
enc.penalty = game.wfrp4e.config.encumbrancePenalties["maxEncumbered"];
}
else if (enc.state > 2) {
enc["veryEncumbered"] = true
enc.penalty = game.wfrp4e.config.encumbrancePenalties["veryEncumbered"];
}
else if (enc.state > 1) {
enc["encumbered"] = true
enc.penalty = game.wfrp4e.config.encumbrancePenalties["encumbered"];
}
else
enc["notEncumbered"] = true;
// Return all processed objects
return {
inventory,
containers,
basicSkills: basicSkills.sort(game.wfrp4e.utility.nameSorter),
advancedOrGroupedSkills: advancedOrGroupedSkills.sort(game.wfrp4e.utility.nameSorter),
talents,
traits,
weapons,
diseases,
mutations,
armour,
penalties,
penaltyOverflow,
AP,
injuries,
grimoire,
petty,
careers: careers.reverse(),
blessings,
miracles,
money,
psychology,
criticals,
criticalCount: criticals.length,
encumbrance: enc,
ingredients,
totalShieldDamage,
extendedTests,
hasSpells,
hasPrayers,
showOffhand
}
}
/**
* Prepares a skill Item.
*
* Preparation of a skill is simply determining the `total` value, which is the base characteristic + advances.
*
* @param {Object} skill 'skill' type Item
* @return {Object} skill Processed skill, with total value calculated
*/
prepareSkill(skill) {
let actorData = this.data
skill.data.characteristic.num = actorData.data.characteristics[skill.data.characteristic.value].value;
if (skill.data.modifier)
{
if (skill.data.modifier.value > 0)
skill.modified = "positive";
else if (skill.data.modifier.value < 0)
skill.modified = "negative"
}
skill.data.characteristic.abrev = game.wfrp4e.config.characteristicsAbbrev[skill.data.characteristic.value];
skill.data.cost = game.wfrp4e.utility._calculateAdvCost(skill.data.advances.value, "skill", skill.data.advances.costModifier)
return skill
}
/**
*
* Prepares a talent Item.
*
* Prepares a talent with actor data and other talents. Two different ways to prepare a talent:
*
* 1. If a talent with the same name is already prepared, don't prepare this talent and instead
* add to the advancements of the existing talent.
*
* 2. If the talent does not exist yet, turn its "Max" value into "numMax", in other words, turn
* "Max: Initiative Bonus" into an actual number value.
*
* @param {Object} talent 'talent' type Item.
* @param {Array} talentList List of talents prepared so far. Prepared talent is pushed here instead of returning.
*/
prepareTalent(talent, talentList) {
let actorData = this.data
// Find an existing prepared talent with the same name
let existingTalent = talentList.find(t => t.name == talent.name)
if (existingTalent) // If it exists
{
if (!existingTalent.numMax) // If for some reason, it does not have a numMax, assign it one
talent["numMax"] = actorData.data.characteristics[talent.data.max.value].bonus;
// Add an advancement to the existing talent
existingTalent.data.advances.value++;
existingTalent.cost = (existingTalent.data.advances.value + 1) * 100
}
else // If a talent of the same name does not exist
{
switch (talent.data.max.value) // Turn its max value into "numMax", which is an actual numeric value
{
case '1':
talent["numMax"] = 1;
break;
case '2':
talent["numMax"] = 2;
break;
case 'none':
talent["numMax"] = "-";
break;
default:
talent["numMax"] = actorData.data.characteristics[talent.data.max.value].bonus;
}
talent.cost = 200;
talentList.push(talent); // Add the prepared talent to the talent list
}
}
/**
* Prepares a weapon Item.
*
* Prepares a weapon using actor data, ammunition, properties, and flags. The weapon's raw
* data is turned into more user friendly / meaningful data with either config values or
* calculations. Also turns all qualities/flaws into a more structured object.
*
* @param {Object} weapon 'weapon' type Item
* @param {Array} ammoList array of 'ammo' type Items
* @param {Array} skills array of 'skill' type Items
*
* @return {Object} weapon processed weapon
*/
prepareWeaponCombat(weapon, ammoList, skills) {
let actorData = this.data
if (!skills) // If a skill list isn't provided, filter all items to find skills
skills = actorData.items.filter(i => i.type == "skill");
weapon.attackType = game.wfrp4e.config.groupToType[weapon.data.weaponGroup.value]
weapon.data.reach.value = game.wfrp4e.config.weaponReaches[weapon.data.reach.value];
weapon.data.weaponGroup.value = game.wfrp4e.config.weaponGroups[weapon.data.weaponGroup.value] || "basic";
// Attach the available skills to use to the weapon.
weapon.skillToUse = skills.find(x => x.name.toLowerCase().includes(`(${weapon.data.weaponGroup.value.toLowerCase()})`))
// prepareQualitiesFlaws turns the comma separated qualities/flaws string into a string array
// Does not include qualities if no skill could be found above
weapon["properties"] = game.wfrp4e.utility._prepareQualitiesFlaws(weapon, !!weapon.skillToUse);
// Special flail rule - if no skill could be found, add the Dangerous property
if (weapon.data.weaponGroup.value == game.i18n.localize("SPEC.Flail") && !weapon.skillToUse && !weapon.properties.includes(game.i18n.localize("PROPERTY.Dangerous")))
weapon.properties.push(game.i18n.localize("PROPERTY.Dangerous"));
// Turn range into a numeric value (important for ranges including SB, see the function for details)
weapon.data.range.value = this.calculateRangeOrDamage(weapon.data.range.value);
// Melee Damage calculation
if (weapon.attackType == "melee") {
weapon["meleeWeaponType"] = true;
// Turn melee damage formula into a numeric value (SB + 4 into a number) Melee damage increase flag comes from Strike Mighty Blow talent
weapon.data.damage.value = this.calculateRangeOrDamage(weapon.data.damage.value) + (actorData.flags.meleeDamageIncrease || 0);
// Very poor wording, but if the weapon has suffered damage (weaponDamage), subtract that amount from meleeValue (melee damage the weapon deals)
if (weapon.data.weaponDamage)
weapon.data.damage.value -= weapon.data.weaponDamage
else
weapon.data["weaponDamage"] = 0;
}
// Ranged Damage calculation
else {
weapon["rangedWeaponType"] = true;
// Turn ranged damage formula into numeric value, same as melee Ranged damage increase flag comes from Accurate Shot
weapon.data.damage.value = this.calculateRangeOrDamage(weapon.data.damage.value) + (actorData.flags.rangedDamageIncrease || 0)
// Very poor wording, but if the weapon has suffered damage (weaponDamage), subtract that amount from rangedValue (ranged damage the weapon deals)
if (weapon.data.weaponDamage)
weapon.data.damage.value -= weapon.data.weaponDamage
else
weapon.data["weaponDamage"] = 0;
}
// If the weapon uses ammo...
if (weapon.data.ammunitionGroup.value != "none") {
weapon["ammo"] = [];
// If a list of ammo has been provided, filter it by ammo that is compatible with the weapon type
if (ammoList) {
weapon.ammo = ammoList.filter(a => a.data.ammunitionType.value == weapon.data.ammunitionGroup.value)
}
else // If no ammo has been provided, filter through all items and find ammo that is compaptible
for (let a of actorData.items)
if (a.type == "ammunition" && a.data.ammunitionType.value == weapon.data.ammunitionGroup.value) // If is ammo and the correct type of ammo
weapon.ammo.push(a);
// Send to prepareWeaponWithAmmo for further calculation (Damage/range modifications based on ammo)
this.prepareWeaponWithAmmo(weapon);
}
// If throwing or explosive weapon, its ammo is its own quantity
else if (weapon.data.weaponGroup.value == game.i18n.localize("SPEC.Throwing") || weapon.data.weaponGroup.value == game.i18n.localize("SPEC.Explosives")) {
weapon.data.ammunitionGroup.value = "";
}
// If entangling, it has no ammo
else if (weapon.data.weaponGroup.value == game.i18n.localize("SPEC.Entangling")) {
weapon.data.ammunitionGroup.value = "";
}
// Separate qualities and flaws into their own arrays: weapon.properties.qualities/flaws
weapon.properties = game.wfrp4e.utility._separateQualitiesFlaws(weapon.properties);
if (weapon.properties.spec)
{
for(let prop of weapon.properties.spec)
{
let spec
if (prop == game.i18n.localize("Special"))
weapon.properties.special = weapon.data.special.value;
if (prop == game.i18n.localize("Special Ammo"))
weapon.properties.specialammo = weapon.ammo.find(a => a._id == weapon.data.currentAmmo.value).data.special.value
}
}
return weapon;
}
/**
* Prepares an armour Item.
*
* Takes a an armour item, along with a persistent AP object to process the armour
* into a useable format. Adding AP values and qualities to the AP object to be used
* in display and opposed tests.
*
* @param {Object} armor 'armour' type item
* @param {Object} AP Object consisting of numeric AP value for each location and a layer array to represent each armour layer
* @return {Object} armor processed armor item
*/
prepareArmorCombat(armor, AP) {
// Turn comma separated qualites/flaws into a more structured 'properties.qualities/flaws` string array
armor.properties = game.wfrp4e.utility._separateQualitiesFlaws(game.wfrp4e.utility._prepareQualitiesFlaws(armor));
// Iterate through armor locations covered
for (let apLoc in armor.data.currentAP) {
// -1 is what all newly created armor's currentAP is initialized to, so if -1: currentAP = maxAP (undamaged)
if (armor.data.currentAP[apLoc] == -1) {
armor.data.currentAP[apLoc] = armor.data.maxAP[apLoc];
}
}
// If the armor protects a certain location, add the AP value of the armor to the AP object's location value
// Then pass it to addLayer to parse out important information about the armor layer, namely qualities/flaws
if (armor.data.maxAP.head > 0) {
armor["protectsHead"] = true;
AP.head.value += armor.data.currentAP.head;
game.wfrp4e.utility.addLayer(AP, armor, "head")
}
if (armor.data.maxAP.body > 0) {
armor["protectsBody"] = true;
AP.body.value += armor.data.currentAP.body;
game.wfrp4e.utility.addLayer(AP, armor, "body")
}
if (armor.data.maxAP.lArm > 0) {
armor["protectslArm"] = true;
AP.lArm.value += armor.data.currentAP.lArm;
game.wfrp4e.utility.addLayer(AP, armor, "lArm")
}
if (armor.data.maxAP.rArm > 0) {
armor["protectsrArm"] = true;
AP.rArm.value += armor.data.currentAP.rArm;
game.wfrp4e.utility.addLayer(AP, armor, "rArm")
}
if (armor.data.maxAP.lLeg > 0) {
armor["protectslLeg"] = true;
AP.lLeg.value += armor.data.currentAP.lLeg;
game.wfrp4e.utility.addLayer(AP, armor, "lLeg")
}
if (armor.data.maxAP.rLeg > 0) {
armor["protectsrLeg"] = true
AP.rLeg.value += armor.data.currentAP.rLeg;
game.wfrp4e.utility.addLayer(AP, armor, "rLeg")
}
return armor;
}
/**
* Augments a prepared weapon based on its equipped ammo.
*
* Ammo can provide bonuses or penalties to the weapon using it, this function
* takes a weapon, finds its current ammo, and applies those modifiers to the
* weapon stats. For instance, if ammo that halves weapon range is equipped,
* this is where it modifies the range of the weapon
*
* @param {Object} weapon A *prepared* weapon item
* @return {Object} weapon Augmented weapon item
*/
prepareWeaponWithAmmo(weapon) {
// Find the current ammo equipped to the weapon, if none, return
let ammo = weapon.ammo.find(a => a._id == weapon.data.currentAmmo.value);
if (!ammo)
return;
let ammoProperties = game.wfrp4e.utility._prepareQualitiesFlaws(ammo);
// If ammo properties include a "special" value, rename the property as "Special Ammo" to not overlap
// with the weapon's "Special" property
let specialPropInd = ammoProperties.indexOf(ammoProperties.find(p => p && p.toLowerCase() == game.i18n.localize("Special").toLowerCase()));
if (specialPropInd != -1)
ammoProperties[specialPropInd] = game.i18n.localize("Special Ammo")
let ammoRange = ammo.data.range.value || "0";
let ammoDamage = ammo.data.damage.value || "0";
// If range modification was handwritten, process it
if (ammoRange.toLowerCase() == "as weapon") { }
// Do nothing to weapon's range
else if (ammoRange.toLowerCase() == "half weapon")
weapon.data.range.value /= 2;
else if (ammoRange.toLowerCase() == "third weapon")
weapon.data.range.value /= 3;
else if (ammoRange.toLowerCase() == "quarter weapon")
weapon.data.range.value /= 4;
else if (ammoRange.toLowerCase() == "twice weapon")
weapon.data.range.value *= 2;
else // If the range modification is a formula (supports +X -X /X *X)
{
try // Works for + and -
{
ammoRange = eval(ammoRange);
weapon.data.range.value = Math.floor(eval(weapon.data.range.value + ammoRange));
}
catch // if *X and /X
{ // eval (50 + "/5") = eval(50/5) = 10
weapon.data.range.value = Math.floor(eval(weapon.data.range.value + ammoRange));
}
}
try // Works for + and -
{
ammoDamage = eval(ammoDamage);
weapon.data.damage.value = Math.floor(eval(weapon.data.damage.value + ammoDamage));
}
catch // if *X and /X
{ // eval (5 + "*2") = eval(5*2) = 10
weapon.data.damage.value = Math.floor(eval(weapon.data.damage.value + ammoDamage)); // Eval throws exception for "/2" for example.
}
// The following code finds qualities or flaws of the ammo that add to the weapon's qualities
// Example: Blast +1 should turn a weapon's Blast 4 into Blast 5
ammoProperties = ammoProperties.filter(p => p != undefined);
let propertyChange = ammoProperties.filter(p => p.includes("+") || p.includes("-")); // Properties that increase or decrease another (Blast +1, Blast -1)
// Normal properties (Impale, Penetrating) from ammo that need to be added to the equipped weapon
let propertiesToAdd = ammoProperties.filter(p => !(p.includes("+") || p.includes("-")));
for (let change of propertyChange) {
// Using the example of "Blast +1" to a weapon with "Blast 3"
let index = change.indexOf(" ");
let property = change.substring(0, index).trim(); // "Blast"
let value = change.substring(index, change.length); // "+1"
if (weapon.properties.find(p => p.includes(property))) // Find the "Blast" quality in the main weapon
{
let basePropertyIndex = weapon.properties.findIndex(p => p.includes(property))
let baseValue = weapon.properties[basePropertyIndex].split(" ")[1]; // Find the Blast value of the weapon (3)
let newValue = eval(baseValue + value) // Assign the new value of Blast 4
weapon.properties[basePropertyIndex] = `${property} ${newValue}`; // Replace old Blast
}
else // If the weapon does not have the Blast quality to begin with
{
propertiesToAdd.push(property + " " + Number(value)); // Add blast as a new quality (Blast 1)
}
}
// Add the new Blast property to the rest of the qualities the ammo adds to the weapon
weapon.properties = weapon.properties.concat(propertiesToAdd);
}
/**
* Prepares a 'spell' or 'prayer' Item type.
*
* Calculates many aspects of spells/prayers defined by characteristics - range, duration, damage, aoe, etc.
* See the calculation function used for specific on how it processes these attributes.
*
* @param {Object} item 'spell' or 'prayer' Item
* @return {Object} item Processed spell/prayer
*/
prepareSpellOrPrayer(item) {
// Turns targets and duration into a number - (e.g. Willpower Bonus allies -> 4 allies, Willpower Bonus Rounds -> 4 rounds, Willpower Yards -> 46 yards)
item['target'] = this.calculateSpellAttributes(item.data.target.value, item.data.target.aoe);
item['duration'] = this.calculateSpellAttributes(item.data.duration.value);
item['range'] = this.calculateSpellAttributes(item.data.range.value);
item.overcasts = {
available: 0,
range: undefined,
duration: undefined,
target: undefined,
}
if (parseInt(item.target)) {
item.overcasts.target = {
label: "Target",
count: 0,
AoE: false,
initial: parseInt(item.target) || item.target,
current: parseInt(item.target) || item.target,
unit: ""
}
}
else if (item.target.includes("AoE")) {
let aoeValue = item.target.substring(item.target.indexOf("(") + 1, item.target.length - 1)
item.overcasts.target = {
label: "AoE",
count: 0,
AoE: true,
initial: parseInt(aoeValue) || aoeValue,
current: parseInt(aoeValue) || aoeValue,
unit: aoeValue.split(" ")[1]
}
}
if (parseInt(item.duration)) {
item.overcasts.duration = {
label: "Duration",
count: 0,
initial: parseInt(item.duration) || item.duration,
current: parseInt(item.duration) || item.duration,
unit: item.duration.split(" ")[1]
}
}
if (parseInt(item.range)) {
item.overcasts.range = {
label: "Range",
count: 0,
initial: parseInt(item.range) || aoeValue,
current: parseInt(item.range) || aoeValue,
unit: item.range.split(" ")[1]
}
}
// Add the + to the duration if it's extendable
if (item.data.duration.extendable)
item.duration += "+";
// Calculate the damage different if it's a Magic Misile spell versus a prayer
if (item.type == "spell")
item['damage'] = this.calculateSpellDamage(item.data.damage.value, item.data.magicMissile.value);
else
item['damage'] = this.calculateSpellDamage(item.data.damage.value, false);
// If it's a spell, augment the description (see _spellDescription() and CN based on memorization)
if (item.type == "spell") {
item.data.description.value = game.wfrp4e.utility._spellDescription(item);
if (!item.data.memorized.value)
item.data.cn.value *= 2;
}
return item;
}
/**
* Turns a formula into a processed string for display
*
* Turns a spell attribute such as "Willpower Bonus Rounds" into a more user friendly, processed value
* such as "4 Rounds". If the aoe is checked, it wraps the result in AoE (Result).
*
* @param {String} formula Formula to process - "Willpower Bonus Rounds"
* @param {boolean} aoe Whether or not it's calculating AoE (changes string return)
* @returns {String} formula processed formula
*/
calculateSpellAttributes(formula, aoe=false)
{
console.log("Compute FR")
let actorData = this.data
formula = formula.toLowerCase();
// Do not process these special values
if (formula != game.i18n.localize("You").toLowerCase() && formula != game.i18n.localize("Special").toLowerCase() && formula != game.i18n.localize("Instant").toLowerCase())
{
// Specific case, to avoid wrong matching with "Force"
if (formula.includes("force mentale"))
{
// Determine if it's looking for the bonus or the value
if (formula.includes('bonus')) {
formula = formula.replace( "bonus de force mentale", actorData.data.characteristics["wp"].bonus);
formula = formula.replace( "force mentale bonus", actorData.data.characteristics["wp"].bonus);
}
else
formula = formula.replace("force mentale", actorData.data.characteristics["wp"].value);
}
if (formula.includes("yard") )
formula = formula.replace('yard', "mètre" );
if (formula.includes("yds") )
formula = formula.replace('yds', "m." );
// Iterate through remaining characteristics
for(let ch in actorData.data.characteristics)
{
// If formula includes characteristic name
//console.log("Testing :", ch, WFRP4E.characteristics[ch].toLowerCase());
if (formula.includes(game.wfrp4e.config.characteristics[ch].toLowerCase()))
{
// Determine if it's looking for the bonus or the value
if (formula.includes('bonus')) {
formula = formula.replace("bonus de " + game.wfrp4e.config.characteristics[ch].toLowerCase(), actorData.data.characteristics[ch].bonus);
formula = formula.replace(game.wfrp4e.config.characteristics[ch].toLowerCase() + " bonus", actorData.data.characteristics[ch].bonus);
}
else
formula = formula.replace(game.wfrp4e.config.characteristics[ch].toLowerCase(), actorData.data.characteristics[ch].value);
}
}
}
// If AoE - wrap with AoE ( )
if (aoe)
formula = "AoE (" + formula.capitalize() + ")";
//console.log("calculateSpellAttributes -> " + formula );
return formula.capitalize();
}
/**
* Turns a formula into a processed string for display
*
* Processes damage formula based - same as calculateSpellAttributes, but with additional
* consideration to whether its a magic missile or not
*
* @param {String} formula Formula to process - "Willpower Bonus + 4"
* @param {boolean} isMagicMissile Whether or not it's a magic missile - used in calculating additional damage
* @returns {String} Processed formula
*/
calculateSpellDamage(formula, isMagicMissile)
{
console.log("Compute FR")
let actorData = this.data
formula = formula.toLowerCase();
if (isMagicMissile) // If it's a magic missile, damage includes willpower bonus
{
formula += "+ " + actorData.data.characteristics["wp"].bonus
}
// Specific case, to avoid wrong matching with "Force"
if (formula.includes("force mentale"))
{
// Determine if it's looking for the bonus or the value
if (formula.includes('bonus')) {
formula = formula.replace( "bonus de force mentale", actorData.data.characteristics["wp"].bonus);
formula = formula.replace( "force mentale bonus", actorData.data.characteristics["wp"].bonus);
} else
formula = formula.replace("force mentale", actorData.data.characteristics["wp"].value);
}
// Iterate through characteristics
for(let ch in actorData.data.characteristics)
{
// If formula includes characteristic name
while (formula.includes(actorData.data.characteristics[ch].label.toLowerCase()))
{
// Determine if it's looking for the bonus or the value
if (formula.includes('bonus')) {
formula = formula.replace("bonus de " + game.wfrp4e.config.characteristics[ch].toLowerCase(), actorData.data.characteristics[ch].bonus);
formula = formula.replace(game.wfrp4e.config.characteristics[ch].toLowerCase() + " bonus", actorData.data.characteristics[ch].bonus);
}
else
formula = formula.replace(game.wfrp4e.config.characteristics[ch].toLowerCase(), actorData.data.characteristics[ch].value);
}
}
//console.log("calculateSpellDamage -> " + formula );
return eval(formula);
}
/**
* Construct armor penalty string based on armors equipped.
*
* For each armor, compile penalties and concatenate them into one string.
* Does not stack armor *type* penalties.
*
* @param {Array} armorList array of processed armor items
* @return {string} Penalty string
*/
calculateArmorPenalties(armorList) {
let armorPenaltiesString = "";
// Armor type penalties do not stack, only apply if you wear any of that type
let wearingMail = false;
let wearingPlate = false;
for (let a of armorList) {
// For each armor, apply its specific penalty value, as well as marking down whether
// it qualifies for armor type penalties (wearingMail/Plate)
armorPenaltiesString += a.data.penalty.value + " ";
if (a.data.armorType.value == "mail")
wearingMail = true;
if (a.data.armorType.value == "plate")
wearingPlate = true;
}
// Apply armor type penalties at the end
if (wearingMail || wearingPlate) {
let stealthPenaltyValue = 0;
if (wearingMail)
stealthPenaltyValue += -10;
if (wearingPlate)
stealthPenaltyValue += -10;
// Add the penalties together to reduce redundancy
armorPenaltiesString += (stealthPenaltyValue + ` ${game.i18n.localize("NAME.Stealth")}`);
}
return armorPenaltiesString;
}
/**
* Calculates a weapon's range or damage formula.
*
* Takes a weapon formula for Damage or Range (SB + 4 or SBx3) and converts to a numeric value.
*
* @param {String} formula formula to be processed (SBx3 => 9).
*
* @return {Number} Numeric formula evaluation
*/
calculateRangeOrDamage(formula)
{
console.log("FR function calculateRangeOrDamage !", formula);
let actorData = this.data
try
{
formula = formula.toLowerCase();
// Iterate through characteristics
for(let ch in actorData.data.characteristics)
{
// Determine if the formula includes the characteristic's abbreviation + B (SB, WPB, etc.)
if (formula.includes(ch.concat('b')))
{
// Replace that abbreviation with the Bonus value
formula = formula.replace(ch.concat('b'), actorData.data.characteristics[ch].bonus.toString());
}
}
if (formula.includes("yard") )
formula = formula.replace('yard', "mètre" );
if (formula.includes("yds") )
formula = formula.replace('yds', "m." );
// To evaluate multiplication, replace x with *
formula = formula.replace('x', '*');
return eval(formula);
}
catch
{
return formula
}
}
/**
* Adds all missing basic skills to the Actor.
*
* This function will add all mising basic skills, used when an Actor is created (see create())
* as well as from the right click menu from the Actor directory.
*
*/
async addBasicSkills() {
let allItems = duplicate(this.data.items)
let ownedBasicSkills = allItems.filter(i => i.type == "skill" && i.data.advanced.value == "bsc");
let allBasicSkills = await game.wfrp4e.utility.allBasicSkills()
// Filter allBasicSkills with ownedBasicSkills, resulting in all the missing skills
let skillsToAdd = allBasicSkills.filter(s => !ownedBasicSkills.find(ownedSkill => ownedSkill.name == s.name))
// Add those missing basic skills
this.createEmbeddedEntity("OwnedItem", skillsToAdd);
}
/**
* Calculates the wounds of an actor based on prepared items
*
* Once all the item preparation is done (prepareItems()), we have a list of traits/talents to use that will
* factor into Wonuds calculation. Namely: Hardy and Size traits. If we find these, they must be considered
* in Wound calculation.
*
* @returns {Number} Max wound value calculated
*/
_calculateWounds() {
let hardies = this.data.items.filter(t => (t.type == "trait" || t.type == "talent") && t.name.toLowerCase().includes(game.i18n.localize("NAME.Hardy").toLowerCase()))
let traits = this.data.items.filter(t => t.type == "trait")
let tbMultiplier = hardies.length
tbMultiplier += hardies.filter(h => h.type == "talent").reduce((extra, talent) => extra + talent.data.advances.value - 1, 0) // Add extra advances if some of the talents had multiple advances (rare, usually there are multiple talent items, not advances)
// Easy to reference bonuses
let sb = this.data.data.characteristics.s.bonus;
let tb = this.data.data.characteristics.t.bonus;
let wpb = this.data.data.characteristics.wp.bonus;
if (this.data.flags.autoCalcCritW)
this.data.data.status.criticalWounds.max = tb;
let wounds = this.data.data.status.wounds.max;
if (this.data.flags.autoCalcWounds) {
// Construct trait means you use SB instead of WPB
if (traits.find(t => t.name.toLowerCase().includes(game.i18n.localize("NAME.Construct").toLowerCase()) || traits.find(t => t.name.toLowerCase().includes(game.i18n.localize("NAME.Mindless").toLowerCase()))))
wpb = sb;
switch (this.data.data.details.size.value) // Use the size to get the correct formula (size determined in prepare())
{
case "tiny":
wounds = 1 + tb * tbMultiplier;
break;
case "ltl":
wounds = tb + tb * tbMultiplier;
break;
case "sml":
wounds = 2 * tb + wpb + tb * tbMultiplier;
break;
case "avg":
wounds = sb + 2 * tb + wpb + tb * tbMultiplier;
break;
case "lrg":
wounds = 2 * (sb + 2 * tb + wpb + tb * tbMultiplier);
break;
case "enor":
wounds = 4 * (sb + 2 * tb + wpb + tb * tbMultiplier);
break;
case "mnst":
wounds = 8 * (sb + 2 * tb + wpb + tb * tbMultiplier);
break;
}
}
let swarmTrait = traits.find(t => t.name.toLowerCase().includes(game.i18n.localize("NAME.Swarm").toLowerCase()))
if (swarmTrait)
wounds *= 5;
return wounds
}
/**
* Apply damage to an actor, taking into account armor, size, and weapons.
*
* applyDamage() is typically called at the end of an oppposed tests, where you can
* right click the chat message and apply damage. This function goes through the
* process of calculating and reducing damage if needede based on armor, toughness,
* size, armor qualities/flaws, and weapon qualities/flaws
*
* @param {Object} victim id of actor taking damage
* @param {Object} opposedData Test results, all the information needed to calculate damage
* @param {var} damageType enum for what the damage ignores, see config.js
*/
static applyDamage(victim, opposeData, damageType = game.wfrp4e.config.DAMAGE_TYPE.NORMAL) {
if (!opposeData.damage)
return `<b>Error</b>: ${game.i18n.localize("CHAT.DamageAppliedError")}`
// If no damage value, don't attempt anything
if (!opposeData.damage.value)
return game.i18n.localize("CHAT.DamageAppliedErrorTiring");
// Get actor/tokens for those in the opposed test
let actor = game.wfrp4e.utility.getSpeaker(victim);
let attacker = game.wfrp4e.utility.getSpeaker(opposeData.speakerAttack)
let soundContext = { item: {}, action: "hit" };
// Start wound loss at the damage value
let totalWoundLoss = opposeData.damage.value
let newWounds = actor.data.data.status.wounds.value;
let applyAP = (damageType == game.wfrp4e.config.DAMAGE_TYPE.IGNORE_TB || damageType == game.wfrp4e.config.DAMAGE_TYPE.NORMAL)
let applyTB = (damageType == game.wfrp4e.config.DAMAGE_TYPE.IGNORE_AP || damageType == game.wfrp4e.config.DAMAGE_TYPE.NORMAL)
let AP = {};
// Start message update string
let updateMsg = `<b>${game.i18n.localize("CHAT.DamageApplied")}</b><span class = 'hide-option'>: @TOTAL`;
if (damageType != game.wfrp4e.config.DAMAGE_TYPE.IGNORE_ALL)
updateMsg += " ("
let weaponProperties
// If armor at hitloc has impenetrable value or not
let impenetrable = false;
// If weapon is undamaging
let undamaging = false;
// If weapon has Hack
let hack = false;
// If weapon has Impale
let impale = false;
// If weapon has Penetrating
let penetrating = false;
// if weapon has pummel - only used for audio
let pummel = false
// Reduce damage by TB
if (applyTB) {
totalWoundLoss -= actor.data.data.characteristics.t.bonus
updateMsg += actor.data.data.characteristics.t.bonus + " TB"
}
// If the actor has the Robust talent, reduce damage by times taken
totalWoundLoss -= actor.data.flags.robust || 0;
if (actor.data.flags.robust)
updateMsg += ` + ${actor.data.flags.robust} Robust`
if (applyAP) {
AP = actor.prepareItems().AP[opposeData.hitloc.value]
AP.ignored = 0;
if (opposeData.attackerTestResult.weapon) // If the attacker is using a weapon
{
// Determine its qualities/flaws to be used for damage calculation
weaponProperties = opposeData.attackerTestResult.weapon.properties;
penetrating = weaponProperties.qualities.includes(game.i18n.localize("PROPERTY.Penetrating"))
undamaging = weaponProperties.flaws.includes(game.i18n.localize("PROPERTY.Undamaging"))
hack = weaponProperties.qualities.includes(game.i18n.localize("PROPERTY.Hack"))
impale = weaponProperties.qualities.includes(game.i18n.localize("PROPERTY.Impale"))
pummel = weaponProperties.qualities.includes(game.i18n.localize("PROPERTY.Pummel"))
}
// see if armor flaws should be triggered
let ignorePartial = opposeData.attackerTestResult.roll % 2 == 0 || opposeData.attackerTestResult.extra.critical
let ignoreWeakpoints = opposeData.attackerTestResult.extra.critical && impale
// Mitigate damage with armor one layer at a time
for (let layer of AP.layers) {
if (ignoreWeakpoints && layer.weakpoints) {
AP.ignored += layer.value
}
else if (ignorePartial && layer.partial) {
AP.ignored += layer.value;
}
else if (penetrating) // If penetrating - ignore 1 or all armor depending on material
{
AP.ignored += layer.metal ? 1 : layer.value
}
if (opposeData.attackerTestResult.roll % 2 != 0 && layer.impenetrable) {
impenetrable = true;
soundContext.outcome = "impenetrable"
}
// Prioritize plate over chain over leather for sound
if (layer.value) {
if (layer.armourType == "plate")
soundContext.item.armourType = layer.armourType
else if (!soundContext.item.armourType || (soundContext.item.armourType && (soundContext.item.armourType.includes("leather")) && layer.armourType == "mail")) // set to chain if there isn't an armour type set yet, or the current armor type is leather
soundContext.item.armourType = layer.armourType
else if (!soundContext.item.armourType)
soundContext.item.armourType = "leather"
}
}
// AP.used is the actual amount of AP considered
AP.used = AP.value - AP.ignored
AP.used = AP.used < 0 ? 0 : AP.used; // AP minimum 0
AP.used = undamaging ? AP.used * 2 : AP.used; // Double AP if undamaging
// show the AP usage in the updated message
if (AP.ignored)
updateMsg += ` + ${AP.used}/${AP.value} ${game.i18n.localize("AP")}`
else
updateMsg += ` + ${AP.used} ${game.i18n.localize("AP")}`
// If using a shield, add that AP as well
let shieldAP = 0;
if (opposeData.defenderTestResult.weapon) {
if (opposeData.defenderTestResult.weapon.properties.qualities.find(q => q.toLowerCase().includes(game.i18n.localize("PROPERTY.Shield").toLowerCase())))
shieldAP = Number(opposeData.defenderTestResult.weapon.properties.qualities.find(q => q.toLowerCase().includes(game.i18n.localize("PROPERTY.Shield").toLowerCase())).split(" ")[1]);
}
if (shieldAP)
updateMsg += ` + ${shieldAP} ${game.i18n.localize("CHAT.DamageShield")})`
else
updateMsg += ")"
// Reduce damage done by AP
totalWoundLoss -= (AP.used + shieldAP)
// Minimum 1 wound if not undamaging
if (!undamaging)
totalWoundLoss = totalWoundLoss <= 0 ? 1 : totalWoundLoss
else
totalWoundLoss = totalWoundLoss <= 0 ? 0 : totalWoundLoss
try {
if (opposeData.attackerTestResult.weapon.attackType == "melee") {
if ((weaponProperties.qualities.concat(weaponProperties.flaws)).every(p => [game.i18n.localize("PROPERTY.Pummel"), game.i18n.localize("PROPERTY.Slow"), game.i18n.localize("PROPERTY.Damaging")].includes(p)))
soundContext.outcome = "warhammer" // special sound for warhammer :^)
else if (AP.used) {
soundContext.item.type = "armour"
if (applyAP && totalWoundLoss <= 1)
soundContext.outcome = "blocked"
else if (applyAP)
soundContext.outcome = "normal"
if (impenetrable)
soundContext.outcome = "impenetrable"
if (hack)
soundContext.outcome = "hack"
}
else {
soundContext.item.type = "hit"
soundContext.outcome = "normal"
if (impale || penetrating) {
soundContext.outcome = "normal_slash"
}
}
}
}
catch (e) { console.log("wfrp4e | Sound Context Error: " + e) } // Ignore sound errors
}
else updateMsg += ")"
newWounds -= totalWoundLoss
game.wfrp4e.audio.PlayContextAudio(soundContext)
// If damage taken reduces wounds to 0, show Critical
if (newWounds <= 0 && !impenetrable) {
//WFRP_Audio.PlayContextAudio(opposeData.attackerTestResult.weapon, {"type": "hit", "equip": "crit"})
let critAmnt = game.settings.get("wfrp4e", "dangerousCritsMod")
if (game.settings.get("wfrp4e", "dangerousCrits") && critAmnt && (Math.abs(newWounds) - actor.data.data.characteristics.t.bonus) > 0) {
let critModifier = (Math.abs(newWounds) - actor.data.data.characteristics.t.bonus) * critAmnt;
updateMsg += `<br><a class ="table-click critical-roll" data-modifier=${critModifier} data-table = "crit${opposeData.hitloc.value}" ><i class='fas fa-list'></i> ${game.i18n.localize("Critical")} +${critModifier}</a>`
}
else if (Math.abs(newWounds) < actor.data.data.characteristics.t.bonus)
updateMsg += `<br><a class ="table-click critical-roll" data-modifier="-20" data-table = "crit${opposeData.hitloc.value}" ><i class='fas fa-list'></i> ${game.i18n.localize("Critical")} (-20)</a>`
else
updateMsg += `<br><a class ="table-click critical-roll" data-table = "crit${opposeData.hitloc.value}" ><i class='fas fa-list'></i> ${game.i18n.localize("Critical")}</a>`
}
else if (impenetrable)
updateMsg += `<br>${game.i18n.localize("PROPERTY.Impenetrable")} - ${game.i18n.localize("CHAT.CriticalsNullified")}`
if (hack)
updateMsg += `<br>${game.i18n.localize("CHAT.DamageAP")} ${game.wfrp4e.config.locations[opposeData.hitloc.value]}`
if (newWounds <= 0)
newWounds = 0; // Do not go below 0 wounds
updateMsg += "</span>"
updateMsg = updateMsg.replace("@TOTAL", totalWoundLoss)
// Update actor wound value
actor.update({ "data.status.wounds.value": newWounds })
return updateMsg;
}
/* --------------------------------------------------------------------------------------------------------- */
/* -------------------------------------- Auto-Advancement Functions --------------------------------------- */
/* --------------------------------------------------------------------------------------------------------- */
/**
* These functions are primarily for NPCs and Creatures and their automatic advancement capabilities.
*
/* --------------------------------------------------------------------------------------------------------- */
/**
* Advances an actor's skills based on their species and character creation rules
*
* Per character creation, 3 skills from your species list are advanced by 5, and 3 more are advanced by 3.
* This functions uses the Foundry Roll class to randomly select skills from the list (defined in config.js)
* and advance the first 3 selected by 5, and the second 3 selected by 3. This function uses the advanceSkill()
* helper defined below.
*/
async _advanceSpeciesSkills() {
let skillList
// A species may not be entered in the actor, so use some error handling.
try {
skillList = game.wfrp4e.config.speciesSkills[this.data.data.details.species.value];
if (!skillList) {
// findKey() will do an inverse lookup of the species key in the species object defined in config.js, and use that if
// user-entered species value does not work (which it probably will not)
skillList = game.wfrp4e.config.speciesSkills[game.wfrp4e.utility.findKey(this.data.data.details.species.value, game.wfrp4e.config.species)]
if (!skillList) {
throw game.i18n.localize("Error.SpeciesSkills") + " " + this.data.data.details.species.value;
}
}
}
catch (error) {
ui.notifications.info("Could not find species " + this.data.data.details.species.value)
console.log("wfrp4e | Could not find species " + this.data.data.details.species.value + ": " + error);
throw error
}
// The Roll class used to randomly select skills
let skillSelector = new Roll(`1d${skillList.length}- 1`);
skillSelector.roll().total;
// Store selected skills
let skillsSelected = [];
while (skillsSelected.length < 6) {
skillSelector = skillSelector.reroll()
if (!skillsSelected.includes(skillSelector.total)) // Do not push duplicates
skillsSelected.push(skillSelector.total);
}
// Advance the first 3 by 5, advance the second 3 by 3.
for (let skillIndex = 0; skillIndex < skillsSelected.length; skillIndex++) {
if (skillIndex <= 2)
await this._advanceSkill(skillList[skillsSelected[skillIndex]], 5)
else
await this._advanceSkill(skillList[skillsSelected[skillIndex]], 3)
}
}
/**
* Advances an actor's talents based on their species and character creation rules
*
* Character creation rules for talents state that you get all talents in your species, but there
* are a few where you must choose between two instead. See config.js for how the species talent
* object is set up for support in this. Basically species talents are an array of strings, however
* ones that offer a choice is formatted as "<talent1>, <talent2>", each talent being a choice. Finally,
* the last element of the talent list is a number denoting the number of random talents. This function uses
* the advanceTalent() helper defined below.
*/
async _advanceSpeciesTalents() {
// A species may not be entered in the actor, so use some error handling.
let talentList
try {
talentList = game.wfrp4e.config.speciesTalents[this.data.data.details.species.value];
if (!talentList) {
// findKey() will do an inverse lookup of the species key in the species object defined in config.js, and use that if
// user-entered species value does not work (which it probably will not)
talentList = game.wfrp4e.config.speciesTalents[game.wfrp4e.utility.findKey(this.data.data.details.species.value, game.wfrp4e.config.species)]
if (!talentList)
throw game.i18n.localize("Error.SpeciesTalents") + " " + this.data.data.details.species.value;
}
}
catch (error) {
ui.notifications.info("Could not find species " + this.data.data.details.species.value)
console.log("wfrp4e | Could not find species " + this.data.data.details.species.value + ": " + error);
throw error
}
let talentSelector;
for (let talent of talentList) {
if (!isNaN(talent)) // If is a number, roll on random talents
{
for (let i = 0; i < talent; i++) {
let result = game.wfrp4e.tables.rollTable("talents")
await this._advanceTalent(result.name);
}
continue
}
// If there is a comma, talent.split() will yield an array of length > 1
let talentOptions = talent.split(',').map(function (item) {
return item.trim();
});
// Randomly choose a talent option and advance it.
if (talentOptions.length > 1) {
talentSelector = new Roll(`1d${talentOptions.length} - 1`)
await this._advanceTalent(talentOptions[talentSelector.roll().total])
}
else // If no option, simply advance the talent.
{
await this._advanceTalent(talent)
}
}
}
/**
* Adds (if needed) and advances a skill by the specified amount.
*
* As the name suggests, this function advances any given skill, if
* the actor does not currently have that skill, it will be added
* from the compendium and advanced. Note that this function is neither
* used by manually advancing skills nor when clicking on advancement
* indicators. This will simply add the advancement value with no
* other processing.
*
* @param {String} skillName Name of the skill to advance/add
* @param {Number} advances Advances to add to the skill
*/
async _advanceSkill(skillName, advances) {
// Look through items and determine if the actor has the skill
let existingSkill = this.data.items.find(i => i.name.trim() == skillName && i.type == "skill")
// If so, simply update the skill with the new advancement value.
if (existingSkill) {
existingSkill = duplicate(existingSkill);
// If the existing skill has a greater amount of advances, use the greater value instead (make no change) - ??? Is this needed? I'm not sure why I did this. TODO: Evaluate.
existingSkill.data.advances.value = (existingSkill.data.advances.value < advances) ? advances : existingSkill.data.advances.value;
await this.updateEmbeddedEntity("OwnedItem", existingSkill);
return;
}
// If the actor does not already own skill, search through compendium and add it
try {
// See findSkill() for a detailed explanation of how it works
// Advanced find function, returns the skill the user expects it to return, even with skills not included in the compendium (Lore (whatever))
let skillToAdd = await game.wfrp4e.utility.findSkill(skillName)
skillToAdd.data.data.advances.value = advances;
await this.createEmbeddedEntity("OwnedItem", skillToAdd.data);
}
catch (error) {
console.error("Something went wrong when adding skill " + skillName + ": " + error);
ui.notifications.error("Something went wrong when adding skill " + skillName + ": " + error);
}
}
/**
* Adds the given talent to the actor
*
* In my implementation, adding a talent is the same as advancing a talent. See
* prepareTalent() and you'll see that the total number of any given talent is the
* advencement value.
*
* @param {String} talentName Name of the talent to add/advance.
*/
async _advanceTalent(talentName) {
try {
// See findTalent() for a detailed explanation of how it works
// Advanced find function, returns the Talent the user expects it to return, even with Talents not included in the compendium (Etiquette (whatever))
let talent = await game.wfrp4e.utility.findTalent(talentName);
await this.createEmbeddedEntity("OwnedItem", talent.data);
}
catch (error) {
console.error("Something went wrong when adding talent " + talentName + ": " + error);
ui.notifications.error("Something went wrong when adding talent " + talentName + ": " + error);
}
}
/**
* Advance NPC based on given career
*
* A specialized function used by NPC type Actors that triggers when you click on a
* career to be "complete". This takes all the career data and uses it (and the helpers
* defined above) to advance the actor accordingly. It adds all skills (advanced to the
* correct amount to be considered complete), advances all characteristics similarly, and
* adds all talents.
*
* Note: This adds *all* skills and talents, which is not necessary to be considered complete.
* However, I find deleting the ones you don't want to be much easier than trying to pick and
* choose the ones you do want.
*
* @param {Object} careerData Career type Item to be used for advancement.
*
* TODO Refactor for embedded entity along with the helper functions
*/
async _advanceNPC(careerData) {
let updateObj = {};
let advancesNeeded = careerData.level.value * 5; // Tier 1 needs 5, 2 needs 10, 3 needs 15, 4 needs 20 in all characteristics and skills
// Update all necessary characteristics to the advancesNeeded
for (let advChar of careerData.characteristics)
if (this.data.data.characteristics[advChar].advances < 5 * careerData.level.value)
updateObj[`data.characteristics.${advChar}.advances`] = 5 * careerData.level.value;
// Advance all skills in the career
for (let skill of careerData.skills)
await this._advanceSkill(skill, advancesNeeded);
// Add all talents in the career
for (let talent of careerData.talents)
await this._advanceTalent(talent);
this.update(updateObj);
}
_replaceData(formula) {
let dataRgx = new RegExp(/@([a-z.0-9]+)/gi);
return formula.replace(dataRgx, (match, term) => {
let value = getProperty(this.data, term);
return value ? String(value).trim() : "0";
});
}
/**
* Use a fortune point from the actor to reroll or add sl to a roll
* @param {Object} message
* @param {String} type (reroll, addSL)
*/
useFortuneOnRoll(message, type) {
if (this.data.data.status.fortune.value > 0) {
message.data.flags.data.preData.roll = undefined;
let data = message.data.flags.data;
let html = `<h3 class="center"><b>${game.i18n.localize("FORTUNE.Use")}</b></h3>`;
//First we send a message to the chat
if (type == "reroll")
html += `${game.i18n.format("FORTUNE.UsageRerollText", { character: '<b>' + this.name + '</b>' })}<br>`;
else
html += `${game.i18n.format("FORTUNE.UsageAddSLText", { character: '<b>' + this.name + '</b>' })}<br>`;
html += `<b>${game.i18n.localize("FORTUNE.PointsRemaining")} </b>${this.data.data.status.fortune.value - 1}`;
ChatMessage.create(game.wfrp4e.utility.chatDataSetup(html));
let cardOptions = this.preparePostRollAction(message);
//Then we do the actual fortune action
if (type == "reroll") {
cardOptions.fortuneUsedReroll = true;
cardOptions.hasBeenCalculated = false;
cardOptions.calculatedMessage = [];
//It was an unopposed targeted test who failed
if (data.originalTargets && data.originalTargets.size > 0) {
game.user.targets = data.originalTargets;
//Foundry has a circular reference to the user in its targets set so we do it too
game.user.targets.user = game.user;
}
//It it is an ongoing opposed test, we transfer the list of the startMessages to update them
if (!data.defenderMessage && data.startMessagesList) {
cardOptions.startMessagesList = data.startMessagesList;
}
delete data.preData.roll;
delete data.preData.SL;
new ActorWfrp4e_fr(data.postData.actor)[`${data.postData.postFunction}`]({testData : data.preData, cardOptions});
//We also set fortuneUsedAddSL to force the player to use it on the new roll
message.update({
"flags.data.fortuneUsedReroll": true,
"flags.data.fortuneUsedAddSL": true
});
}
else //addSL
{
let newTestData = data.preData;
newTestData.SL = Math.trunc(data.postData.SL) + 1;
newTestData.slBonus = 0;
newTestData.successBonus = 0;
newTestData.roll = Math.trunc(data.postData.roll);
newTestData.hitloc = data.preData.hitloc;
//We deselect the token,
//2020-04-25 : Currently the foundry function is bugged so we do it ourself
//game.user.updateTokenTargets([]);
game.user.targets.forEach(t => t.setTarget(false, { user: game.user, releaseOthers: false, groupSelection: true }));
cardOptions.fortuneUsedAddSL = true;
new ActorWfrp4e_fr(data.postData.actor)[`${data.postData.postFunction}`]({testData : newTestData, cardOptions}, {rerenderMessage : message});
message.update({
"flags.data.fortuneUsedAddSL": true
});
}
this.update({ "data.status.fortune.value": this.data.data.status.fortune.value - 1 });
}
}
/**
* Take a Dark Deal to reroll for +1 Corruption
* @param {Object} message
*/
useDarkDeal(message) {
let html = `<h3 class="center"><b>${game.i18n.localize("DARKDEAL.Use")}</b></h3>`;
html += `${game.i18n.format("DARKDEAL.UsageText", { character: '<b>' + this.name + '</b>' })}<br>`;
let corruption = Math.trunc(this.data.data.status.corruption.value) + 1;
html += `<b>${game.i18n.localize("Corruption")}: </b>${corruption}/${this.data.data.status.corruption.max}`;
ChatMessage.create(game.wfrp4e.utility.chatDataSetup(html));
this.update({ "data.status.corruption.value": corruption }).then(() => {
this.checkCorruption();
});
message.data.flags.data.preData.roll = undefined;
let cardOptions = this.preparePostRollAction(message);
let data = message.data.flags.data;
cardOptions.fortuneUsedReroll = data.fortuneUsedReroll;
cardOptions.fortuneUsedAddSL = data.fortuneUsedAddSL;
cardOptions.hasBeenCalculated = false;
cardOptions.calculatedMessage = [];
//It was an unopposed targeted test who failed
if (data.originalTargets && data.originalTargets.size > 0) {
game.user.targets = data.originalTargets;
//Foundry has a circular reference to the user in its targets set so we do it too
game.user.targets.user = game.user;
}
//It it is an ongoing opposed test, we transfer the list of the startMessages to update them
if (!data.defenderMessage && data.startMessagesList) {
cardOptions.startMessagesList = data.startMessagesList;
}
delete message.data.flags.data.preData.roll;
delete message.data.flags.data.preData.SL;
new ActorWfrp4e_fr(data.postData.actor)[`${data.postData.postFunction}`]({testData : data.preData, cardOptions});
}
/**
* This helper can be used to prepare cardOptions to reroll/edit a test card
* It uses the informations of the roll located in the message entry
* from game.messages
* @param {Object} message
* @returns {Object} cardOptions
*/
preparePostRollAction(message) {
//recreate the initial (virgin) cardOptions object
//add a flag for reroll limit
let data = message.data.flags.data;
let cardOptions = {
flags: { img: message.data.flags.img },
rollMode: data.rollMode,
sound: message.data.sound,
speaker: message.data.speaker,
template: data.template,
title: data.title.replace(` - ${game.i18n.localize("Opposed")}`, ""),
user: message.data.user
};
if (data.attackerMessage)
cardOptions.attackerMessage = data.attackerMessage;
if (data.defenderMessage)
cardOptions.defenderMessage = data.defenderMessage;
if (data.unopposedStartMessage)
cardOptions.unopposedStartMessage = data.unopposedStartMessage;
return cardOptions;
}
async corruptionDialog(strength) {
new Dialog({
title: "Corrupting Influence",
content: `<p>How does ${this.name} resist this corruption?`,
buttons: {
endurance: {
label: game.i18n.localize("NAME.Endurance"),
callback: () => {
let skill = this.items.find(i => i.name == game.i18n.localize("NAME.Endurance") && i.type == "skill")
if (skill) {
this.setupSkill(skill.data, { corruption: strength }).then(setupData => this.basicTest(setupData))
}
else {
this.setupCharacteristic("t", { corruption: strength }).then(setupData => this.basicTest(setupData))
}
}
},
cool: {
label: game.i18n.localize("NAME.Cool"),
callback: () => {
let skill = this.items.find(i => i.name == game.i18n.localize("NAME.Cool") && i.type == "skill")
if (skill) {
this.setupSkill(skill.data, { corruption: strength }).then(setupData => this.basicTest(setupData))
}
else {
this.setupCharacteristic("wp", { corruption: strength }).then(setupData => this.basicTest(setupData))
}
}
}
}
}).render(true)
}
async handleCorruptionResult(testResult) {
let strength = testResult.options.corruption;
let failed = testResult.target < testResult.roll;
let corruption = 0 // Corruption GAINED
switch (strength) {
case "minor":
if (failed)
corruption++;
break;
case "moderate":
if (failed)
corruption += 2
else if (testResult.SL < 2)
corruption += 1
break;
case "major":
if (failed)
corruption += 3
else if (testResult.SL < 2)
corruption += 2
else if (testResult.SL < 4)
corruption += 1
break;
}
let newCorruption = Number(this.data.data.status.corruption.value) + corruption
ChatMessage.create(game.wfrp4e.utility.chatDataSetup(`<b>${this.name}</b> gains ${corruption} Corruption.`, "gmroll", false))
await this.update({ "data.status.corruption.value": newCorruption })
if (corruption > 0)
this.checkCorruption();
}
async checkCorruption() {
if (this.data.data.status.corruption.value > this.data.data.status.corruption.max) {
let skill = this.items.find(i => i.name == game.i18n.localize("NAME.Endurance") && i.type == "skill")
if (skill) {
this.setupSkill(skill.data, { mutate: true }).then(setupData => {
this.basicTest(setupData)
});
}
else {
this.setupCharacteristic("t", { mutate: true }).then(setupData => {
this.basicTest(setupData)
});
}
}
}
async handleMutationResult(testResult) {
let failed = testResult.target < testResult.roll;
if (failed) {
let wpb = this.data.data.characteristics.wp.bonus;
let tableText = "Roll on a Corruption Table:<br>" + game.wfrp4e.config.corruptionTables.map(t => `@Table[${t}]<br>`).join("")
ChatMessage.create(game.wfrp4e.utility.chatDataSetup(`
<h3>Dissolution of Body and Mind</h3>
<p>As corruption ravages your soul, the warping breath of Chaos whispers within, either fanning your flesh into a fresh, new form, or fracturing your psyche with exquisite knowledge it can never unlearn.</p>
<p><b>${this.name}</b> loses ${wpb} Corruption.
<p>${tableText}</p>`,
"gmroll", false))
this.update({ "data.status.corruption.value": Number(this.data.data.status.corruption.value) - wpb })
}
else
ChatMessage.create(game.wfrp4e.utility.chatDataSetup(`You have managed to hold off your corruption. For now.`, "gmroll", false))
}
async handleExtendedTest(testResult) {
let test = duplicate(this.getEmbeddedEntity("OwnedItem", testResult.options.extended));
if(game.settings.get("wfrp4e", "extendedTests") && testResult.SL == 0)
testResult.SL = testResult.roll <= testResult.target ? 1 : -1
if (test.data.failingDecreases.value)
{
test.data.SL.current += Number(testResult.SL)
if (!test.data.negativePossible.value && test.data.SL.current < 0)
test.data.SL.current = 0;
}
else if(testResult.SL > 0)
test.data.SL.current += Number(testResult.SL)
let displayString = `${test.name} ${test.data.SL.current} / ${test.data.SL.target} SL`
if (test.data.SL.current >= test.data.SL.target)
{
if (test.data.completion.value == "reset")
test.data.SL.current = 0;
else if (test.data.completion.value == "remove")
{
this.deleteEmbeddedEntity("OwnedItem", test._id)
test = undefined
}
displayString = displayString.concat("<br>" + "<b>Completed</b>")
}
testResult.other.push(displayString)
if (test)
this.updateEmbeddedEntity("OwnedItem", test);
}
}
View Git Blame Copy Permalink