122 lines
4.2 KiB
JavaScript
122 lines
4.2 KiB
JavaScript
import { Grammar } from "../grammar.js"
|
|
import { RdDBonus } from "../rdd-bonus.js"
|
|
import { StatusEffects } from "../settings/status-effects.js"
|
|
import { ROLL_MODE_ATTAQUE } from "./roll-constants.mjs"
|
|
import { PART_CARAC } from "./roll-part-carac.mjs"
|
|
import { PART_COMP } from "./roll-part-comp.mjs"
|
|
import { RollPartSelect } from "./roll-part-select.mjs"
|
|
import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
|
|
|
|
export const PART_ATTAQUE = 'attaque'
|
|
|
|
const TACTIQUES = [
|
|
{ key: "", label: "Attaque normale" },
|
|
{ key: "charge", label: "Charge" },
|
|
{ key: "feinte", label: "Feinte" },
|
|
]
|
|
|
|
export class RollPartAttaque extends RollPartSelect {
|
|
|
|
get code() { return PART_ATTAQUE }
|
|
get section() { return ROLLDIALOG_SECTION.CHOIX }
|
|
|
|
visible(rollData) { return this.isRollMode(rollData, ROLL_MODE_ATTAQUE) }
|
|
|
|
loadRefs(rollData) {
|
|
const refs = this.getRefs(rollData)
|
|
const attaques = rollData.active.actor.listAttaques()
|
|
refs.attaques = attaques.map(it => RollPartAttaque.$extractAttaque(it, rollData.active.actor))
|
|
refs.tactiques = TACTIQUES
|
|
if (refs.attaques.length > 0) {
|
|
this.$selectAttaque(rollData)
|
|
}
|
|
}
|
|
|
|
choices(refs) { return refs.attaques }
|
|
|
|
static $extractAttaque(action, actor) {
|
|
return {
|
|
key: `${action.action}::${action.name}`,
|
|
label: action.name,
|
|
action: action,
|
|
tactique: "",
|
|
arme: action.arme,
|
|
comp: action.comp,
|
|
}
|
|
}
|
|
|
|
prepareContext(rollData) {
|
|
const current = this.getCurrent(rollData)
|
|
const defenseurSurpris = rollData.opponent?.actor?.getSurprise(true) ?? ''
|
|
current.defenseur = defenseurSurpris
|
|
? {
|
|
surprise: RdDBonus.find(defenseurSurpris),
|
|
effects: rollData.opponent.actor.getEffects(it => StatusEffects.niveauSurprise(it, true) > 0)
|
|
}
|
|
: undefined
|
|
current.dmg = this.dmgRollV2(rollData, current)
|
|
}
|
|
|
|
dmgRollV2(rollData, current) {
|
|
const actor = rollData.active.actor
|
|
const defender = rollData.opponent.actor
|
|
const dmgArme = RdDBonus.dmgArme(current.arme, current.action.dommagesArme)
|
|
const dmg = {
|
|
total: 0,
|
|
dmgArme: dmgArme,
|
|
penetration: current.arme.penetration(),
|
|
dmgTactique: RdDBonus.dmgBonus(current.tactique),
|
|
dmgParticuliere: 0, // TODO RdDBonus._dmgParticuliere(rollData),
|
|
dmgSurprise: RdDBonus.dmgBonus(current.defenseur.surprise),
|
|
mortalite: RdDBonus.mortalite(current.dmg?.mortalite, current.arme.system.mortalite, defender?.isEntite()),
|
|
dmgActor: RdDBonus.bonusDmg(actor, current.action.carac.key, dmgArme)
|
|
}
|
|
dmg.total = dmg.dmgSurprise + dmg.dmgTactique + dmg.dmgArme + dmg.dmgActor + dmg.dmgParticuliere
|
|
return dmg;
|
|
}
|
|
|
|
$selectAttaque(rollData, key) {
|
|
this.selectByKey(rollData, key, 0)
|
|
}
|
|
|
|
async _onRender(rollDialog, context, options) {
|
|
const selectAttaque = rollDialog.element.querySelector(`roll-section[name="${this.code}"] select[name="select-attaque"]`)
|
|
const selectTactique = rollDialog.element.querySelector(`roll-section[name="${this.code}"] select[name="select-tactique"]`)
|
|
const checkMortalite = rollDialog.element.querySelector(`roll-section[name="${this.code}"] input[name="check-mortalite"]`)
|
|
const current = this.getCurrent(rollDialog.rollData)
|
|
|
|
selectAttaque.addEventListener("change", e => {
|
|
const selectOptions = e.currentTarget.options
|
|
const index = selectOptions.selectedIndex
|
|
this.$selectAttaque(rollDialog.rollData, selectOptions[index]?.value)
|
|
rollDialog.setModeTitle()
|
|
rollDialog.render()
|
|
})
|
|
|
|
selectTactique.addEventListener("change", e => {
|
|
const selectOptions = e.currentTarget.options
|
|
const index = selectOptions.selectedIndex
|
|
current.tactique = TACTIQUES[index].key
|
|
rollDialog.render()
|
|
})
|
|
|
|
checkMortalite?.addEventListener("change", e => {
|
|
current.dmg.mortalite = (e.currentTarget.checked ? 'mortel' : 'non-mortel')
|
|
rollDialog.render()
|
|
})
|
|
}
|
|
|
|
getExternalPartsFilter(partCode, rollData) {
|
|
if (this.visible(rollData)) {
|
|
const current = this.getCurrent(rollData)
|
|
switch (partCode) {
|
|
case PART_CARAC: return p => Grammar.equalsInsensitive(current.action.carac.key, p.key)
|
|
case PART_COMP: return p => p.label == current.comp?.name
|
|
}
|
|
}
|
|
return undefined
|
|
}
|
|
|
|
|
|
}
|