303 lines
11 KiB
JavaScript
303 lines
11 KiB
JavaScript
import {ActionManager} from "../sheets/actions/action-manager.mjs";
|
|
|
|
const {ApplicationV2, HandlebarsApplicationMixin} = foundry.applications.api
|
|
|
|
|
|
/**
|
|
* @typedef TokenDistance
|
|
* @property {Number} x
|
|
* @property {Number} y
|
|
* @property {Number} d
|
|
* @property {Token} token
|
|
*/
|
|
|
|
export class DefenseActionDialog extends HandlebarsApplicationMixin(ApplicationV2) {
|
|
|
|
static DEFAULT_OPTIONS = {
|
|
classes: ['dsa41', 'dialog', 'combat'],
|
|
tag: "form",
|
|
position: {
|
|
width: 480,
|
|
height: 640
|
|
},
|
|
window: {
|
|
resizable: false,
|
|
},
|
|
form: {
|
|
submitOnChange: false,
|
|
closeOnSubmit: true,
|
|
handler: DefenseActionDialog.#onSubmitForm
|
|
},
|
|
actions: {
|
|
selectWeaponAndSkill: DefenseActionDialog.#onSelectWeaponAndSkill,
|
|
selectManeuver: DefenseActionDialog.#onSelectManeuver,
|
|
}
|
|
}
|
|
|
|
static PARTS = {
|
|
form: {
|
|
template: 'systems/DSA_4-1/templates/dialog/defense-action.hbs',
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @type {Actor}
|
|
* @private
|
|
*/
|
|
_actor = null
|
|
|
|
constructor(actor, attackData) {
|
|
super();
|
|
this._attackData = attackData ?? {
|
|
modToDefense: 0,
|
|
attacker: null,
|
|
weapon: null, // is important to note as weapons like Chain Weapons or Flails can ignore Shields
|
|
}
|
|
this._actor = actor
|
|
this._skillId = null
|
|
this._weaponId = null
|
|
this._defenseManeuverId = null
|
|
this._actionManager = new ActionManager(this._actor)
|
|
//if (this._actor) {
|
|
// this._actor.prepareDerivedData()
|
|
//}
|
|
}
|
|
|
|
|
|
static async #onSelectTarget(event, target) {
|
|
const {targetId} = target.dataset
|
|
this._targetId = this._targetId === targetId ? null : targetId
|
|
this.render({parts: ["form"]})
|
|
}
|
|
|
|
static async #onSelectManeuver(event, target) {
|
|
const {maneuverId} = target.dataset
|
|
this._defenseManeuverId = this._defenseManeuverId === maneuverId ? null : maneuverId
|
|
this.render({parts: ["form"]})
|
|
}
|
|
|
|
|
|
static async #onSelectWeaponAndSkill(event, target) {
|
|
const {weaponId, skillId} = target.dataset
|
|
this._weaponId = this._weaponId === weaponId ? null : weaponId
|
|
this._skillId = this._skillId === skillId ? null : skillId
|
|
this.render({parts: ["form"]})
|
|
}
|
|
|
|
static async #onSubmitForm(event, form, formData) {
|
|
event.preventDefault()
|
|
const attack = this._attackData
|
|
const maneuver = this.#evaluateManeuvers().find(p => p.id === this._defenseManeuverId)
|
|
this._actor.rollDefense({
|
|
weapon: this._weaponId,
|
|
skill: this._skillId,
|
|
attackData: attack,
|
|
maneuver,
|
|
mod: this._mod,
|
|
circumstance: this._circumstance,
|
|
penalty: this._penalty,
|
|
targetNumber: this._targetNumber,
|
|
modDescription: maneuver?.modDescription?.replace("{}", "" + this._mod) ?? ""
|
|
})
|
|
}
|
|
|
|
_configureRenderOptions(options) {
|
|
super._configureRenderOptions(options)
|
|
|
|
if (options.window) {
|
|
options.window.title = `Gegen einen Angriff verteidigen`
|
|
}
|
|
return options
|
|
}
|
|
|
|
#evaluateWeapons() {
|
|
|
|
// get equipped weapons and adjust AT/PA values by basis values from actor TODO: and W/M of weapons
|
|
const equips = this._actor.system.heldenausruestung[this._actor.system.setEquipped]
|
|
const weapons = []
|
|
|
|
const equippedWeapons = ["links", "rechts", "fernkampf"]
|
|
|
|
const baseAt = {
|
|
links: this._actor.system.at.links.aktuell, // TODO hook Beidhändigerkampf/linkhand
|
|
rechts: this._actor.system.at.rechts.aktuell,
|
|
fernkampf: this._actor.system.fk.aktuell,
|
|
}
|
|
const basePa = {
|
|
links: this._actor.system.pa.links.aktuell, // TODO hook Beidhändigerkampf/linkhand
|
|
rechts: this._actor.system.pa.rechts.aktuell,
|
|
fernkampf: 0,
|
|
}
|
|
|
|
equippedWeapons.forEach(slot => {
|
|
const equip = equips[slot]
|
|
const weapon = this._actor.itemTypes["Equipment"].find(p => p._id === equip)
|
|
if (weapon) {
|
|
|
|
const variantWeaponSkills = [...weapon.system.rangedSkills, ...weapon.system.meleeSkills]
|
|
|
|
variantWeaponSkills.forEach(weaponSkill => {
|
|
|
|
const skill = this._actor.itemTypes["Skill"].find(p => p.name === weaponSkill)
|
|
if (skill) {
|
|
|
|
const skillAt = skill.system.at
|
|
const skillPa = skill.system.pa
|
|
|
|
weapons.push({
|
|
isSelected: this._skillId === skill._id && this._weaponId === weapon._id,
|
|
weaponId: weapon._id,
|
|
skillId: skill._id,
|
|
name: weapon.name,
|
|
skillName: skill.name,
|
|
img: weapon.img,
|
|
combatStatistics: {
|
|
at: baseAt[slot] + weapon.system.attackModifier + skillAt,
|
|
pa: basePa[slot] + weapon.system.parryModifier + skillPa
|
|
}
|
|
})
|
|
}
|
|
})
|
|
}
|
|
})
|
|
// TODO: also do this for combatAction
|
|
const links = this._actor.system.heldenausruestung[this._actor.system.setEquipped].links
|
|
const rechts = this._actor.system.heldenausruestung[this._actor.system.setEquipped].rechts
|
|
if (!links && !rechts) {
|
|
const unarmedSkills = [this._actor.itemTypes["Skill"].find(p => p.name === "Ringen"), this._actor.itemTypes["Skill"].find(p => p.name === "Raufen")]
|
|
|
|
unarmedSkills.forEach(unarmedSkill => {
|
|
const [skillAt, skillPa] = [unarmedSkill.system.at, unarmedSkill.system.pa]
|
|
|
|
weapons.push({
|
|
isSelected: this._skillId === unarmedSkill._id,
|
|
weaponId: "",
|
|
skillId: unarmedSkill._id,
|
|
name: unarmedSkill.name,
|
|
skillName: unarmedSkill.name,
|
|
img: "",
|
|
combatStatistics: {
|
|
at: baseAt["rechts"] + skillAt,
|
|
pa: basePa["rechts"] + skillPa
|
|
}
|
|
})
|
|
})
|
|
}
|
|
// Ausweichen as Weapon
|
|
weapons.push({
|
|
isSelected: this._weaponId === "Ausweichen",
|
|
weaponId: "Ausweichen",
|
|
skillId: "Ausweichen",
|
|
name: "Ausweichen",
|
|
skillName: "Ausweichen",
|
|
img: "",
|
|
combatStatistics: {
|
|
at: 0,
|
|
pa: this._actor.system.ausweichen.aktuell
|
|
}
|
|
})
|
|
|
|
this._weapons = weapons.sort((a, b) => (a.isSelected ? 0 : 1) - (b.isSelected ? 0 : 1))
|
|
return this._weapons
|
|
|
|
}
|
|
|
|
#evaluateManeuvers() {
|
|
const manager = this._actionManager
|
|
const weapon = this._weaponId !== "Ausweichen" ? this._actor.itemTypes["Equipment"].find(p => p._id === this._weaponId) : "Ausweichen"
|
|
const skill = this._actor.itemTypes["Skill"].find(p => p._id === this._skillId)
|
|
//const target = game.actors.get(game.scenes.current.tokens.find(p => p._id === this._targetId).actorId)
|
|
this._maneuvers = manager.evaluate({
|
|
//target,
|
|
weapon,
|
|
skill
|
|
}).filter(p => p.type === ActionManager.DEFENSE).map(action => {
|
|
return {
|
|
isSelected: this._defenseManeuverId === action.name,
|
|
id: action.name,
|
|
name: action.name,
|
|
type: action.type,
|
|
source: action.source,
|
|
cost: action.cost,
|
|
penalty: action.eval?.mod ?? 0,
|
|
mod: action.mod,
|
|
modDescription: action.modDescription,
|
|
cooldown: action.cooldown,
|
|
activate: action.activate,
|
|
}
|
|
}).sort((a, b) => (a.isSelected ? 0 : 1) - (b.isSelected ? 0 : 1))
|
|
return this._maneuvers
|
|
}
|
|
|
|
async _prepareContext(options) {
|
|
const context = await super._prepareContext(options)
|
|
|
|
context.actor = this._actor
|
|
context.distanceUnit = game.scenes.current.grid.units
|
|
|
|
if (this._actor.getActiveTokens()[0]?.id) {
|
|
|
|
context.weapons = this.#evaluateWeapons()
|
|
|
|
if (this._skillId) {
|
|
context.maneuver = this.#evaluateManeuvers()
|
|
}
|
|
const maneuver = this._maneuvers?.find(p => p.id === this._defenseManeuverId)
|
|
if (maneuver) {
|
|
context.canMod = maneuver.mod != undefined
|
|
}
|
|
|
|
context.targetNumber = context.weapons.find(p => ((this._weaponId != "") || p.weaponId === this._weaponId) && p.skillId === this._skillId)?.combatStatistics.pa
|
|
|
|
// TODO get W/M of weapon NOW
|
|
|
|
context.ready = this._targetId && this._weaponId && this._skillId && this._defenseManeuverId
|
|
return context
|
|
} else {
|
|
ui.notifications.error(`Feature funktioniert nur wenn der Akteur ein Token auf der aktuellen Szene hat`);
|
|
}
|
|
|
|
}
|
|
|
|
#update(context) {
|
|
const target = this.element.querySelector(".actions button .value")
|
|
const targetDescription = this.element.querySelector(".modResult")
|
|
const at = Number(context.targetNumber)
|
|
const maneuver = this._maneuvers?.find(p => p.id === this._defenseManeuverId)
|
|
const mod = Number(this.element.querySelector('[name="mod"]').value)
|
|
const penalty = 0 - (maneuver?.penalty ?? 0) + (maneuver?.mod?.(mod) ?? 0) ?? 0
|
|
const circumstance = Number(this.element.querySelector('[name="circumstance"]').value)
|
|
this.element.querySelector('[name="penalty"]').value = penalty + circumstance
|
|
const result = (at + circumstance + penalty)
|
|
|
|
this._circumstance = circumstance
|
|
this._penalty = penalty
|
|
this._targetNumber = result
|
|
this._mod = mod
|
|
this._modDescription = maneuver?.modDescription?.replace("{}", "" + mod) ?? ""
|
|
|
|
target.textContent = `(${result})`
|
|
targetDescription.textContent = this._modDescription
|
|
|
|
if (result <= 0) {
|
|
context.ready = false
|
|
this.element.querySelector(".actions button").classList.remove("ready")
|
|
this.element.querySelector(".actions button").setAttribute("disabled", true)
|
|
} else {
|
|
context.ready = true
|
|
this.element.querySelector(".actions button").classList.add("ready")
|
|
this.element.querySelector(".actions button").removeAttribute("disabled")
|
|
}
|
|
}
|
|
|
|
_onRender(context, options) {
|
|
this.#update(context)
|
|
|
|
this.element.querySelectorAll('[name="mod"], [name="malus"], [name="circumstance"]').forEach(e => e.addEventListener('change', (event) => {
|
|
this.#update(context)
|
|
}))
|
|
|
|
}
|
|
|
|
|
|
} |