Attaques V2 depuis onglet combat

changelog.md

@@ -1,5 +1,9 @@
 # 13.0
 
+## 13.0.29 - Le tricorne d'Illysis
+
+- gestion des attaques avec jets V2 depuis l'onglet de combat'
+
 ## 13.0.28 - La quadrature d'Illysis
 
 - Les ajustements de portée sont calculés pour les attaques à distance

module/actor/base-actor-reve.js

@@ -56,8 +56,6 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   getTaille() { return Misc.toInt(this.system.carac.taille?.value) }
   getConstitution() { return this.getReve() }
-  getVie() { return this.getReve() }
-  getCaracVie() { return { [CARACS.VIE]: { label: "Vie", value: this.getVieMax(), type: "number" } } }
 
   getForce() { return this.getReve() }
   getAgilite() { return this.getForce() }
@@ -484,17 +482,15 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   async rollCompetence(idOrName, options = { tryTarget: true, arme: undefined }) {
     RdDEmpoignade.checkEmpoignadeEnCours(this)
-
     const competence = this.getCompetence(idOrName);
     if (OptionsAvancees.isUsing(ROLL_DIALOG_V2)) {
       const rollData = {
         ids: { actorId: this.id },
-        type: { allowed: options.arme ? ATTAQUE_ROLL_TYPES : DEFAULT_ROLL_TYPES },
+        type: { allowed: DEFAULT_ROLL_TYPES },
         selected: {
           carac: competence.type == ITEM_TYPES.competencecreature ? { key: competence.name } : undefined,
           comp: { key: competence.name },
-          diff: { type: options.arme ? DIFF.ATTAQUE : DIFF.LIBRE, value: competence.system.default_diffLibre ?? 0 },
-          attaque: options.arme ? { arme: { key: options.arme.id } } : undefined
+          diff: { type: DIFF.LIBRE, value: competence.system.default_diffLibre ?? 0 },
         }
       }
       return await RollDialog.create(rollData)
@@ -566,7 +562,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
             type: {
               allowed: [ROLL_TYPE_ATTAQUE], current: ROLL_TYPE_ATTAQUE
             }
-          };
+          }
           return await RollDialog.create(rollData, { onRollDone: RollDialog.onRollDoneClose })
         }
       })
@@ -575,16 +571,18 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   /** --------------------------------------------
    * @param {*} arme item d'arme/compétence de créature
-   * @param {*} categorieArme catégorie d'attaque à utiliser: competence (== melee), lancer, tir; naturelle, possession
+   * @param {*} maniement catégorie d'attaque à utiliser: competence (== melee), lancer, tir; naturelle, possession
    * @returns
    */
-  rollArme(arme, categorieArme = 'competence', token = undefined) {
+  async rollArme(arme, maniement = 'competence', token = undefined) {
     token = token ?? RdDUtility.getSelectedToken(this)
-    const compToUse = RdDItemArme.getCompetenceArme(arme, categorieArme)
+    const compToUse = RdDItemArme.getCompetenceArme(arme, maniement)
+    
     if (!RdDItemArme.isUtilisable(arme)) {
       ui.notifications.warn(`Arme inutilisable: ${arme.name} non équipée ou avec une résistance de 0 ou moins`)
       return
     }
+
     if (!Targets.hasTargets()) {
       RdDConfirm.confirmer({
         settingConfirmer: "confirmer-combat-sans-cible",
@@ -596,7 +594,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
         onAction: async () => {
           this.rollCompetence(compToUse, { tryTarget: false, arme: arme })
         }
-      });
+      })
       return
     }
 
@@ -606,11 +604,12 @@ export class RdDBaseActorReve extends RdDBaseActor {
         return
       }
 
-      const competence = this.getCompetence(compToUse)
-      if (competence.isCompetencePossession()) {
-        return RdDPossession.onAttaquePossession(target, this, competence);
+      const comp = this.getCompetence(compToUse)
+      if (comp.isCompetencePossession()) {
+        // TODO: vérifier si c'est possible, sinon simplifier
+        return RdDPossession.onAttaquePossession(target, this, comp);
       }
-      RdDCombat.rddCombatTarget(target, this, token).attaque(competence, arme);
+      RdDCombat.rddCombatTarget(target, this, token).attaque(comp, arme, maniement)
     })
   }
 

module/rdd-combat.js

@@ -518,8 +518,8 @@ export class RdDCombat {
   /* -------------------------------------------- */
   attaqueChanceuse(attackerRoll) {
     ui.notifications.info("L'attaque est rejouée grâce à la chance")
-    attackerRoll.essais.attaqueChance = true;
-    this.attaque(attackerRoll, attackerRoll.arme);
+    attackerRoll.essais.attaqueChance = true
+    this.attaque(attackerRoll, attackerRoll.arme)
   }
 
   /* -------------------------------------------- */
@@ -646,11 +646,11 @@ export class RdDCombat {
     }
   }
 
-  async attaqueV2() {
+  async attaqueV2(options = undefined) {
     if (!await this.attacker.accorder(this.defender, 'avant-attaque')) {
       return
     }
-    await this.doRollAttaque({
+    const rollData = {
       ids: {
         actorId: this.attackerId,
         actorTokenId: this.attackerTokenId,
@@ -658,8 +658,19 @@ export class RdDCombat {
         opponentTokenId: this.defenderTokenId,
       },
       type: { allowed: ['attaque'], current: 'attaque' },
+      selected: {},
       passeArme: foundry.utils.randomID(16),
-    })
+    }
+    if (options) {
+      rollData.selected = {
+        attaque: {
+          comp: { id: options.comp.id },
+          arme: { id: options.arme.id },
+          main: options.main
+        }
+      }
+    }
+    await this.doRollAttaque(rollData)
   }
 
   async doRollAttaque(rollData, callbacks = []) {
@@ -740,12 +751,14 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  async attaque(competence, arme) {
+  async attaque(competence, arme, main) {
     if (!await this.attacker.accorder(this.defender, 'avant-attaque')) {
       return
     }
     if (OptionsAvancees.isUsing(ROLL_DIALOG_V2)) {
-      return this.attacker.rollCompetence(competence.name, { arme: arme })
+      return this.attaqueV2(
+        { comp: competence, arme: arme, main: main }
+      )
     }
     if (arme.system.cac == EMPOIGNADE) {
       RdDEmpoignade.onAttaqueEmpoignade(this.attacker, this.defender)
@@ -754,7 +767,7 @@ export class RdDCombat {
     RdDEmpoignade.checkEmpoignadeEnCours(this.attacker)
 
     let rollData = this._prepareAttaque(competence, arme)
-    console.log("RdDCombat.attaque >>>", rollData);
+    console.log("RdDCombat.attaque >>>", rollData)
     if (arme) {
       this.attacker.verifierForceMin(arme);
     }

module/rdd-hotbar-drop.js

@@ -101,7 +101,7 @@ export class RdDHotbar {
   }
 
   /** Roll macro */
-  static rollMacro(itemName, itemType, categorieArme = 'competence') {
+  static rollMacro(itemName, itemType, maniement = 'competence') {
     const speaker = ChatMessage.getSpeaker();
     let actor;
     if (speaker.token) actor = game.actors.tokens[speaker.token];
@@ -117,10 +117,10 @@ export class RdDHotbar {
     // Trigger the item roll
     switch (item.type) {
       case ITEM_TYPES.arme:
-        return actor.rollArme(item, categorieArme);
+        return actor.rollArme(item, maniement);
       case ITEM_TYPES.competence:
         if (item.isCorpsACorps()) {
-          switch (categorieArme) {
+          switch (maniement) {
             case PUGILAT:
               return actor.rollArme(RdDItemArme.pugilat(actor));
             case EMPOIGNADE:
@@ -130,7 +130,7 @@ export class RdDHotbar {
         return actor.rollCompetence(item);
       case ITEM_TYPES.competencecreature:
         return item.system.iscombat
-          ? actor.rollArme(item, categorieArme)
+          ? actor.rollArme(item, maniement)
           : actor.rollCompetence(item);
 
     }

module/roll/roll-part-attaque.mjs

@@ -52,11 +52,13 @@ export class RollPartAttaque extends RollPartSelect {
 
   restore(rollData) {
     const saved = this.getSaved(rollData) ?? {}
-    this.setCurrent(rollData, {
-      key: saved.key,
-      tactique: saved.tactique,
-      dmg: saved.dmg
-    })
+    if (saved.key) {
+      this.setCurrent(rollData, {
+        key: saved.key,
+        tactique: saved.tactique,
+        dmg: saved.dmg
+      })
+    }
   }
 
   store(rollData, targetData) {
@@ -70,8 +72,10 @@ export class RollPartAttaque extends RollPartSelect {
 
 
   findAttaque(attaques, saved) {
-    return attaques.find(at => at.arme.id == saved?.arme?.id &&
-      at.comp.id == saved?.comp?.id
+    return attaques.find(at => at.arme.id == (saved?.arme?.id ?? at.arme.id)
+      && at.comp.id == (saved?.comp?.id ?? at.comp.id)
+      && at.main == (saved?.main ?? at.main)
+
     )
   }