reroll OK

2024-04-28 16:35:48 +02:00
parent 74e11d439c
commit 0fada335f4
85 changed files with 1273 additions and 435 deletions
@@ -1,20 +1,180 @@
 export class VermineUtils {
+  /**
+   * Méthode pour effectuer un jet de dés avec différentes options
+   * @param {Object} options - Les options du jet de dés
+   * @returns {Roll} - Le résultat du jet de dés
+   */
+  static async roll({ actor, NoD, Reroll = 0, difficulty = 7, self_control = 0, rollLabel = "jet custom", totems = { human: false, adapted: false }, max_effort = 0 }) {
+    // Déclaration des variables
+    let formula = "";
+    let modFormula = null;

-  static roll(actorId, label, NoD, Reroll = 0, params = {}) {
-    const actor = game.actors.get(actorId);
-    let formula = '' + NoD + "d10";
+    // Vérification des totems humains
+    if (totems.human) {
+      NoD--;
+      modFormula = "(1D10cs>=" + difficulty + `[human_${game.user.name}]*2)`;
+      await actor.update({
+        "system.adaptation.totems.human.value": actor.system.adaptation.totems.human.value - 1
+      })
+    }
+    // Vérification des totems adaptés
+    if (totems.adapted) {
+      NoD--;
+      // Construction de la formule modifiée
+      if (modFormula != null) {
+        modFormula = modFormula + "+(1D10cs>=" + difficulty + `[adapted_${game.user.name}]*2)`;
+      } else {
+        modFormula = "(1D10cs>=" + difficulty + `[adapted_${game.user.name}]*2)`;
+      }
+      await actor.update({
+        "system.adaptation.totems.adapted.value": actor.system.adaptation.totems.adapted.value - 1
+      })
+    };

-    formula += (params.difficulty != undefined) ? "cs>=" + params.difficulty : "cs>=7";
+    // Construction de la formule de base
+    let baseFormula = '' + NoD + "d10";
+    baseFormula += (difficulty != undefined) ? "cs>=" + difficulty : "cs>=7";
+    baseFormula += `[regular_${game.user.name}]`
+
+    // Construction de la formule finale
+    if (modFormula != null) {
+      formula = baseFormula + "+" + modFormula;
+    } else { formula = baseFormula }
+
+    // Création du jet de dés
    let roll = new Roll(formula, actor.getRollData());
-    roll.toMessage({
-      speaker: ChatMessage.getSpeaker({ actor: actor }),
-      flavor: label,
-      rollMode: game.settings.get('core', 'rollMode'),
-    });
+    await roll.evaluate();
+    await VermineUtils.showDiceSoNice(roll);
+    VermineUtils.diplayChatRoll(roll, ...arguments);
    return roll;
  }

-  /* -------------------------------------------- */
+  /**
+   * Méthode pour gérer les événements de relance de dés
+   * @param {Object} message - Le message contenant l'événement de relance
+   * @param {Object} ev - L'événement de relance
+   */
+  static async _onRerollSelect(message, ev) {
+    // Vérification de l'utilisateur
+    if (game.user._id != message.user._id) {
+      ui.notifications.warn('vous ne pouvez pas relancer un dés sur ce jet')
+      return false
+    }
+
+    // Récupération du nombre de relances autorisé
+    let rerollCount = ev.currentTarget.closest('div.vermine-roll-message').querySelector('#allowed_reroll')?.innerText;
+    // Vérification du nombre de relances restantes
+    if (!rerollCount || parseInt(rerollCount) < 1) {
+      console.log('no reroll')
+      ui.notifications.warn("plus de relance possible");
+      let rerollables = ev.currentTarget.closest('ul').querySelectorAll('.rerollable');
+      rerollables.forEach(el => el.classList.remove('rerollable'));
+
+      // Mise à jour du nombre de relances restantes
+      ev.currentTarget.closest('div.vermine-roll-message').querySelector('#allowed_reroll').innerText = rerollCount - 1;
+
+      let content = ev.currentTarget.closest('div.message-content').outerHTML;
+
+      await message.update({
+        content: content
+      })
+      return false
+    }
+    ev.currentTarget.classList.add('rerolled');
+
+    // Mise en place de la relance
+    await message.setFlag("world", "reroll", true);
+
+    // Récupération de la difficulté et du type de dé
+    let difficulty = ev.currentTarget.closest('ul').dataset.difficulty;
+    let diceType = ev.currentTarget.dataset.diceType;
+
+    // Mise à jour du nombre de relances restantes
+    ev.currentTarget.closest('div.vermine-roll-message').querySelector('#allowed_reroll').innerText = rerollCount - 1;
+
+    // Construction de la formule de relance
+    let formula = `1d10cs>=${difficulty}`;
+    console.log(diceType)
+    switch (diceType.trim()) {
+      case 'human':
+        formula = `(1d10cs>=${difficulty}[human_${game.user.name}])*2`
+        break;
+      case 'adapted':
+        formula = `(1d10cs>=${difficulty}[adapted_${game.user.name}])*2`
+        break;
+      default:
+        formula += `[regular_${game.user.name}]`
+        break;
+    };
+
+    // Création et évaluation du jet de dés de relance
+    let reroll = await new Roll(formula);
+    await reroll.evaluate();
+    await VermineUtils.showDiceSoNice(reroll);
+    // mise à jour de l'affichage du dés 
+    console.log(reroll)
+    let result = reroll.dice[0].results[0].result;
+    ev.currentTarget.querySelector('span').innerText = result;
+    //mise à jour du total
+    let success = reroll.dice[0].results[0].success;
+    if (success) {
+      ev.currentTarget.classList.add('success')
+      let total = parseInt(ev.currentTarget.closest('.vermine-roll-message').querySelector('#total').innerText) + reroll.total
+      ev.currentTarget.closest('.vermine-roll-message').querySelector('#total').innerText = total
+    }
+    // Mise à jour de l'affichagedu message
+    ev.currentTarget.classList.remove("rerollable")
+    let content = ev.currentTarget.closest('div.message-content').outerHTML;
+    console.log(reroll, message);
+
+    await message.update({
+      content: content
+    })
+  }
+
+  /**
+   * Méthode pour gérer les événements de chat
+   * @param {HTMLElement} html - L'élément HTML contenant les événements de chat
+   */
+  static async chatListenners(html) {
+    let reroll = html.find('#allowed_reroll')[0]?.innerText;
+    if (!reroll || parseInt(reroll) < 1) {
+      for (let die of html.find('.die')) {
+        die.classList.remove("rerollable")
+      };
+    } else {
+      for (let die of html.find('.die')) {
+        die.classList.add("rerollable")
+      };
+    }
+    html.find('.rerollable').click(async (ev) => {
+      ev.preventDefault();
+      let msgId = ev.currentTarget.closest("li.message").dataset.messageId;
+      let message = await game.messages.get(msgId);
+      await VermineUtils._onRerollSelect(message, ev);
+    });
+
+    html.find("#effort-reroll").change(ev => {
+      let label = html.find("#granted-reroll")[0]
+      label.innerText = ev.currentTarget.value
+    });
+    html.find("button.grant-reroll").click(async (ev) => {
+      html.find("#allowed_reroll")[0].innerText = html.find('#granted-reroll')[0].innerText
+      let mesEl = ev.currentTarget.closest('[data-message-id]')
+      let messageId = mesEl.dataset.messageId;
+      ev.currentTarget.closest('.reroll-from-effort').style.display="none"
+      let content = ev.currentTarget.closest(".vermine-roll-message").outerHTML;
+      let message = await game.messages.get(messageId);
+      await message.update({ content: content });
+    });
+
+  }
+
+  /**
+   * Méthode pour afficher les résultats des dés de manière graphique
+   * @param {Roll} roll - Le jet de dés à afficher
+   * @param {string} rollMode - Le mode d'affichage du jet de dés
+   */
  static async showDiceSoNice(roll, rollMode) {
    if (game.modules.get("dice-so-nice")?.active) {
      if (game.dice3d) {
@@ -39,22 +199,36 @@ export class VermineUtils {
    }
  }

-  /* -------------------------------------------- */
-  static async chatListeners(html) {
-
-    html.on("click", '.roll-dice-bonus', event => {
-      let rollData = this.getRollDataFromMessage(event)
-
-      let msgId = VermineRoll.findChatMessageId(event.currentTarget)
-      nocUtility.removeChatMessageId(msgId)
-
-      let nbDice = $(event.target).data('nb-dice')
-      console.log(">>>>>", nbDice)
-      this.rollBonus(rollData, nbDice)
-    })
+  /**
+ * Méthode pour récupérer un jet de dés à partir d'un message
+ * @param {string} messageId - L'identifiant du message contenant le jet de dés
+ */
+  static async getRollFromMessage(messageId) {
+    let message = await game.messages.get(messageId);

  }

+
+  /**
+   * Méthode pour afficher un jet de dés dans le chat
+   * @param {Roll} roll - Le jet de dés à afficher
+   * @param {Object} param - Les paramètres du jet de dés
+   * @returns {ChatMessage} - Le message affichant le jet de dés
+   */
+  static async diplayChatRoll(roll, param) {
+    let content = await renderTemplate("systems/vermine2047/templates/roll-message.hbs", { roll, param })
+    let chatData = {
+      user: game.user._id,
+      speaker: ChatMessage.getSpeaker(),
+      content: content,
+      roll: roll
+    };
+    let msg = await ChatMessage.create(chatData);
+    await msg.setFlag('world', 'roll', roll);
+    return msg
+  }
+
+
 }