Autoriser le combat sans cible

module/actor.js

@@ -223,8 +223,18 @@ export class RdDActor extends Actor {
   }
   /* -------------------------------------------- */
   getReveActuel() {
-    return Misc.toInt(this.system.reve?.reve?.value ?? this.carac.reve.value);
+    switch(this.type) {
+      case 'personnage':
+        return Misc.toInt(this.system.reve?.reve?.value ?? this.carac.reve.value);
+      case 'creature':
+      case 'entite':
+        return Misc.toInt(this.system.carac.reve?.value)
+      case 'vehicule':
+      default:
+         return 0;
+    }
   }
+
   /* -------------------------------------------- */
   getChanceActuel() {
     return Misc.toInt(this.system.compteurs.chance?.value ?? 10);
@@ -2535,48 +2545,43 @@ export class RdDActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  async rollCompetence(idOrName) {
-    let rollData = { competence: this.getCompetence(idOrName) }
-
+  async rollCompetence(idOrName, options = {tryTarget: true}) {
+    let rollData = {
+      carac: this.system.carac,
+      competence: this.getCompetence(idOrName)
+    }
     if (rollData.competence.type == 'competencecreature') {
-      if (rollData.competence.system.iscombat) {
-        if (rollData.competence.system.ispossession) {
-          RdDPossession.onAttaquePossession(this, rollData.competence)
-          return
-        }
-        else if (RdDCombat.getTarget()) {
-          const arme = RdDItemCompetenceCreature.toActionArme(rollData.competence)
-          RdDCombat.createUsingTarget(this)?.attaque(competence, arme)
-          return
+      if (rollData.competence.system.iscombat && options.tryTarget) {
+        const target = RdDCombat.getTarget();
+        if (target) {
+          if (rollData.competence.system.ispossession) {
+            RdDPossession.onAttaquePossession(target, this, rollData.competence)
+          }
+          else {
+            const arme = RdDItemCompetenceCreature.armeNaturelle(rollData.competence)
+            RdDCombat.rddCombatTarget(this, target).attaque(competence, arme)
+          }
+          return;
         }
       }
-      // Fake competence pour créature
+      // Transformer la competence de créature
       RdDItemCompetenceCreature.setRollDataCreature(rollData)
-    } else {
-      rollData.carac = this.system.carac
     }
     console.log("rollCompetence !!!", rollData);
-
     const dialog = await RdDRoll.create(this, rollData, { html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html' }, {
       name: 'jet-competence',
       label: 'Jet ' + Grammar.apostrophe('de', rollData.competence.name),
       callbacks: [
         this.createCallbackExperience(),
         this.createCallbackAppelAuMoral(),
-        { action: r => this._competenceResult(r) }
+        { action: r => this.$onRollCompetence(r) }
       ]
     });
     dialog.render(true);
   }
 
   /* -------------------------------------------- */
-  conjurerPossession(possession) {
-    let draconic = this.getDraconicOuPossession();
-    RdDPossession.onAttaquePossession(this, draconic, possession)
-  }
-
-  /* -------------------------------------------- */
-  async _competenceResult(rollData) {
+  async $onRollCompetence(rollData) {
     await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-competence.html')
   }
 
@@ -3217,26 +3222,42 @@ export class RdDActor extends Actor {
 
   /* -------------------------------------------- */
   rollArme(arme) {
-    let competence = this.getCompetence(arme.system.competence)
-    if (arme || (competence.type == 'competencecreature' && competence.system.iscombat)) {
-      if (competence.system.ispossession) {
-        RdDPossession.onAttaquePossession(this, competence);
-      } else {
-        RdDCombat.createUsingTarget(this)?.attaque(competence, arme);
-      }
-    } else {
-      this.rollCompetence(competence.name);
+    const target = RdDCombat.getTarget();
+    if (!target) {
+      RdDConfirm.confirmer({
+        settingConfirmer: "confirmer-combat-sans-cible",
+        content: `<p>Voulez vous faire un jet de compétence ${arme.system.competence} sans choisir de cible valide?
+                  <br>Tous les jets de combats devront être gérés à la main
+                  </p>`,
+        title: 'Ne pas utiliser les automatisation de combat',
+        buttonLabel: "Pas d'automatisation",
+        onAction: async () => {
+          this.rollCompetence(arme.system.competence, {tryTarget: false})
+        }
+      });
+      return;
     }
+    if (RdDCombat.isTargetEntite(target)){
+      ui.notifications.warn(`Vous ne pouvez pas attaquer une entité non incarnée avec votre ${arme.name}!!!!`);
+      return;
+    }
+    // if (RdDCombat.isTargetEntite(targets[0])) {
+    //   ui.notifications.warn("Vous ne pouvez pas cibler une entité non incarnée!");
+    //   return;
+    // }
+
+    const competence = this.getCompetence(arme.system.competence)
+    if (competence.system.ispossession) {
+      return RdDPossession.onAttaquePossession(target, this, competence);
+    }
+    RdDCombat.rddCombatTarget(this, target).attaque(competence, arme);
   }
 
   /* -------------------------------------------- */
-  _getTarget() {
-    if (game.user.targets && game.user.targets.size == 1) {
-      for (let target of game.user.targets) {
-        return target;
-      }
-    }
-    return undefined;
+  conjurerPossession(possession) {
+    // TODO: choix de la compétence de draconic ou de possession
+    let draconic = this.getDraconicOuPossession();
+    RdDPossession.onConjurerPossession(this, draconic, possession)
   }
 
   /* -------------------------------------------- */