1125 lines
38 KiB
JavaScript
1125 lines
38 KiB
JavaScript
import { BoLDefaultRoll, BoLRoll } from "../controllers/bol-rolls.js";
|
|
import { BoLUtility } from "../system/bol-utility.js";
|
|
|
|
/**
|
|
* Extend the base Actor entity by defining a custom roll data structure which is ideal for the Simple system.
|
|
* @extends {Actor}
|
|
*/
|
|
export class BoLActor extends Actor {
|
|
|
|
static async create(data, options) {
|
|
|
|
// Case of compendium global import
|
|
if (data instanceof Array) {
|
|
return super.create(data, options);
|
|
}
|
|
// If the created actor has items (only applicable to duplicated actors) bypass the new actor creation logic
|
|
if (data.items) {
|
|
let actor = super.create(data, options);
|
|
return actor;
|
|
}
|
|
|
|
if (data.type == 'encounter') {
|
|
data.system = { resources: { hero : { max : 0, value: 0 } } }
|
|
}
|
|
|
|
if (data.type == 'horde') {
|
|
let weapon = {
|
|
name: game.i18n.localize("BOL.ui.hordeAttack"), type: "item",
|
|
img: "ui/icons/attaque_melee.webp",
|
|
system: foundry.utils.duplicate(game.bol.config.defaultNaturalWeapon)
|
|
}
|
|
weapon.system.properties.attackModifiers = 1
|
|
weapon.system.properties.damage = "1d6M"
|
|
data.items = [weapon]
|
|
|
|
data.img = "systems/bol/ui/icons/icon-horde-token.webp"
|
|
data.prototypeToken = { texture: "systems/bol/ui/icons/icon-horde-token.webp" }
|
|
}
|
|
|
|
return super.create(data, options);
|
|
}
|
|
|
|
/** @override */
|
|
prepareData() {
|
|
|
|
if (this.type === 'character') {
|
|
this.chartype = 'player'
|
|
this.villainy = false
|
|
}
|
|
if (this.type === 'encounter') {
|
|
this.chartype = 'tough'
|
|
this.villainy = true
|
|
}
|
|
if (this.type === 'creature') {
|
|
this.villainy = true
|
|
}
|
|
if (this.type == "horde") {
|
|
let weapon = this.items.find(i => i.type === "item" && i.system.subtype === "weapon")
|
|
// Check if the horde attack is inline with the hordesize
|
|
if (weapon?.system?.properties?.attackModifiers != this.system.hordesize) {
|
|
this.updateEmbeddedDocuments('Item', [{ _id: weapon.id, 'system.properties.attackModifiers': this.system.hordesize }])
|
|
}
|
|
}
|
|
|
|
super.prepareData()
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _onCreateOperation(documents, operation, user) {
|
|
await super._onCreateOperation(documents, operation, user);
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getTokenSizeFromHordeSize(hordeSize) {
|
|
hordeSize = hordeSize || this.system.hordesize
|
|
// If size > 50 then max is 50
|
|
let size = Math.min(hordeSize, 20)
|
|
// Compute the size of the token from 1 to 5
|
|
let tokenSize = Math.max((size / 4), 1) // Never below 1
|
|
return tokenSize
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async _preCreate(data, options, user) {
|
|
await super._preCreate(data, options, user);
|
|
|
|
// Configure prototype token settings
|
|
const prototypeToken = {};
|
|
if (this.type === "character") {
|
|
Object.assign(prototypeToken, {
|
|
sight: { enabled: true }, actorLink: true, disposition: CONST.TOKEN_DISPOSITIONS.FRIENDLY
|
|
});
|
|
this.updateSource({ prototypeToken });
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
isHeroAdversary() {
|
|
if (this.type === 'character') {
|
|
return true
|
|
}
|
|
return (this.type === 'encounter' && this.chartype == "adversary")
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getCharType() {
|
|
if (this.type === 'character') {
|
|
return "player"
|
|
}
|
|
return this.system.chartype
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getVillainy() {
|
|
return ( (this.type === 'encounter' && this.chartype == "adversary") || this.chartype == "creature")
|
|
}
|
|
isUndead() {
|
|
return (this.type == "encounter" && this.system.isundead)
|
|
}
|
|
/* -------------------------------------------- */
|
|
getInitiativeMalus() {
|
|
if (this.type === 'encounter' && (this.chartype == "adversary" || this.chartype == "tough")) {
|
|
return this.system.aptitudes.init.value
|
|
}
|
|
return 0
|
|
}
|
|
/* -------------------------------------------- */
|
|
getBougette() {
|
|
if (this.type == "character") {
|
|
let b = foundry.utils.duplicate(this.system.bougette)
|
|
b.label = game.i18n.localize(game.bol.config.bougetteState[String(this.system.bougette.value)])
|
|
b.diceImg = "icons/dice/" + game.bol.config.bougetteDice[String(this.system.bougette.value)] + "black.svg"
|
|
return b
|
|
}
|
|
return undefined
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollBougette() {
|
|
if (this.type == "character") {
|
|
let attribute = foundry.utils.duplicate(this.system.attributes.vigor)
|
|
let rollData = BoLRoll.getCommonRollData(this, "bougette", attribute, undefined)
|
|
rollData.formula = game.bol.config.bougetteDice[String(this.system.bougette.value)]
|
|
let r = new BoLDefaultRoll(rollData)
|
|
r.roll()
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
decBougette() {
|
|
if (this.type == "character") {
|
|
let bougette = foundry.utils.duplicate(this.system.bougette)
|
|
bougette.value = Math.max(Number(bougette.value) - 1, 0)
|
|
this.update({ 'system.bougette': bougette })
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
updateResourcesData() {
|
|
if (this.type == 'character') {
|
|
let newVitality = 10 + this.system.attributes.vigor.value + this.system.resources.hp.bonus
|
|
if (this.system.resources.hp.max != newVitality) {
|
|
let actor = this
|
|
setTimeout(function () { actor.update({ 'system.resources.hp.max': newVitality }) }, 800)
|
|
}
|
|
let newPower = 10 + this.system.attributes.mind.value + this.system.resources.power.bonus
|
|
if (this.system.resources.power.max != newPower) {
|
|
let actor = this
|
|
setTimeout(function () { actor.update({ 'system.resources.power.max': newPower }) }, 800)
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
prepareDerivedData() {
|
|
if (this.type == "vehicle") {
|
|
|
|
} else {
|
|
super.prepareDerivedData()
|
|
if (this.id) {
|
|
this.updateResourcesData()
|
|
this.manageHealthState()
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
get details() {
|
|
return this.system.details
|
|
}
|
|
addEffectModifiers(myList, dataPath) {
|
|
for (let attr of myList) {
|
|
attr.numModifier = 0
|
|
attr.diceModifier = ""
|
|
let effects = this.items.filter(i => i.type === "feature" && i.system.subtype === "boleffect" && i.system.properties.identifier == dataPath + attr.key)
|
|
for (let effect of effects) {
|
|
if (Number(effect.system.properties.modifier)) {
|
|
attr.numModifier += Number(effect.system.properties.modifier)
|
|
} else {
|
|
attr.diceModifier += "+" + effect.system.properties.modifier
|
|
}
|
|
}
|
|
}
|
|
}
|
|
get attributes() {
|
|
let attrList = foundry.utils.duplicate(Object.values(this.system.attributes))
|
|
this.addEffectModifiers(attrList, "system.attributes.")
|
|
return attrList
|
|
}
|
|
get aptitudes() {
|
|
let aptList = Object.values(this.system.aptitudes)
|
|
this.addEffectModifiers(aptList, "system.aptitudes.")
|
|
return aptList
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
clearRoundModifiers() { // Process data/items that are finished at end of a round
|
|
let foList = this.fightoptions
|
|
for (let fo of foList) {
|
|
if (fo.system.properties.used) {
|
|
this.updateEmbeddedDocuments("Item", [{ _id: fo._id, 'system.properties.used': false }])
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
get defenseValue() {
|
|
let defMod = 0
|
|
let fo = this.getActiveFightOption()
|
|
if (fo && fo.system.properties.fightoptiontype == "intrepid") {
|
|
defMod += -2
|
|
}
|
|
if (fo && fo.system.properties.fightoptiontype == "fulldefense") {
|
|
defMod += 2
|
|
}
|
|
if (fo && fo.system.properties.fightoptiontype == "twoweaponsdef" && !fo.system.properties.used) {
|
|
defMod += 1
|
|
this.updateEmbeddedDocuments("Item", [{ _id: fo._id, 'system.properties.used': true }])
|
|
}
|
|
if (fo && fo.system.properties.fightoptiontype == "defense") {
|
|
defMod += 1
|
|
}
|
|
if (fo && fo.system.properties.fightoptiontype == "attack") {
|
|
defMod += -1
|
|
}
|
|
// Apply defense effects
|
|
for (let i of this.items) {
|
|
if (i.type === "feature" && i.system.subtype === "boleffect" && i.system.properties.identifier.includes("aptitudes.def")) {
|
|
defMod += Number(i.system.properties.modifier)
|
|
}
|
|
}
|
|
console.log("Defense : ", defMod)
|
|
return this.system.aptitudes.def.value + defMod
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getActiveFightOption() {
|
|
let it = this.items.find(i => i.type === "feature" && i.system.subtype === "fightoption" && i.system.properties.activated)
|
|
if (it) {
|
|
return foundry.utils.duplicate(it)
|
|
}
|
|
return undefined
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
addXPLog(type, name, cost, value) {
|
|
let xplog = {
|
|
name: "XP : " + game.i18n.localize(type), type: "feature",
|
|
img: "icons/magic/symbols/chevron-elipse-circle-blue.webp",
|
|
system: {
|
|
subtype: "xplog", properties: {
|
|
xptype: type,
|
|
xpdate: new Date().toLocaleDateString(),
|
|
xpname: name,
|
|
xpcost: cost,
|
|
xpvalue: value
|
|
}
|
|
}
|
|
}
|
|
this.createEmbeddedDocuments('Item', [xplog])
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
incAttributeXP(key) {
|
|
let attr = foundry.utils.duplicate(this.system.attributes[key])
|
|
if (attr) {
|
|
let nextXP = (attr.value == -1) ? 2 : attr.value + (attr.value + 1)
|
|
let xp = foundry.utils.duplicate(this.system.xp)
|
|
if (xp.total - xp.spent >= nextXP) {
|
|
attr.value += 1
|
|
xp.spent += nextXP
|
|
this.update({ [`system.attributes.${key}`]: attr, [`system.xp`]: xp })
|
|
this.addXPLog("attribute", key, nextXP, attr.value)
|
|
} else {
|
|
ui.notifications.warn("Pas assez de points d'expérience !")
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
incAptitudeXP(key) {
|
|
let apt = foundry.utils.duplicate(this.system.aptitudes[key])
|
|
if (apt) {
|
|
let nextXP = (apt.value == -1) ? 1 : apt.value + 2
|
|
let xp = foundry.utils.duplicate(this.system.xp)
|
|
if (xp.total - xp.spent >= nextXP) {
|
|
apt.value += 1
|
|
xp.spent += nextXP
|
|
this.update({ [`system.aptitudes.${key}`]: apt, [`system.xp`]: xp })
|
|
this.addXPLog("aptitude", key, nextXP, apt.value)
|
|
} else {
|
|
ui.notifications.warn("Pas assez de points d'expérience !")
|
|
}
|
|
}
|
|
}
|
|
/* -------------------------------------------- */
|
|
incCareerXP(itemId) {
|
|
let career = this.items.get(itemId)
|
|
if (career) {
|
|
career = foundry.utils.duplicate(career)
|
|
let nextXP = career.system.rank + 1
|
|
let xp = foundry.utils.duplicate(this.system.xp)
|
|
if (xp.total - xp.spent >= nextXP) {
|
|
xp.spent += nextXP
|
|
this.update({ [`system.xp`]: xp })
|
|
this.updateEmbeddedDocuments('Item', [{ _id: career._id, 'system.rank': career.system.rank + 1 }])
|
|
this.addXPLog("career", career.name, nextXP, career.system.rank + 1)
|
|
} else {
|
|
ui.notifications.warn("Pas assez de points d'expérience !")
|
|
}
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async toggleFightOption(itemId) {
|
|
let fightOption = this.items.get(itemId)
|
|
let state
|
|
let updates = []
|
|
|
|
if (fightOption) {
|
|
fightOption = foundry.utils.duplicate(fightOption)
|
|
if (fightOption.system.properties.activated) {
|
|
state = false
|
|
} else {
|
|
state = true
|
|
}
|
|
updates.push({ _id: fightOption._id, 'system.properties.activated': state }) // Update the selected one
|
|
await this.updateEmbeddedDocuments("Item", updates) // Apply all changes
|
|
// Then notify
|
|
ChatMessage.create({
|
|
alias: this.name,
|
|
whisper: BoLUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: await renderTemplate('systems/bol/templates/chat/chat-activate-fight-option.hbs', { name: this.name, img: fightOption.img, foName: fightOption.name, state: state })
|
|
})
|
|
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
get armorMalusValue() { // used for Fight Options
|
|
for (let armor of this.armors) {
|
|
if (armor.system.properties.armorQuality?.includes("light")) {
|
|
return 1
|
|
}
|
|
if (armor.system.properties.armorQuality?.includes("medium")) {
|
|
return 2
|
|
}
|
|
if (armor.system.properties.armorQuality?.includes("heavy")) {
|
|
return 3
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
get resources() {
|
|
return Object.values(this.system.resources)
|
|
}
|
|
get boleffects() {
|
|
return this.items.filter(i => i.type === "feature" && i.system.subtype === "boleffect")
|
|
}
|
|
get xplog() {
|
|
return this.items.filter(i => i.type === "feature" && i.system.subtype === "xplog")
|
|
}
|
|
get horoscopes() {
|
|
return this.items.filter(i => i.type === "feature" && i.system.subtype === "horoscope")
|
|
}
|
|
get boons() {
|
|
return foundry.utils.duplicate(this.items.filter(i => i.type === "feature" && i.system.subtype === "boon") || []);
|
|
}
|
|
get flaws() {
|
|
return foundry.utils.duplicate(this.items.filter(i => i.type === "feature" && i.system.subtype === "flaw") || []);
|
|
}
|
|
get careers() {
|
|
return foundry.utils.duplicate(this.items.filter(i => i.type === "feature" && i.system.subtype === "career") || [])
|
|
}
|
|
get origins() {
|
|
return this.items.filter(i => i.type === "feature" && i.system.subtype === "origin");
|
|
}
|
|
get races() {
|
|
return this.items.filter(i => i.type === "feature" && i.system.subtype === "race");
|
|
}
|
|
get languages() {
|
|
return this.items.filter(i => i.type === "feature" && i.system.subtype === "language")
|
|
}
|
|
get fightoptions() {
|
|
return this.items.filter(i => i.type === "feature" && i.system.subtype === "fightoption")
|
|
}
|
|
get godsfaith() {
|
|
return this.items.filter(i => i.type === "feature" && i.system.subtype === "godsfaith")
|
|
}
|
|
get features() {
|
|
return this.items.filter(i => i.type === "feature")
|
|
}
|
|
get equipment() {
|
|
return this.items.filter(i => i.type === "item")
|
|
}
|
|
get equipmentCreature() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && ((i.system.subtype === "weapon" && i.system.properties.natural === true) || (i.system.subtype === "armor")))
|
|
}
|
|
get armors() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "armor");
|
|
}
|
|
get helms() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "helm");
|
|
}
|
|
get shields() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "shield");
|
|
}
|
|
get vehicleWeapons() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "vehicleweapon")
|
|
}
|
|
get weapons() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "weapon")
|
|
}
|
|
get protections() {
|
|
return this.armors.concat(this.helms).concat(this.shields)
|
|
}
|
|
get spells() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "spell");
|
|
}
|
|
get alchemy() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "alchemy");
|
|
}
|
|
get melee() {
|
|
return this.weapons.filter(i => i.system.properties.melee === true);
|
|
}
|
|
get natural() {
|
|
return this.weapons.filter(i => i.system.properties.natural === true);
|
|
}
|
|
get ranged() {
|
|
return this.weapons.filter(i => i.system.properties.ranged === true);
|
|
}
|
|
|
|
get containers() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "container");
|
|
}
|
|
|
|
get treasure() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "currency");
|
|
}
|
|
|
|
get vehicles() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "vehicle");
|
|
}
|
|
|
|
get ammos() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && i.system.subtype === "ammunition");
|
|
}
|
|
|
|
get misc() {
|
|
return this.items.filter(i => i.type === "item" && i.system.category === "equipment" && (i.system.subtype === "other" || i.system.subtype === "container" || i.system.subtype === "scroll" || i.system.subtype === "jewel"));
|
|
}
|
|
|
|
get bonusBoons() {
|
|
let boons = this.items.filter(i => i.type === "feature" && i.system.subtype === "boon" && i.system.properties.isbonusdice)
|
|
return foundry.utils.duplicate(boons || [])
|
|
}
|
|
get malusFlaws() {
|
|
return foundry.utils.duplicate(this.items.filter(i => i.type === "feature" && i.system.subtype === "flaw" && i.system.properties.ismalusdice) || []);
|
|
}
|
|
|
|
isSorcerer() {
|
|
return (this.careers.find(item => item.system.properties.sorcerer))
|
|
}
|
|
isAlchemist() {
|
|
return (this.careers.find(item => item.system.properties.alchemist))
|
|
}
|
|
isAstrologer() {
|
|
return (this.careers.find(item => item.system.properties.astrologer))
|
|
}
|
|
isPriest() {
|
|
return (this.careers.find(item => item.system.properties.priest))
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
getPPCostArmor() {
|
|
let armors = this.armors
|
|
let ppCostArmor = 0
|
|
for (let armor of armors) {
|
|
if (armor.system.worn) {
|
|
ppCostArmor += Number(armor.system.properties.modifiers.powercost) || 0
|
|
}
|
|
}
|
|
return ppCostArmor
|
|
}
|
|
/*-------------------------------------------- */
|
|
getDamageAttributeValue(attrDamage) {
|
|
let attrDamageValue = 0
|
|
if (attrDamage.includes("vigor")) {
|
|
attrDamageValue = this.system.attributes.vigor.value
|
|
if (attrDamage.includes("half")) {
|
|
attrDamageValue = Math.floor(attrDamageValue / 2)
|
|
}
|
|
// Apply vigor effects
|
|
for (let i of this.items) {
|
|
if (i.type === "feature" && i.system.subtype === "boleffect" && i.system.properties.identifier.includes("vigor")) {
|
|
attrDamageValue += Number(i.system.properties.modifier)
|
|
}
|
|
}
|
|
}
|
|
return attrDamageValue
|
|
}
|
|
/*-------------------------------------------- */
|
|
getArmorAgiMalus() {
|
|
let malusAgi = 0
|
|
for (let armor of this.protections) {
|
|
if (armor.system.worn) {
|
|
malusAgi += Number(armor.system.properties.modifiers.agility) || 0
|
|
}
|
|
}
|
|
return malusAgi
|
|
}
|
|
/*-------------------------------------------- */
|
|
getArmorInitMalus() {
|
|
let malusInit = 0
|
|
for (let armor of this.protections) {
|
|
if (armor.system.worn) {
|
|
malusInit += Number(armor.system.properties.modifiers.init) || 0
|
|
}
|
|
}
|
|
return malusInit
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
spendPowerPoint(ppCost) {
|
|
let newPP = this.system.resources.power.value - ppCost
|
|
newPP = (newPP < 0) ? 0 : newPP
|
|
this.update({ 'system.resources.power.value': newPP })
|
|
return newPP
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
resetAlchemyStatus(alchemyId) {
|
|
let alchemy = this.items.get(alchemyId)
|
|
if (alchemy) {
|
|
this.updateEmbeddedDocuments('Item', [{ _id: alchemy.id, 'system.properties.pccurrent': 0 }])
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
spentAstrologyPoints(points) {
|
|
let astrology = foundry.utils.duplicate(this.system.resources.astrologypoints)
|
|
astrology.value -= points
|
|
astrology.value = Math.max(astrology.value, 0)
|
|
this.update({ 'system.resources.astrologypoints': astrology })
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
getHoroscopesBonus() {
|
|
let astro = this.items.filter(it => it.type == "feature" && it.system.subtype == "horoscope" && !it.system.properties.ishoroscopemajor
|
|
&& it.system.properties.horoscopeanswer == "favorable")
|
|
return astro
|
|
}
|
|
/*-------------------------------------------- */
|
|
getHoroscopesMalus() {
|
|
let astro = this.items.filter(it => it.type == "feature" && it.system.subtype == "horoscope" && !it.system.properties.ishoroscopemajor
|
|
&& it.system.properties.horoscopeanswer == "unfavorable")
|
|
return astro
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
manageHoroscope(rollData) {
|
|
//Spent points
|
|
this.spentAstrologyPoints(rollData.astrologyPointsCost)
|
|
if (rollData.horoscopeType == "minor") {
|
|
let horoscope = {
|
|
name: "SITUATION A SPECIFIER", type: "feature",
|
|
img: "icons/magic/perception/eye-ringed-glow-angry-large-red.webp",
|
|
system: {
|
|
subtype: "horoscope", properties: {
|
|
ishoroscopemajor: false,
|
|
horoscopeanswer: (rollData.isSuccess) ? "favorable" : "unfavorable",
|
|
rank: rollData.careerBonus
|
|
}
|
|
}
|
|
}
|
|
this.createEmbeddedDocuments('Item', [horoscope])
|
|
}
|
|
if (rollData.horoscopeType == "major") {
|
|
let actorHoroscope = this
|
|
if (rollData.targetId) {
|
|
let token = game.scenes.current.tokens.get(rollData.targetId)
|
|
actorHoroscope = token.actor
|
|
}
|
|
if (rollData.isSuccess) {
|
|
actorHoroscope.addHeroPoints(1)
|
|
} else {
|
|
actorHoroscope.subHeroPoints(1)
|
|
}
|
|
rollData.horoscopeName = actorHoroscope.name
|
|
}
|
|
if (rollData.horoscopeType == "majorgroup") {
|
|
let rID = foundry.utils.randomID(16)
|
|
let horoscopes = foundry.utils.duplicate(game.settings.get("bol", "horoscope-group"))
|
|
horoscopes[rID] = {
|
|
id: rID,
|
|
name: game.i18n.localize("BOL.ui.groupHoroscope") + this.name,
|
|
maxDice: rollData.careerBonus,
|
|
availableDice: rollData.careerBonus,
|
|
type: (rollData.isSuccess) ? "bonus" : "malus"
|
|
}
|
|
game.settings.set("bol", "horoscope-group", horoscopes)
|
|
}
|
|
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
getAstrologyPoints() {
|
|
return this.system.resources.astrologypoints.value
|
|
}
|
|
/*-------------------------------------------- */
|
|
removeHoroscopeMinor(rollData) {
|
|
let toDel = []
|
|
for (let horo of rollData.selectedHoroscope) {
|
|
toDel.push(horo._id)
|
|
}
|
|
if (toDel.length > 0) {
|
|
this.deleteEmbeddedDocuments('Item', toDel)
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
async spendAlchemyPoint(alchemyId, pcCost) {
|
|
let alchemy = this.items.get(alchemyId)
|
|
if (alchemy) {
|
|
pcCost = Number(pcCost) || 0
|
|
if (this.system.resources.alchemypoints.value >= pcCost) {
|
|
let newPC = this.system.resources.alchemypoints.value - pcCost
|
|
newPC = (newPC < 0) ? 0 : newPC
|
|
this.update({ 'data.resources.alchemypoints.value': newPC })
|
|
newPC = alchemy.system.properties.pccurrent + pcCost
|
|
await this.updateEmbeddedDocuments('Item', [{ _id: alchemy.id, 'system.properties.pccurrent': newPC }])
|
|
} else {
|
|
ui.notifications.warn(game.i18n.localize("BOL.ui.nomorealchemypoints"))
|
|
}
|
|
}
|
|
}
|
|
/*-------------------------------------------- */
|
|
getAstrologerBonus() {
|
|
let astrologer = this.careers.find(item => item.system.properties.astrologer)
|
|
if (astrologer) {
|
|
return astrologer.system.rank
|
|
}
|
|
return 0;
|
|
}
|
|
/*-------------------------------------------- */
|
|
getAlchemistBonus() {
|
|
let sorcerer = this.careers.find(item => item.system.properties.alchemist)
|
|
if (sorcerer) {
|
|
return sorcerer.system.rank
|
|
}
|
|
return 0;
|
|
}
|
|
/*-------------------------------------------- */
|
|
getSorcererBonus() {
|
|
let sorcerer = this.careers.find(item => item.system.properties.sorcerer)
|
|
if (sorcerer) {
|
|
return sorcerer.system.rank
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
heroReroll() {
|
|
if (this.type == 'character' || this.system.villainy == 'adversary') {
|
|
return this.system.resources.hero.value > 0;
|
|
}
|
|
return false
|
|
}
|
|
/*-------------------------------------------- */
|
|
getHeroPoints() {
|
|
if (this.type == 'character' || this.system.villainy == 'adversary') {
|
|
return this.system.resources.hero.value
|
|
}
|
|
return 0
|
|
}
|
|
/*-------------------------------------------- */
|
|
getResourcesFromType() {
|
|
let resources = {};
|
|
if (this.type == 'encounter') {
|
|
resources['hp'] = this.system.resources.hp;
|
|
if (this.system.chartype != 'base') {
|
|
resources['faith'] = this.system.resources.faith
|
|
resources['power'] = this.system.resources.power
|
|
}
|
|
if (this.system.chartype == 'adversary' || this.system.chartype == 'creature') {
|
|
resources['hero'] = foundry.utils.duplicate(this.system.resources.hero)
|
|
resources['hero'].label = "BOL.resources.villainy"
|
|
}
|
|
} else {
|
|
resources = this.system.resources;
|
|
}
|
|
return resources
|
|
}
|
|
|
|
buildFeatures() {
|
|
return {
|
|
"careers": {
|
|
"label": "BOL.featureCategory.careers",
|
|
"ranked": true,
|
|
"items": this.careers
|
|
},
|
|
"origins": {
|
|
"label": "BOL.featureCategory.origins",
|
|
"ranked": false,
|
|
"items": this.origins
|
|
},
|
|
"races": {
|
|
"label": "BOL.featureCategory.races",
|
|
"ranked": false,
|
|
"items": this.races
|
|
},
|
|
"boons": {
|
|
"label": "BOL.featureCategory.boons",
|
|
"ranked": false,
|
|
"items": this.boons
|
|
},
|
|
"flaws": {
|
|
"label": "BOL.featureCategory.flaws",
|
|
"ranked": false,
|
|
"items": this.flaws
|
|
},
|
|
"languages": {
|
|
"label": "BOL.featureCategory.languages",
|
|
"ranked": false,
|
|
"items": this.languages
|
|
},
|
|
"fightoptions": {
|
|
"label": "BOL.featureCategory.fightoptions",
|
|
"ranked": false,
|
|
"items": this.fightoptions
|
|
},
|
|
"godsfaith": {
|
|
"label": "BOL.featureSubtypes.gods",
|
|
"ranked": false,
|
|
"items": this.godsfaith
|
|
},
|
|
"boleffects": {
|
|
"label": "BOL.featureSubtypes.effects",
|
|
"ranked": false,
|
|
"items": this.boleffects
|
|
}
|
|
}
|
|
}
|
|
|
|
buildCombat() {
|
|
return {
|
|
"melee": {
|
|
"label": "BOL.combatCategory.melee",
|
|
"weapon": true,
|
|
"protection": false,
|
|
"blocking": false,
|
|
"ranged": false,
|
|
"options": false,
|
|
"items": this.melee
|
|
},
|
|
"natural": {
|
|
"label": "BOL.combatCategory.natural",
|
|
"weapon": true,
|
|
"protection": false,
|
|
"blocking": false,
|
|
"ranged": false,
|
|
"options": false,
|
|
"items": this.natural
|
|
},
|
|
"ranged": {
|
|
"label": "BOL.combatCategory.ranged",
|
|
"weapon": true,
|
|
"protection": false,
|
|
"blocking": false,
|
|
"ranged": true,
|
|
"options": false,
|
|
"items": this.ranged
|
|
},
|
|
"protections": {
|
|
"label": "BOL.combatCategory.protections",
|
|
"weapon": false,
|
|
"protection": true,
|
|
"blocking": false,
|
|
"ranged": false,
|
|
"options": false,
|
|
"items": this.protections
|
|
},
|
|
"shields": {
|
|
"label": "BOL.combatCategory.shields",
|
|
"weapon": false,
|
|
"protection": false,
|
|
"blocking": true,
|
|
"ranged": false,
|
|
"options": false,
|
|
"items": this.shields
|
|
},
|
|
"fightoptions": {
|
|
"label": "BOL.combatCategory.fightOptions",
|
|
"weapon": false,
|
|
"protection": false,
|
|
"blocking": false,
|
|
"ranged": false,
|
|
"options": true,
|
|
"items": this.fightoptions
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*-------------------------------------------- */
|
|
buildRollList() {
|
|
let rolls = []
|
|
for (let key in this.system.attributes) {
|
|
let attr = this.system.attributes[key]
|
|
rolls.push({ key: key, value: attr.value, name: attr.label, type: "attribute" })
|
|
}
|
|
for (let key in this.system.aptitudes) {
|
|
if (key != "def") {
|
|
let apt = this.system.aptitudes[key]
|
|
rolls.push({ key: key, value: apt.value, name: apt.label, type: "aptitude" })
|
|
}
|
|
}
|
|
return rolls
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
buildListeActions() {
|
|
return this.melee.concat(this.ranged).concat(this.natural).concat(this.fightoptions)
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
async manageHealthState() {
|
|
let hpID = "lastHP" + this.id
|
|
let lastHP = await this.getFlag("world", hpID)
|
|
if (lastHP != this.system.resources.hp.value && game.user.isGM) { // Only GM sends this
|
|
await this.setFlag("world", hpID, this.system.resources.hp.value)
|
|
let prone = this.effects.find(ef => ef.name == game.i18n.localize("EFFECT.StatusProne"))
|
|
let dead = this.effects.find(ef => ef.name == game.i18n.localize("EFFECT.StatusDead"))
|
|
if (this.system.resources.hp.value <= 0) {
|
|
if (!prone) {
|
|
await this.createEmbeddedDocuments("ActiveEffect", [
|
|
{ name: game.i18n.localize('EFFECT.StatusProne'), icon: 'icons/svg/falling.svg', statuses: 'prone' }
|
|
])
|
|
}
|
|
if (this.system.resources.hp.value < -5 && !dead) {
|
|
await this.createEmbeddedDocuments("ActiveEffect", [
|
|
{ name: game.i18n.localize('EFFECT.StatusDead'), icon: 'icons/svg/skull.svg', statuses: 'dead' }
|
|
])
|
|
}
|
|
ChatMessage.create({
|
|
alias: this.name,
|
|
whisper: BoLUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: await renderTemplate('systems/bol/templates/chat/chat-vitality-zero.hbs', { name: this.name, img: this.img, hp: this.system.resources.hp.value, isHeroAdversary: this.isHeroAdversary() })
|
|
})
|
|
} else {
|
|
if (prone) {
|
|
await this.deleteEmbeddedDocuments("ActiveEffect", [prone.id])
|
|
}
|
|
if (dead) {
|
|
await this.deleteEmbeddedDocuments("ActiveEffect", [dead.id])
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
async registerInit(rollData) {
|
|
rollData.actor = undefined // Cleanup if present
|
|
await this.setFlag("world", "last-initiative", rollData)
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
storeVitaliteCombat() {
|
|
this.setFlag("world", "vitalite-before-combat", foundry.utils.duplicate(this.system.resources.hp))
|
|
}
|
|
/*-------------------------------------------- */
|
|
async displayRecuperation() {
|
|
let previousHP = this.getFlag("world", "vitalite-before-combat")
|
|
let lossHP = previousHP.value - this.system.resources.hp.value
|
|
//console.log(">>>>> RECUP INFO", previousHP, this.system.resources.hp.value)
|
|
if (previousHP && lossHP > 0 && this.system.resources.hp.value > 0) {
|
|
let msg = await ChatMessage.create({
|
|
alias: this.name,
|
|
whisper: BoLUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: await renderTemplate('systems/bol/templates/chat/chat-recup-information.hbs', {
|
|
name: this.name,
|
|
img: this.img,
|
|
actorId: this.id,
|
|
lossHP: lossHP,
|
|
recupHP: Math.ceil(lossHP / 2)
|
|
})
|
|
})
|
|
}
|
|
this.unsetFlag("world", "vitalite-before-combat")
|
|
}
|
|
/*-------------------------------------------- */
|
|
async applyRecuperation(recupHP) {
|
|
let hp = foundry.utils.duplicate(this.system.resources.hp)
|
|
//console.log("RECUP !!!!", hp, recupHP)
|
|
hp.value += Number(recupHP)
|
|
hp.value = Math.min(hp.value, hp.max)
|
|
this.update({ 'system.resources.hp': hp })
|
|
let msg = await ChatMessage.create({
|
|
alias: this.name,
|
|
whisper: BoLUtility.getWhisperRecipientsAndGMs(this.name),
|
|
content: game.i18n.format("BOL.chat.inforecup", { name: this.name, recupHP: recupHP })
|
|
})
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
clearInitiative() {
|
|
this.unsetFlag("world", "last-initiative")
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
getSize() {
|
|
if (this.system.details.size.length > 0 && game.bol.config.creatureSize[this.system.details.size]) {
|
|
return game.bol.config.creatureSize[this.system.details.size].order
|
|
}
|
|
return game.bol.config.creatureSize["medium"].order // Medium size per default
|
|
}
|
|
/*-------------------------------------------- */
|
|
checkNumeric(myObject) {
|
|
if (myObject) {
|
|
for (let key in myObject) {
|
|
if (myObject[key].value === null || isNaN(myObject[key].value)) {
|
|
myObject[key].value = 0
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
_preUpdate(data, options, userId) {
|
|
if (data.system?.attributes) {
|
|
this.checkNumeric(data.system.attributes)
|
|
}
|
|
if (data.system?.aptitudes) {
|
|
this.checkNumeric(data.system.aptitudes)
|
|
}
|
|
if (data.system?.resources) {
|
|
this.checkNumeric(data.system.resources)
|
|
}
|
|
// Apply changes in Horde size to Token width/height
|
|
if (this.type == "horde") {
|
|
if (data?.system?.hordesize) { // If horde size is changed}
|
|
let newHP = data.system.hordesize * this.system.hordebasehp
|
|
if (newHP != this.system.resources.hp.value) {
|
|
data.system.resources = { hp: { value: newHP, max: newHP } } // Update HP
|
|
}
|
|
let tokenSize = this.getTokenSizeFromHordeSize(data?.system?.hordesize)
|
|
if (this.isToken && (tokenSize !== this.token.width)) {
|
|
this.token.update({ width: tokenSize, height: tokenSize })
|
|
} else {
|
|
if (tokenSize && (tokenSize !== this.prototypeToken.width)) {
|
|
if (!foundry.utils.hasProperty(data, "prototypeToken.width")) {
|
|
data.prototypeToken ||= {};
|
|
data.prototypeToken.height = tokenSize;
|
|
data.prototypeToken.width = tokenSize;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (data?.system?.hordebasehp) {
|
|
let newHP = this.system.hordesize * data.system.hordebasehp
|
|
if (newHP != this.system.resources.hp.value) {
|
|
data.system.resources = { hp: { value: newHP, max: newHP } }
|
|
}
|
|
}
|
|
}
|
|
|
|
super._preUpdate(data, options, userId)
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
getInitiativeRank(rollData = undefined, isCombat = false, combatData = undefined) {
|
|
let fvttInit = 4 // Pietaille par defaut
|
|
if (this.type == 'character') {
|
|
fvttInit = 5
|
|
if (!rollData) {
|
|
if (isCombat) {
|
|
if (game.user.isGM) {
|
|
if (this.hasPlayerOwner) {
|
|
game.socket.emit("system.bol", { name: "msg_request_init_roll", data: { actorId: this.id, combatData } })
|
|
} else {
|
|
BoLRoll.aptitudeCheck(this, "init", undefined, combatData);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (rollData.isLegendary) {
|
|
fvttInit = 10
|
|
} else if (rollData.isCritical) {
|
|
fvttInit = 9
|
|
} else if (rollData.isSuccess) {
|
|
fvttInit = 8
|
|
} else if (rollData.isFumble) {
|
|
fvttInit = 3
|
|
}
|
|
}
|
|
}
|
|
if (this.getCharType() == 'adversary') {
|
|
fvttInit = 7
|
|
}
|
|
if (this.getCharType() == 'tough') {
|
|
fvttInit = 6
|
|
}
|
|
if (this.getCharType() == 'creature') {
|
|
let mySize = this.getSize()
|
|
let sizeSmall = game.bol.config.creatureSize["small"].order
|
|
let sizeMedium = game.bol.config.creatureSize["medium"].order
|
|
if (mySize >= sizeSmall && mySize <= sizeMedium) {
|
|
fvttInit = 6
|
|
}
|
|
if (mySize > sizeMedium) {
|
|
fvttInit = 7
|
|
}
|
|
}
|
|
return fvttInit
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
async subHeroPoints(nb) {
|
|
let newHeroP = this.system.resources.hero.value - nb;
|
|
newHeroP = (newHeroP < 0) ? 0 : newHeroP;
|
|
await this.update({ 'system.resources.hero.value': newHeroP });
|
|
}
|
|
/*-------------------------------------------- */
|
|
async addHeroPoints(nb) {
|
|
let newHeroP = this.system.resources.hero.value + nb;
|
|
newHeroP = (newHeroP < 0) ? 0 : newHeroP;
|
|
await this.update({ 'system.resources.hero.value': newHeroP });
|
|
}
|
|
|
|
/*-------------------------------------------- */
|
|
incDecResources(target, value) {
|
|
let newValue = this.system.resources[target].value + value
|
|
this.update({ [`system.resources.${target}.value`]: newValue })
|
|
}
|
|
/*-------------------------------------------- */
|
|
async sufferDamage(damage) {
|
|
let updates = {}
|
|
let newHP = this.system.resources.hp.value - damage
|
|
updates['system.resources.hp.value'] = newHP
|
|
if (this.type == "horde") {
|
|
let newSize = Math.ceil(newHP / this.system.hordebasehp)
|
|
updates['system.hordesize'] = newSize
|
|
}
|
|
await this.update(updates)
|
|
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
getArmorFormula() {
|
|
let protectWorn = this.protections.filter(item => item.system.worn)
|
|
let formula = ""
|
|
for (let protect of protectWorn) {
|
|
if (protect.system.subtype == 'helm') {
|
|
formula += "+1"
|
|
} else if (protect.system.subtype == 'armor') {
|
|
if (BoLUtility.getRollArmor()) {
|
|
if (!protect.system.properties.soak.formula || protect.system.properties.soak.formula == "") {
|
|
ui.notifications.warn(game.i18n.localize("BOL.ui.armornoformula", protect.name))
|
|
} else {
|
|
formula += "+" + " max(" + protect.system.properties.soak.formula + ",0)"
|
|
}
|
|
} else {
|
|
if (protect.system.properties.soak.value == undefined) {
|
|
ui.notifications.warn(game.i18n.localize("BOL.ui.armornoformula", protect.name))
|
|
} else {
|
|
formula += "+ " + protect.system.properties.soak.value
|
|
}
|
|
}
|
|
}
|
|
}
|
|
console.log("Protect Formula", formula)
|
|
return (formula == "") ? "0" : formula;
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
async rollProtection(itemId) {
|
|
let armor = foundry.utils.duplicate(this.items.get(itemId))
|
|
if (armor) {
|
|
let armorFormula = "max(" + armor.system.properties.soak.formula + ", 0)"
|
|
let rollArmor = new Roll(armorFormula)
|
|
await rollArmor.roll()
|
|
rollArmor.toMessage()
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
rollWeaponDamage(itemId) {
|
|
let weapon = foundry.utils.duplicate(this.items.get(itemId))
|
|
if (weapon) {
|
|
let r = new BoLDefaultRoll({ id: foundry.utils.randomID(16), isSuccess: true, mode: "weapon", weapon: weapon, actorId: this.id, actor: this })
|
|
r.setSuccess(true)
|
|
r.rollDamage()
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------- */
|
|
toggleEquipItem(item) {
|
|
const equipable = item.system.properties.equipable;
|
|
if (equipable) {
|
|
let itemData = foundry.utils.duplicate(item);
|
|
itemData.system.worn = !itemData.system.worn;
|
|
return item.update(itemData);
|
|
}
|
|
}
|
|
} |