232 lines
8.6 KiB
JavaScript
232 lines
8.6 KiB
JavaScript
import PrismRPGUtils from "../utils.mjs"
|
|
export default class PrismRPGActor 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 === 'character') {
|
|
const skills = await PrismRPGUtils.loadCompendium("fvtt-prism-rpg.lf-skills")
|
|
data.items = data.items || []
|
|
for (let skill of skills) {
|
|
if (skill.system.category === "layperson") {
|
|
data.items.push(skill.toObject())
|
|
}
|
|
}
|
|
}
|
|
|
|
return super.create(data, options);
|
|
}
|
|
|
|
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 })
|
|
}
|
|
}
|
|
|
|
/* *************************************************/
|
|
getBestWeaponClassSkill(skills, rollType, multiplier = 1.0) {
|
|
let maxValue = 0
|
|
let goodSkill = skills[0]
|
|
for (let s of skills) {
|
|
if (rollType === "weapon-attack") {
|
|
if (s.system.weaponBonus.attack > maxValue) {
|
|
maxValue = Number(s.system.weaponBonus.attack)
|
|
goodSkill = s
|
|
}
|
|
}
|
|
if (rollType === "weapon-defense") {
|
|
if (s.system.weaponBonus.defense > maxValue) {
|
|
maxValue = Number(s.system.weaponBonus.defense)
|
|
goodSkill = s
|
|
}
|
|
}
|
|
if (rollType.includes("weapon-damage")) {
|
|
if (s.system.weaponBonus.damage > maxValue) {
|
|
maxValue = Number(s.system.weaponBonus.damage)
|
|
goodSkill = s
|
|
}
|
|
}
|
|
}
|
|
goodSkill.weaponSkillModifier = maxValue * multiplier
|
|
return goodSkill
|
|
}
|
|
|
|
/* *************************************************/
|
|
async applyDamage(hpLoss) {
|
|
let hp = this.system.hp.value + hpLoss
|
|
if (hp < 0) {
|
|
hp = 0
|
|
}
|
|
this.update({ "system.hp.value": hp })
|
|
}
|
|
|
|
/* *************************************************/
|
|
async prepareRoll(rollType, rollKey, rollDice) {
|
|
console.log("Preparing roll", rollType, rollKey, rollDice)
|
|
let rollTarget
|
|
switch (rollType) {
|
|
case "characteristic":
|
|
if (!this.system.characteristics || !this.system.characteristics[rollKey]) {
|
|
ui.notifications.error(`Characteristic ${rollKey} not found`)
|
|
return
|
|
}
|
|
rollTarget = {
|
|
...foundry.utils.duplicate(this.system.characteristics[rollKey]),
|
|
rollKey: rollKey,
|
|
name: game.i18n.localize(`PRISMRPG.Label.${rollKey}`)
|
|
}
|
|
break
|
|
case "sub-attribute":
|
|
if (!this.system.subAttributes || !this.system.subAttributes[rollKey]) {
|
|
ui.notifications.error(`Sub-attribute ${rollKey} not found`)
|
|
return
|
|
}
|
|
rollTarget = {
|
|
...foundry.utils.duplicate(this.system.subAttributes[rollKey]),
|
|
rollKey: rollKey,
|
|
name: game.i18n.localize(SYSTEM.SUB_ATTRIBUTES[rollKey].label)
|
|
}
|
|
break
|
|
case "granted":
|
|
rollTarget = {
|
|
name: rollKey,
|
|
formula: foundry.utils.duplicate(this.system.granted[rollKey]),
|
|
rollKey: rollKey
|
|
}
|
|
if (rollTarget.formula === "" || rollTarget.formula === undefined) {
|
|
rollTarget.formula = 0
|
|
}
|
|
break;
|
|
case "challenge":
|
|
rollTarget = foundry.utils.duplicate(this.system.challenges[rollKey])
|
|
rollTarget.rollKey = rollKey
|
|
break
|
|
case "save":
|
|
rollTarget = foundry.utils.duplicate(this.system.saves[rollKey])
|
|
rollTarget.rollKey = rollKey
|
|
rollTarget.rollDice = rollDice
|
|
// Pass the characteristic value for D&D 5e modifier calculation
|
|
rollTarget.characteristicValue = this.system.characteristics[rollKey].value
|
|
// The save bonus is the proficiency modifier (value stored in saves)
|
|
rollTarget.saveBonus = this.system.saves[rollKey].value
|
|
break
|
|
case "spell":
|
|
rollTarget = this.items.find((i) => i.type === "spell" && i.id === rollKey)
|
|
rollTarget.rollKey = rollKey
|
|
break
|
|
case "miracle":
|
|
rollTarget = this.items.find((i) => i.type === "miracle" && i.id === rollKey)
|
|
rollTarget.rollKey = rollKey
|
|
break
|
|
case "skill":
|
|
rollTarget = this.items.find((i) => i.type === "skill" && i.id === rollKey)
|
|
rollTarget.rollKey = rollKey
|
|
if (rollTarget.system.category === "weapon") {
|
|
ui.notifications.warn(game.i18n.localize("PRISMRPG.Notifications.rollFromWeapon"))
|
|
return
|
|
}
|
|
// Get the primary attribute for D&D 5e style rolls
|
|
const attrKey = rollTarget.system.primaryAttribute || "dex"
|
|
rollTarget.characteristicValue = this.system.characteristics[attrKey].value
|
|
rollTarget.proficiencyBonus = rollTarget.system.modifier
|
|
break
|
|
case "spell-attack":
|
|
case "spell-power":
|
|
case "miracle-attack":
|
|
case "miracle-power":
|
|
rollTarget = this.items.find((i) => (i.type === "miracle" || i.type === "spell") && i.id === rollKey)
|
|
rollTarget.rollKey = rollKey
|
|
break
|
|
case "shield-roll": {
|
|
rollTarget = this.items.find((i) => i.type === "shield" && i.id === rollKey)
|
|
let shieldSkill = this.items.find((i) => i.type === "skill" && i.name.toLowerCase() === rollTarget.name.toLowerCase())
|
|
rollTarget.skill = shieldSkill
|
|
rollTarget.rollKey = rollKey
|
|
}
|
|
break;
|
|
case "weapon-damage-small":
|
|
case "weapon-damage-medium":
|
|
case "weapon-attack":
|
|
case "weapon-defense": {
|
|
let weapon = this.items.find((i) => i.type === "weapon" && i.id === rollKey)
|
|
let skill
|
|
let skills = this.items.filter((i) => i.type === "skill" && i.name.toLowerCase() === weapon.name.toLowerCase())
|
|
if (skills.length > 0) {
|
|
skill = this.getBestWeaponClassSkill(skills, rollType, 1.0)
|
|
} else {
|
|
skills = this.items.filter((i) => i.type === "skill" && i.name.toLowerCase().replace(" skill", "") === weapon.name.toLowerCase())
|
|
if (skills.length > 0) {
|
|
skill = this.getBestWeaponClassSkill(skills, rollType, 1.0)
|
|
} else {
|
|
skills = this.items.filter((i) => i.type === "skill" && i.system.weaponClass === weapon.system.weaponClass)
|
|
if (skills.length > 0) {
|
|
skill = this.getBestWeaponClassSkill(skills, rollType, 0.5)
|
|
} else {
|
|
skills = this.items.filter((i) => i.type === "skill" && i.system.weaponClass.includes(SYSTEM.WEAPON_CATEGORIES[weapon.system.weaponClass]))
|
|
if (skills.length > 0) {
|
|
skill = this.getBestWeaponClassSkill(skills, rollType, 0.25)
|
|
} else {
|
|
ui.notifications.warn(game.i18n.localize("PRISMRPG.Notifications.skillNotFound"))
|
|
return
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!weapon || !skill) {
|
|
console.error("Weapon or skill not found", weapon, skill)
|
|
ui.notifications.warn(game.i18n.localize("PRISMRPG.Notifications.skillNotFound"))
|
|
return
|
|
}
|
|
rollTarget = skill
|
|
rollTarget.weapon = weapon
|
|
rollTarget.weaponSkillModifier = skill.weaponSkillModifier
|
|
rollTarget.rollKey = rollKey
|
|
rollTarget.combat = foundry.utils.duplicate(this.system.combat)
|
|
if (rollType === "weapon-damage-small" || rollType === "weapon-damage-medium") {
|
|
rollTarget.grantedDice = this.system.granted.damageDice
|
|
}
|
|
if (rollType === "weapon-attack") {
|
|
rollTarget.grantedDice = this.system.granted.attackDice
|
|
}
|
|
if (rollType === "weapon-defense") {
|
|
rollTarget.grantedDice = this.system.granted.defenseDice
|
|
}
|
|
}
|
|
break
|
|
default:
|
|
ui.notifications.error(game.i18n.localize("PRISMRPG.Notifications.rollTypeNotFound") + String(rollType))
|
|
return
|
|
}
|
|
|
|
// In all cases - verify rollTarget exists
|
|
if (!rollTarget) {
|
|
console.error("Roll target is undefined for rollType:", rollType)
|
|
return
|
|
}
|
|
|
|
rollTarget.magicUser = this.system.biodata?.magicUser || false
|
|
rollTarget.actorModifiers = this.system.modifiers ? foundry.utils.duplicate(this.system.modifiers) : {}
|
|
rollTarget.actorLevel = this.system.biodata?.level || 1
|
|
await this.system.roll(rollType, rollTarget)
|
|
}
|
|
|
|
}
|