foundryvtt-reve-de-dragon/module/roll/roll-part-attaque.mjs

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 } from "./roll-part.mjs"

export const PART_ATTAQUE = 'attaque'

const TACTIQUES = RdDBonus.tactiques.filter(it => it.isTactique)

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: TACTIQUES[0],
      arme: action.arme,
      comp: action.comp,
    }
  }

  prepareContext(rollData) {
    const current = this.getCurrent(rollData)
    const effetsSurprise = rollData.opponent?.actor?.getEffects(it => StatusEffects.niveauSurprise(it, true) > 0) ?? []
    current.defenseur = effetsSurprise
      ? {
        surprise: RdDBonus.find(rollData.opponent?.actor?.getSurprise(true)),
        effects: effetsSurprise
      }
      : undefined
    current.dmg = this.dmgRollV2(rollData, current)
  }

  getAjustements(rollData) {
    const current = this.getCurrent(rollData)
    const tactique = current.tactique
    const surprise = current.defenseur?.surprise
    const ajustements = []
    if (tactique) {
      ajustements.push({ label: tactique.label, diff: tactique.attaque })
    }
    if (surprise) {
      ajustements.push({ label: surprise.label, diff: surprise.attaque })
    }
    return ajustements
  }


  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: current.tactique?.dmg ?? 0,
      dmgParticuliere: 0, // TODO RdDBonus._dmgParticuliere(rollData),
      dmgSurprise: current.defenseur?.surprise.dmg,
      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 = RdDBonus.find(selectOptions[index]?.value)
      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
  }


}