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

import { RdDBonus } from "../rdd-bonus.js"
import { DIFF, ROLL_TYPE_ATTAQUE } from "./roll-constants.mjs"
import { PART_CARAC } from "./roll-part-carac.mjs"
import { PART_COMP } from "./roll-part-comp.mjs"
import { PART_DIFF } from "./roll-part-diff.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.isRollType(rollData, ROLL_TYPE_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) {
      const attaque = this.findAttaque(refs.attaques, this.getSaved(rollData))
      this.$selectAttaque(rollData, attaque?.key)
    }
  }

  store(rollData, targetData) {
    super.store(rollData, targetData)
    this.getSaved(targetData).dmg = this.getCurrent(rollData).dmg
  }

  restore(rollData) {
    const saved = this.getSaved(rollData)
    super.restore(rollData)
    if (saved.dmg) {
      this.getCurrent(rollData).dmg = this.getSaved(rollData).dmg
    }
  }

  findAttaque(attaques, saved) {
    return attaques.find(at => at.arme.id == saved?.arme?.id &&
      at.comp.id == saved?.comp?.id
    )
  }

  choices(refs) { return refs.attaques }

  static $extractAttaque(attaque, actor) {
    // const extracted = foundry.utils.mergeObject({
    //   key: `${attaque.action}::${attaque.label}`,
    //   tactique: TACTIQUES[0]
    // },
    //   attaque
    // )
    // return extracted
    // extracted.initialDiff = attaque.comp?.system.default_diffLibre ?? 0
    attaque.key = `${attaque.action}::${attaque.label}`
    attaque.tactique = TACTIQUES[0]
    attaque.initialDiff = attaque.comp?.system.default_diffLibre ?? 0
    return attaque
  }

  prepareContext(rollData) {
    const current = this.getCurrent(rollData)
    current.dmg = RdDBonus.dmgRollV2(rollData, current)
  }

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


  $selectAttaque(rollData, key) {
    this.selectByKey(rollData, key)
  }

  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.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()
    })
  }

  impactOtherPart(part, rollData) {
    if (this.visible(rollData)) {
      const current = this.getCurrent(rollData)
      switch (part.code) {
        case PART_CARAC: return part.filterCaracs(rollData, [current.carac.key])
        case PART_COMP: return part.filterComps(rollData, [current.comp.name])
        case PART_DIFF: {
          if (current.initialDiff) {
            part.setDiff(rollData, { type: DIFF.ATTAQUE, value: current.initialDiff })
            current.initialDiff = undefined
          }
        }
      }
    }
    return undefined
  }
}