foundryvtt-reve-de-dragon/module/roll/roll-basic-parts.mjs

import { ActorToken } from "../actor-token.mjs"
import { StatusEffects } from "../settings/status-effects.js"
import { ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE } from "./roll-constants.mjs"
import { PART_ATTAQUE } from "./roll-part-attaque.mjs"
import { PART_DEFENSE } from "./roll-part-defense.mjs"

export class RollBasicParts {

  restore(rollData) {
    rollData.ids.sceneId = rollData.ids.sceneId ?? canvas.scene.id
    rollData.active = RollBasicParts.$getActor(rollData)
    rollData.opponent = RollBasicParts.$getOpponent(rollData)
    if (rollData.type.opposed == undefined) {
      rollData.type.opposed = rollData.opponent != null
    }
  }

  loadSurprises(rollData, type) {
    if (!rollData.type.passif) {
      this.loadSurprise(rollData.active, this.getForceRequiseActiveActor(rollData, type))
      this.loadSurprise(rollData.opponent, 0)
    }
  }

  loadSurprise(who, forceRequise) {
    if (who?.actor) {
      foundry.utils.mergeObject(who,
        StatusEffects.getActorEffetSurprise(who.actor, forceRequise),
        { overwrite: true, inPlace: true })
    }
  }

  getForceRequiseActiveActor(rollData, type) {
    switch (type) {
      case ROLL_TYPE_ATTAQUE: return rollData.current[PART_ATTAQUE].attaque.forceRequise
      case ROLL_TYPE_DEFENSE: return rollData.current[PART_DEFENSE].forceRequise
      default: return 0
    }
  }

  initFrom(rollData) {
    return {
      selected: {},
      type: rollData.type,
      ids: {
        sceneId: rollData.ids.sceneId,
        actorId: rollData.active.id,
        actorTokenId: rollData.active.tokenId,
        opponentId: rollData.type.opposed ? rollData.opponent.id : undefined,
        opponentTokenId: rollData.type.opposed ? rollData.opponent.tokenId : undefined,
      }
    }
  }

  static $getActor(rollData) {
    if (rollData.ids.actorTokenId) {
      return ActorToken.fromTokenId(rollData.ids.actorTokenId, rollData.ids.sceneId)
    }
    else {
      const actorId = rollData.ids.actorId ?? (canvas.tokens.controlled.length == 1
        /** TODO: jets de plusieurs personnages??? */
        ? canvas.tokens.controlled[0]
        : undefined)
      return ActorToken.fromActorId(actorId, () => { throw new Error("Pas d'acteur sélectionné") })
    }
  }

  static $getOpponent(rollData) {
    if (rollData.ids.opponentTokenId) {
      return ActorToken.fromTokenId(rollData.ids.opponentTokenId, rollData.ids.sceneId)
    }
    else if (rollData.ids.opponentId) {
      return ActorToken.fromActorId(rollData.ids.opponentId)
    }
    else {
      const targets = Array.from(game.user.targets)
      if (targets.length == 1) {
        return ActorToken.fromToken(targets[0])
      }
      else {
        return undefined
      }
    }
  }
}