foundryvtt-reve-de-dragon/module/rdd-roll.js

import { HtmlUtility } from "./html-utility.js";
import { RdDItemCompetence } from "./item-competence.js";
import { RdDItemSort } from "./item-sort.js";
import { Misc } from "./misc.js";
import { RdDBonus } from "./rdd-bonus.js";
import { RdDResolutionTable } from "./rdd-resolution-table.js";

/**
 * Extend the base Dialog entity to select roll parameters
 * @extends {Dialog}
 */
/* -------------------------------------------- */
export class RdDRoll extends Dialog {

  /* -------------------------------------------- */
  static async create(actor, rollData, dialogConfig, ...actions) {

    RdDRoll._ensureCorrectActions(actions);
    RdDRoll._setDefaultOptions(actor, rollData);

    const html = await renderTemplate(dialogConfig.html, rollData);

    let options = { classes: ["rdddialog"], width: 600, height: 500, 'z-index': 99999 };
    if (dialogConfig.options) {
      mergeObject(options, dialogConfig.options, { overwrite: true })
    }
    return new RdDRoll(actor, rollData, html, options, actions, dialogConfig.close );
  }

  /* -------------------------------------------- */
  static _setDefaultOptions(actor, rollData) {

    let defaultRollData = {
      ajustementsConditions: CONFIG.RDD.ajustementsConditions,
      difficultesLibres: CONFIG.RDD.difficultesLibres,
      etat: actor.data.data.compteurs.etat.value,
      moral: actor.isPersonnage() ? actor.data.data.compteurs.moral.value : 0,
      carac: actor.data.data.carac,
      finalLevel: 0,
      diffConditions: rollData.arme ? RdDBonus.bonusAttaque(rollData.surpriseDefenseur) :0,
      diffLibre: 0,
      editLibre: true,
      editConditions: true,
      forceValue: actor.getForceValue(),
      malusArmureValue: (actor.isPersonnage() && actor.data.data.attributs && actor.data.data.attributs.malusarmure) ? actor.data.data.attributs.malusarmure.value : 0,
      surencMalusFlag: actor.isPersonnage() ? (actor.data.data.compteurs.surenc.value < 0) : false,
      surencMalusValue: actor.isPersonnage() ? actor.data.data.compteurs.surenc.value : 0,
      surencMalusApply: false,
      isMalusEncombrementTotal: RdDItemCompetence.isMalusEncombrementTotal(rollData.competence),
      useMalusEncTotal: false,
      encTotal: actor.getEncombrementTotal(),
      ajustementAstrologique: actor.ajustementAstrologique()
    }
    mergeObject(rollData, defaultRollData, { overwrite: false });
  }

  /* -------------------------------------------- */
  static _ensureCorrectActions(actions) {
    if (actions.length == 0) {
      throw 'No action defined';
    }
    actions.forEach(action => {
      if (action.callbacks == undefined) {
        action.callbacks = [{ action: r => console.log(action.name, r) }];
      }
    });
  }

  /* -------------------------------------------- */
  constructor(actor, rollData, html, options, actions, close = undefined) {
    let conf = {
      title: actions[0].label,
      content: html,
      buttons: {},
      default: actions[0].name,
      close: close
    };
    for (let action of actions) {
      conf.buttons[action.name] = { label: action.label, callback: html => this.onAction(action, html) };
    }

    super(conf, options);

    this.actor = actor;
    this.rollData = rollData;
  }

  /* -------------------------------------------- */
  async onAction(action, html) {
    await RdDResolutionTable.rollData(this.rollData);
    console.log("RdDRoll -=>", this.rollData, this.rollData.rolled);

    if (action.callbacks)
      for (let callback of action.callbacks) {
        if (callback.condition == undefined || callback.condition(this.rollData)) {
          callback.action(this.rollData);
        }
      }
  }

  /* -------------------------------------------- */
  activateListeners(html) {
    super.activateListeners(html);

    this.bringToTop();

    var rollData = this.rollData;
    var actor = this.actor;
    var dialog = this;

    function updateRollResult(rollData) {
      let caracValue = parseInt(rollData.selectedCarac.value)
      let rollLevel = dialog._computeFinalLevel(rollData);
      rollData.dmg = rollData.attackerRoll ? rollData.attackerRoll.dmg : RdDBonus.dmg(rollData, actor.getBonusDegat());
      rollData.finalLevel = rollLevel;
      rollData.caracValue = caracValue;
      rollData.coupsNonMortels = (rollData.attackerRoll ? rollData.attackerRoll.dmg.mortalite : rollData.dmg.mortalite) == 'non-mortel';
      let dmgText = Misc.toSignedString(rollData.dmg.total);
      if (rollData.coupsNonMortels) {
        dmgText = '(' + dmgText + ')';
      }

      HtmlUtility._showControlWhen($(".diffMoral"), rollData.selectedCarac == actor.data.data.carac.volonte);
      HtmlUtility._showControlWhen($(".etat-general"), !dialog._isIgnoreEtatGeneral(rollData));

      // Sort management
      if (rollData.selectedSort) {
        rollData.bonus = RdDItemSort.getCaseBonus(rollData.selectedSort, rollData.coord),
        //console.log("Toggle show/hide", rollData.selectedSort);
        HtmlUtility._showControlWhen($("#div-sort-difficulte"), RdDItemSort.isDifficulteVariable(rollData.selectedSort))
        HtmlUtility._showControlWhen($("#div-sort-ptreve"), RdDItemSort.isCoutVariable(rollData.selectedSort))
      }

      // Mise à jour valeurs
      $("#roll-param").text(rollData.selectedCarac.value + " / " + Misc.toSignedString(rollData.finalLevel));
      $("#compdialogTitle").text(dialog._getTitle(rollData));
      $('#coupsNonMortels').prop('checked', rollData.coupsNonMortels);
      $("#dmg-arme-actor").text(dmgText);
      $("#defenseur-surprise").text(RdDBonus.description(rollData.surpriseDefenseur));
      $(".table-resolution").remove();
      $("#resolutionTable").append(RdDResolutionTable.buildHTMLTableExtract(caracValue, rollLevel));
      $(".span-valeur").remove();
      $("#resolutionValeurs").append(RdDResolutionTable.buildHTMLResults(caracValue, rollLevel));
    }

    // Setup everything onload
    $(function () {
      // Update html, according to data
      if (rollData.competence) {
        // Set the default carac from the competence item
        rollData.selectedCarac = rollData.carac[rollData.competence.data.defaut_carac];
        $("#carac").val(rollData.competence.data.defaut_carac);
      }
      RdDItemSort.setCoutReveReel(rollData.selectedSort);
      $("#diffLibre").val(Misc.toInt(rollData.diffLibre));
      $("#diffConditions").val(Misc.toInt(rollData.diffConditions));
      updateRollResult(rollData);
    });

    // Update !
    html.find('#diffLibre').change((event) => {
      rollData.diffLibre = Misc.toInt(event.currentTarget.value); // Update the selected bonus/malus
      //console.log("RdDRollSelectDialog","BM CLICKED !!!", rollData);
      updateRollResult(rollData);
    });
    html.find('#diffConditions').change((event) => {
      rollData.diffConditions = Misc.toInt(event.currentTarget.value); // Update the selected bonus/malus
      //console.log("RdDRollSelectDialog","BM CLICKED !!!", rollData);
      updateRollResult(rollData);
    });
    html.find('#carac').change((event) => {
      let caracKey = event.currentTarget.value;
      this.rollData.selectedCarac = rollData.carac[caracKey]; // Update the selectedCarac
      //console.log("RdDRollSelectDialog","CARAC CLICKED !!!", rollData);
      updateRollResult(rollData);
    });
    html.find('#draconic').change((event) => {
      let draconicKey = Misc.toInt(event.currentTarget.value);
      this.rollData.selectedDraconic = rollData.draconicList[draconicKey]; // Update the selectedCarac
      //console.log("RdDRollSelectDialog","CARAC CLICKED !!!", rollData);
      updateRollResult(rollData);
    });
    html.find('#sort').change((event) => {
      let sortKey = Misc.toInt(event.currentTarget.value);
      this.rollData.selectedSort = rollData.sortList[sortKey]; // Update the selectedCarac
      this.rollData.bonus = RdDItemSort.getCaseBonus(rollData.selectedSort, rollData.coord);
      RdDItemSort.setCoutReveReel(rollData.selectedSort);
      //console.log("RdDRollSelectDialog - Sort selection", rollData.selectedSort);
      updateRollResult(rollData);
    });
    html.find('#ptreve-variable').change((event) => {
      let ptreve = Misc.toInt(event.currentTarget.value);
      this.rollData.selectedSort.data.ptreve_reel = ptreve;
      console.log("RdDRollSelectDialog - Cout reve", ptreve);
      updateRollResult(rollData);
    });
    html.find('#ptreve-variable').change((event) => {
      let ptreve = Misc.toInt(event.currentTarget.value);
      this.rollData.selectedSort.data.ptreve_reel = ptreve; // Update the selectedCarac
      console.log("RdDRollSelectDialog - Cout reve", ptreve);
      updateRollResult(rollData);
    });
    html.find('#coupsNonMortels').change((event) => {
      this.rollData.dmg.mortalite = event.currentTarget.checked ? "non-mortel" : "mortel";
      updateRollResult(rollData);
    });
    html.find('#tactique-combat').change((event) => {
      this.rollData.tactique = event.currentTarget.value;
      updateRollResult(rollData);
    });
    html.find('#surencMalusApply').change((event) => {
      this.rollData.surencMalusApply = event.currentTarget.checked;
      updateRollResult(rollData);
    });
    html.find('#useMalusEncTotal').change((event) => {
      this.rollData.useMalusEncTotal = event.currentTarget.checked;
      updateRollResult(rollData);
    });
  }

  _isIgnoreEtatGeneral(rollData) {
    return rollData.selectedCarac.ignoreEtatGeneral;
  }

  /* -------------------------------------------- */
  _computeFinalLevel(rollData) {
    const etat = this._isIgnoreEtatGeneral(rollData) ? 0 : Misc.toInt(rollData.etat);
    const diffConditions = Misc.toInt(rollData.diffConditions);
    const malusEnc = (rollData.surencMalusApply) ? rollData.surencMalusValue : 0;
    const bonusTactique = RdDBonus.bonusAttaque(rollData.tactique);
    const malusEncTotal = (rollData.useMalusEncTotal) ? -rollData.encTotal : 0;
    const ajustementChance = rollData.selectedCarac.label.toLowerCase().includes('chance') ? rollData.ajustementAstrologique : 0;
    // Gestion malus armure
    const malusArmureValue = this._computeMalusArmure(rollData);

    const diffLibre = this._computeDiffLibre(rollData);
    const diffCompetence = this._computeDiffCompetence(rollData);
    const diffMoral = rollData.selectedCarac == this.actor.data.data.carac.volonte ? rollData.moral : 0;

    return etat + diffCompetence + diffLibre + diffMoral + diffConditions + malusEnc + malusEncTotal + malusArmureValue + ajustementChance + bonusTactique;
  }

  _computeDiffCompetence(rollData) {
    if (rollData.competence) {
      return Misc.toInt(rollData.competence.data.niveau);
    }
    if (rollData.draconicList) {
      return Misc.toInt(rollData.selectedDraconic.data.niveau);
    }
    return 0;
  }

  _computeDiffLibre(rollData) {
    let diffLibre = Misc.toInt(rollData.diffLibre);
    if (rollData.draconicList && rollData.selectedSort) {
      return RdDItemSort.getDifficulte(rollData.selectedSort, diffLibre);
    }
    return diffLibre;
  }

  _computeMalusArmure(rollData) {
    let malusArmureValue = 0;
    if (rollData.malusArmureValue != 0 && (rollData.selectedCarac.label == "Agilité" || rollData.selectedCarac.label == "Dérobée")) {
      $("#addon-message").text("Malus armure appliqué : " + rollData.malusArmureValue);
      malusArmureValue = rollData.malusArmureValue;
    } else {
      $("#addon-message").text("");
    }
    return malusArmureValue;
  }

  /* -------------------------------------------- */
  _getTitle(rollData) {
    if (rollData.competence) {
      // If a weapon is there, add it in the title
      let armeTitle = (rollData.arme) ? " (" + rollData.arme.name + ") " : "";
      let niveau = Misc.toSignedString(rollData.competence.data.niveau);
      return rollData.selectedCarac.label + "/" + rollData.competence.name + armeTitle + " " + niveau
    }
    if (rollData.draconicList) {
      return rollData.selectedDraconic.name + " - " + rollData.selectedSort.name;
    }
    return rollData.selectedCarac.label;
  }
}