Merge pull request 'Choisir parmi plusieurs cibles' (#579) from VincentVk/foundryvtt-reve-de-dragon:v10 into v10

Reviewed-on: https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/pulls/579

module/actor.js

@@ -35,6 +35,7 @@ import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE, HIDE_DICE, SHOW_DIC
 import { RdDConfirm } from "./rdd-confirm.js";
 import { DialogValidationEncaissement } from "./dialog-validation-encaissement.js";
 import { RdDRencontre } from "./item-rencontre.js";
+import { DialogSelectTarget } from "./dialog-select-target.js";
 
 const POSSESSION_SANS_DRACONIC = {
   img: 'systems/foundryvtt-reve-de-dragon/icons/entites/possession.webp',
@@ -223,8 +224,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 +2546,42 @@ 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 && DialogSelectTarget.hasTargets()) {
+        DialogSelectTarget.selectOneToken(target => {
+            if (rollData.competence.system.ispossession) {
+              RdDPossession.onAttaquePossession(target, this, rollData.competence)
+            }
+            else {
+              const arme = RdDItemCompetenceCreature.armeNaturelle(rollData.competence)
+              RdDCombat.rddCombatTarget(target, this).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,41 @@ 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);
+    if (!DialogSelectTarget.hasTargets()) {
+      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;
     }
+    DialogSelectTarget.selectOneToken(target => {
+      if (RdDCombat.isTargetEntite(target)){
+        ui.notifications.warn(`Vous ne pouvez pas attaquer une entité non incarnée avec votre ${arme.name}!!!!`);
+        return;
+      }
+  
+      
+      const competence = this.getCompetence(arme.system.competence)
+      if (competence.system.ispossession) {
+        return RdDPossession.onAttaquePossession(target, this, competence);
+      }
+      RdDCombat.rddCombatTarget(target, this).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)
   }
 
   /* -------------------------------------------- */

module/dialog-select-target.js

@@ -0,0 +1,60 @@
+
+export class DialogSelectTarget extends Dialog {
+  static hasTargets() {
+    return (game.user.targets?.size ?? 0) > 0;
+  }
+
+  static async selectOneToken(onSelectTarget = target => { }) {
+    if (DialogSelectTarget.hasTargets()) {
+      const targets = game.user.targets.map(it => it);
+      switch (targets.size) {
+        case 0: return;
+        case 1:
+          onSelectTarget(targets[0]);
+          return;
+        default:
+          {
+            const tokens = targets.map(it => { return { id: it.id, name: it.document.name, img: it.document.texture.src ?? it.actor.img ?? 'icons/svg/mystery-man.svg' } })
+            const html = await renderTemplate("systems/foundryvtt-reve-de-dragon/templates/dialog-select-target.html", {
+              tokens: tokens
+            });
+            new DialogSelectTarget(html, onSelectTarget, targets).render(true);
+          }
+      }
+    }
+  }
+
+  constructor(html, onSelectTarget, targets) {
+    const options = {
+      classes: ["rdd-dialog-select-target"],
+      width: 'fit-content',
+      height: 'fit-content',
+      'max-height': 600,
+      'z-index': 99999
+    };
+    const conf = {
+      title: "Choisir une cible",
+      content: html,
+      buttons: {}
+    };
+    super(conf, options);
+    this.onSelectTarget = onSelectTarget;
+    this.targets = targets;
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+    html.find("li.select-target").click((event) => {
+      this.targetSelected($(event.currentTarget)?.data("token-id"));
+    });
+  }
+
+
+  targetSelected(tokenId) {
+    const target = this.targets.find(it => it.id == tokenId);
+    this.close();
+    if (target) {
+      this.onSelectTarget(target);
+    }
+  }
+}

module/item-arme.js

@@ -28,7 +28,7 @@ export class RdDItemArme extends Item {
     switch (arme ? arme.type : '') {
       case 'arme': return arme;
       case 'competencecreature':
-        return RdDItemCompetenceCreature.toActionArme(arme);
+        return RdDItemCompetenceCreature.armeNaturelle(arme);
     }
     return RdDItemArme.mainsNues();
   }

module/item-competencecreature.js

@@ -1,4 +1,4 @@
-import { Misc } from "./misc.js";
+
 import { RdDCombatManager } from "./rdd-combat.js";
 
 /* -------------------------------------------- */
@@ -12,12 +12,12 @@ export class RdDItemCompetenceCreature extends Item {
     rollData.competence.system.categorie = "creature"
     rollData.selectedCarac =  rollData.carac.carac_creature
     if (rollData.competence.system.iscombat) {
-      rollData.arme = RdDItemCompetenceCreature.toActionArme(rollData.competence);
+      rollData.arme = RdDItemCompetenceCreature.armeNaturelle(rollData.competence);
     }
   }
 
   /* -------------------------------------------- */
-  static toActionArme(competencecreature) {
+  static armeNaturelle(competencecreature) {
     if (RdDItemCompetenceCreature.isCompetenceAttaque(competencecreature)) {
       // si c'est un Item compétence: cloner pour ne pas modifier lma compétence
       let arme = (competencecreature instanceof Item) ? competencecreature.clone():  competencecreature;

module/rdd-combat.js

@@ -1,5 +1,6 @@
 import { ChatUtility } from "./chat-utility.js";
 import { ENTITE_BLURETTE, ENTITE_INCARNE, ENTITE_NONINCARNE, HIDE_DICE, SYSTEM_RDD, SYSTEM_SOCKET_ID } from "./constants.js";
+import { DialogSelectTarget } from "./dialog-select-target.js";
 import { Grammar } from "./grammar.js";
 import { RdDItemArme } from "./item-arme.js";
 import { RdDItemCompetence } from "./item-competence.js";
@@ -101,14 +102,14 @@ export class RdDCombatManager extends Combat {
             const carac = combatant.actor.system.carac[competence.system.defaut_carac].value;
             const niveau = competence.system.niveau;
             const bonusEcaille = (armeCombat?.system.magique) ? armeCombat.system.ecaille_efficacite : 0;
-            rollFormula = RdDCombatManager.formuleInitiative(2,  carac, niveau, bonusEcaille);
+            rollFormula = RdDCombatManager.formuleInitiative(2, carac, niveau, bonusEcaille);
           }
         }
       }
       //console.log("Combatat", c);
       const roll = combatant.getInitiativeRoll(rollFormula);
-      if ( !roll.total) {
-        roll.evaluate( {async: false});
+      if (!roll.total) {
+        roll.evaluate({ async: false });
       }
       if (roll.total <= 0) roll.total = 0.00;
       console.log("Compute init for", rollFormula, roll.total, combatant);
@@ -156,12 +157,14 @@ export class RdDCombatManager extends Combat {
     let actions = [];
     for (const arme of armes) {
       if (arme.system.equipe) {
-        const dommages = arme.system.dommages;
-        const tableauDommages = dommages.includes("/") ? dommages.split("/") : [dommages, dommages] ;
+        const dommages = arme.system.dommages.toString();
+        const tableauDommages = dommages.includes("/") ? dommages.split("/") : [dommages, dommages];
         if (arme.system.unemain && arme.system.deuxmains && !dommages.includes("/")) {
           ui.notifications.info("Les dommages de l'arme à 1/2 mains " + arme.name + " ne sont pas corrects (ie sous la forme X/Y)");
         }
-        if (arme.system.unemain && arme.system.competence) {
+        console.log(">>>>", arme)
+        if ((arme.system.unemain && arme.system.competence) ||
+          (arme.system.competence.toLowerCase().includes("corps à corps"))) {
           actions.push(RdDCombatManager.$prepareAttaqueArme({
             arme: arme,
             infoMain: "(1 main)",
@@ -220,28 +223,27 @@ export class RdDCombatManager extends Combat {
 
   static listActionsCreature(competences) {
     return competences.filter(it => RdDItemCompetenceCreature.isCompetenceAttaque(it))
-      .map(it => RdDItemCompetenceCreature.toActionArme(it));
+      .map(it => RdDItemCompetenceCreature.armeNaturelle(it));
   }
 
   static listActionsPossessions(actor) {
-    return RdDCombatManager._indexActions(actor.getPossessions().map(p =>
-      {
-        return {
-          name: p.name,
-          action: 'conjurer',
-          system: {
-            competence: p.name,
-            possessionid: p.system.possessionid,
-          }
+    return RdDCombatManager._indexActions(actor.getPossessions().map(p => {
+      return {
+        name: p.name,
+        action: 'conjurer',
+        system: {
+          competence: p.name,
+          possessionid: p.system.possessionid,
         }
-      }));
+      }
+    }));
   }
 
   /* -------------------------------------------- */
   static listActionsCombat(combatant) {
     const actor = combatant.actor;
     let actions = RdDCombatManager.listActionsPossessions(actor);
-    if (actions.length>0) {
+    if (actions.length > 0) {
       return actions;
     }
     if (actor.isCreature()) {
@@ -355,7 +357,7 @@ export class RdDCombatManager extends Combat {
       compData = RdDItemCompetence.findCompetence(combatant.actor.items, action.system.competence);
       compNiveau = compData.system.niveau;
       initInfo = action.name + " / " + action.system.competence;
-        
+
       if (combatant.actor.type == 'creature' || combatant.actor.type == 'entite') {
         caracForInit = compData.system.carac_value;
       } else {
@@ -383,7 +385,7 @@ export class RdDCombatManager extends Combat {
     switch (arme.system.cac) {
       case "empoignade":
         return 3;
-      case "pugilat": 
+      case "pugilat":
       case "naturelle":
         return 4;
     }
@@ -394,7 +396,7 @@ export class RdDCombatManager extends Combat {
   static displayInitiativeMenu(html, combatantId) {
     console.log("Combatant ; ", combatantId);
     const combatant = game.combat.combatants.get(combatantId);
-    if (! (combatant?.actor) ) {
+    if (!(combatant?.actor)) {
       ui.notifications.warn(`Le combatant ${combatant.name ?? combatantId} n'est pas associé à un acteur, impossible de déterminer ses actions de combat!`)
       return;
     }
@@ -468,50 +470,53 @@ export class RdDCombat {
     return true;
   }
 
-  /* -------------------------------------------- */
-  static createUsingTarget(attacker) {
-    const target = RdDCombat.getTarget()
-    if (target == undefined) {
-      ui.notifications.warn((game.user.targets?.size ?? 0) > 1
-        ? "Vous devez choisir <strong>une seule</strong> cible à attaquer!"
-        : "Vous devez choisir une cible à attaquer!");
-    }
-    else {
-      const defender = target?.actor;
-      const defenderTokenId = target?.id;
-      if ( defender.type == 'entite' && defender.system.definition.typeentite == ENTITE_NONINCARNE) {
-        ui.notifications.warn("Vous ne pouvez pas cibler une entité non incarnée !!!!");
-      } else {
-        return this.create(attacker, defender, defenderTokenId, target)
-      }
-    }
-  }
-
   /* -------------------------------------------- */
   static getTarget() {
-    if (game.user.targets && game.user.targets.size == 1) {
-      for (let target of game.user.targets) {
-        return target;
-      }
+    const targets = game.user.targets;
+    switch (targets?.size ?? 0) {
+      case 1:
+        for (let t of targets) {
+          return t;
+        }
+      case 0:
+        ui.notifications.warn("Vous devez choisir une cible à attaquer!");
+        break;
+      default:
+        DialogSelectTarget.selectOneToken(t => console.info(`selecte target ${t}`));
+        ui.notifications.warn("Vous devez choisir une cible (et <strong>une seule</strong>) à attaquer!");
+        return;
+      }    
+    }  
+
+    static isTargetEntite(target) {
+      return target?.actor.type == 'entite' && target?.actor.system.definition.typeentite == ENTITE_NONINCARNE;
     }
-    return undefined;
-  }
 
   /* -------------------------------------------- */
-  static create(attacker, defender, defenderTokenId, target = undefined) {
+  static rddCombatTarget(target, attacker) {
+    const defender = target?.actor;
+    const defenderTokenId = target?.id;
     return new RdDCombat(attacker, defender, defenderTokenId, target)
   }
 
   /* -------------------------------------------- */
-  static createForAttackerAndDefender(attackerId, defenderTokenId) {
+  static rddCombatForAttackerAndDefender(attackerId, defenderTokenId) {
     const attacker = game.actors.get(attackerId);
-    if (defenderTokenId) {
-      const defenderToken = canvas.tokens.get(defenderTokenId);
-      const defender = defenderToken.actor;
-
-      return RdDCombat.create(attacker, defender, defenderTokenId);
+    let defender = defenderTokenId ? canvas.tokens.get(defenderTokenId)?.actor : undefined;
+    let target = undefined
+    if (!defenderTokenId || !defender) {
+      console.warn(`RdDCombat.rddCombatForAttackerAndDefender: appel avec defenderTokenId ${defenderTokenId} incorrect, ou pas de defender correspondant`);
+      target = RdDCombat.getTarget()
+      if (!target) {
+        return;
+      }
+      defenderTokenId = target.id;
+      defender = target.actor;
+      if (!defenderTokenId || !defender) {
+        return;
+      }
     }
-    return RdDCombat.createUsingTarget(attacker)
+    return new RdDCombat(attacker, defender, defenderTokenId, target)
   }
 
   /* -------------------------------------------- */
@@ -522,7 +527,7 @@ export class RdDCombat {
       let attacker = msg.attackerId ? game.actors.get(msg.attackerId) : undefined;
 
       defender.encaisserDommages(attackerRoll, attacker);
-      const rddCombat = RdDCombat.createForAttackerAndDefender(msg.attackerId, msg.defenderTokenId);
+      const rddCombat = RdDCombat.rddCombatForAttackerAndDefender(msg.attackerId, msg.defenderTokenId);
       rddCombat?.removeChatMessageActionsPasseArme(attackerRoll.passeArme);
     }
   }
@@ -531,7 +536,7 @@ export class RdDCombat {
   static onMsgDefense(msg) {
     let defenderToken = canvas.tokens.get(msg.defenderTokenId);
     if (defenderToken && Misc.isUniqueConnectedGM()) {
-      const rddCombat = RdDCombat.createForAttackerAndDefender(msg.attackerId, msg.defenderTokenId);
+      const rddCombat = RdDCombat.rddCombatForAttackerAndDefender(msg.attackerId, msg.defenderTokenId);
       rddCombat?.removeChatMessageActionsPasseArme(msg.defenderRoll.passeArme);
       rddCombat?._chatMessageDefense(msg.paramChatDefense, msg.defenderRoll);
     }
@@ -558,11 +563,10 @@ export class RdDCombat {
       '#echec-total-attaque',
     ]) {
       html.on("click", button, event => {
-        const rddCombat = RdDCombat.createForAttackerAndDefender(
+        const rddCombat = RdDCombat.rddCombatForAttackerAndDefender(
           event.currentTarget.attributes['data-attackerId']?.value,
           event.currentTarget.attributes['data-defenderTokenId']?.value);
         if (rddCombat) {
-
           rddCombat.onEvent(button, event);
           event.preventDefault();
         }
@@ -589,7 +593,7 @@ export class RdDCombat {
   async onEvent(button, event) {
     const chatMessage = ChatUtility.getChatMessage(event);
     const defenderRoll = ChatUtility.getMessageData(chatMessage, 'defender-roll');
-    const attackerRoll = defenderRoll?.attackerRoll ?? ChatUtility.getMessageData(chatMessage, 'attacker-roll') ;
+    const attackerRoll = defenderRoll?.attackerRoll ?? ChatUtility.getMessageData(chatMessage, 'attacker-roll');
     console.log('RdDCombat', attackerRoll, defenderRoll);
     const defenderTokenId = event.currentTarget.attributes['data-defenderTokenId']?.value;
 
@@ -709,12 +713,13 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  async proposerAjustementTirLancer( rollData ) {
+  async proposerAjustementTirLancer(rollData) {
     if (['tir', 'lancer'].includes(rollData.competence.system.categorie)) {
-      if (this.defender.isEntite([ENTITE_BLURETTE])){
-        ChatMessage.create( {
+      if (this.defender.isEntite([ENTITE_BLURETTE])) {
+        ChatMessage.create({
           content: `<strong>La cible est une blurette, l'arme à distance sera perdue dans le blurêve`,
-          whisper: ChatMessage.getWhisperRecipients("GM")})
+          whisper: ChatMessage.getWhisperRecipients("GM")
+        })
       }
       else {
         const defenderToken = canvas.tokens.get(this.defenderTokenId);
@@ -723,7 +728,7 @@ export class RdDCombat {
         const portee = this._ajustementPortee(dist, rollData.arme)
         const taille = this._ajustementTaille(this.defender)
         const activite = this._ajustementMouvement(this.defender)
-        const total = [portee, taille, activite].map(it=>it.diff).filter(d => !Number.isNaN(d)).reduce(Misc.sum(), 0)
+        const total = [portee, taille, activite].map(it => it.diff).filter(d => !Number.isNaN(d)).reduce(Misc.sum(), 0)
         ChatMessage.create({
           content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-info-distance.html', {
             rollData: rollData,
@@ -745,32 +750,32 @@ export class RdDCombat {
   isVisible(token, defenderToken) {
     return canvas.effects.visibility.testVisibility(defenderToken.center, { object: token })
   }
-    
+
   distance(token, defenderToken) {
     return Number(canvas.grid.measureDistances([{ ray: new Ray(token.center, defenderToken.center) }], { gridSpaces: false })).toFixed(1);
   }
 
   _ajustementPortee(dist, arme) {
-    if (dist <= arme.system.portee_courte) return {msg:"courte", diff:0};
-    if (dist <= arme.system.portee_moyenne) return {msg: "moyenne" , diff: -3};
-    if (dist <= arme.system.portee_extreme) return {msg: "extrême", diff:-5};
-    return {msg: "inatteignable", diff: -10};
+    if (dist <= arme.system.portee_courte) return { msg: "courte", diff: 0 };
+    if (dist <= arme.system.portee_moyenne) return { msg: "moyenne", diff: -3 };
+    if (dist <= arme.system.portee_extreme) return { msg: "extrême", diff: -5 };
+    return { msg: "inatteignable", diff: -10 };
   }
 
   _ajustementTaille(actor) {
-    if (actor.isVehicule()) return {msg: "véhicule", diff: 0}
+    if (actor.isVehicule()) return { msg: "véhicule", diff: 0 }
     const taille = actor.getCaracByName('TAILLE')?.value ?? 1;
-    if (taille <= 1) return {msg: "souris", diff: -8};
-    if (taille <= 3) return {msg: "chat", diff: -4};
-    if (taille <= 5) return {msg: "chien", diff: -2};
-    if (taille <= 15) return {msg: "humanoïde", diff: 0};
-    if (taille <= 20) return {msg: "ogre", diff: 2};
-    return {msg: "gigantesque", diff: 4};
+    if (taille <= 1) return { msg: "souris", diff: -8 };
+    if (taille <= 3) return { msg: "chat", diff: -4 };
+    if (taille <= 5) return { msg: "chien", diff: -2 };
+    if (taille <= 15) return { msg: "humanoïde", diff: 0 };
+    if (taille <= 20) return { msg: "ogre", diff: 2 };
+    return { msg: "gigantesque", diff: 4 };
   }
   _ajustementMouvement(defender) {
-    if (defender.getSurprise(true)) return {msg: "immobile (surprise)", diff: 0};
-    if (game.combat?.combatants.find(it => it.actorId == defender.id)) return {msg: "en mouvement (combat)", diff: -4};
-    return {msg: "à déterminer (0 immobile, -3 actif, -4 en mouvement, -5 en zig-zag)", diff: -3};
+    if (defender.getSurprise(true)) return { msg: "immobile (surprise)", diff: 0 };
+    if (game.combat?.combatants.find(it => it.actorId == defender.id)) return { msg: "en mouvement (combat)", diff: -4 };
+    return { msg: "à déterminer (0 immobile, -3 actif, -4 en mouvement, -5 en zig-zag)", diff: -3 };
   }
 
   /* -------------------------------------------- */
@@ -857,7 +862,7 @@ export class RdDCombat {
 
   /* -------------------------------------------- */
   async _onAttaqueParticuliere(rollData) {
-    
+
     const isMeleeDiffNegative = (rollData.competence.type == 'competencecreature' || rollData.selectedCarac.label == "Mêlée") && rollData.diffLibre < 0;
     // force toujours, sauf empoignade
     // finesse seulement en mélée, pour l'empoignade, ou si la difficulté libre est de -1 minimum
@@ -875,7 +880,7 @@ export class RdDCombat {
     else if (!isForce && !isFinesse && isRapide) {
       return await this.choixParticuliere(rollData, "rapidite");
     }
-    
+
     const choixParticuliere = await ChatMessage.create({
       alias: this.attacker.name,
       whisper: ChatUtility.getWhisperRecipientsAndGMs(this.attacker.name),
@@ -914,7 +919,7 @@ export class RdDCombat {
   }
 
   /* -------------------------------------------- */
-  isPossession( attackerRoll) {
+  isPossession(attackerRoll) {
     return attackerRoll.selectedCarac.label.toLowerCase() == 'possession';
   }
 
@@ -1057,9 +1062,8 @@ export class RdDCombat {
     const arme = this.defender.getArmeParade(armeParadeId);
     console.log("RdDCombat.parade >>>", attackerRoll, armeParadeId, arme);
     const competence = arme?.system?.competence;
-    if (competence == undefined)
-    {
-      console.error("Pas de compétence de parade associée à ", arme?.name, armeParadeId) ;
+    if (competence == undefined) {
+      console.error("Pas de compétence de parade associée à ", arme?.name, armeParadeId);
       return;
     }
 

module/rdd-possession.js

@@ -27,7 +27,133 @@ export class RdDPossession {
   }
 
   /* -------------------------------------------- */
-  static updateEtatPossession(possession) {
+  static async onAttaquePossession(target, attacker, competence, possession = undefined) {
+    const defender = target.actor;
+    possession = duplicate(possession ?? this.searchPossessionFromEntite(attacker, defender) ?? (await this.createPossession(attacker, defender)));
+    
+    this.$updateEtatPossession(possession)
+    let rollData = {
+      mode: "possession",
+      isECNIDefender: false,
+      competence: competence,
+      possession: possession,
+      attacker: attacker,
+      defender: defender
+    };
+    if (attacker.isCreature()) {
+      RdDItemCompetenceCreature.setRollDataCreature(rollData)
+    }
+    
+    await RdDPossession.$rollAttaquePossession(attacker, rollData);
+  }
+  
+  /* -------------------------------------------- */
+  static async onConjurerPossession(attacker, competence, possession) {
+    possession = duplicate(possession);
+    this.$updateEtatPossession(possession)
+    let rollData = {
+      mode: "possession",
+      isECNIDefender: true,
+      competence: competence,
+      possession: possession,
+      attacker: attacker,
+      defender: game.actors.get(possession.system.possesseurid)
+    };
+    await RdDPossession.$rollAttaquePossession(attacker, rollData);
+  }
+
+  /* -------------------------------------------- */
+  static async onDefensePossession(attackerId, defenderId, possessionId) {
+    let attacker = game.actors.get(attackerId)
+    let possession = attacker?.getPossession(possessionId)
+    defenderId = defenderId ?? possession?.system.possesseurid ?? undefined
+    let defender = game.actors.get(defenderId)
+    possession = possession ?? defender?.getPossession(possessionId) ?? undefined;
+
+    if (!possession) {
+      ui.notifications.warn("Une erreur s'est produite : Aucune possession trouvée !!")
+      return
+    }
+    // Update for draconic roll
+    let rollData = {
+      mode: "conjuration",
+      isECNIDefender: defender.type == "entite",
+      possession: duplicate(possession),
+      attacker: attacker,
+      defender: defender,
+      competence: defender.getDraconicOuPossession(),
+      selectedCarac: defender.system.carac.reve,
+      forceCarac: { 'reve-actuel': { label: "Rêve Actuel", value: defender.getReveActuel() } }
+    }
+    rollData.competence.system.defaut_carac = 'reve-actuel'
+
+    await RdDPossession.$rollDefensePossesion(defender, rollData);
+  }
+
+  /* -------------------------------------------- */
+  static async $rollAttaquePossession(attacker, rollData) {
+    const dialog = await RdDRoll.create(attacker, rollData,
+      {
+        html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html'
+      }, {
+        name: 'jet-possession',
+        label: rollData.isECNIDefender ? 'Conjurer la possession' : 'Possession',
+        callbacks: [
+          { condition: r => (r.rolled.isSuccess), action: async (r) => await this.$onRollPossession(r, true) },
+          { condition: r => (r.rolled.isEchec), action: async (r) => await this.$onRollPossession(r, false) },
+        ]
+      });
+      dialog.render(true);
+  }
+
+  /* -------------------------------------------- */
+  static async $rollDefensePossesion(defender, rollData) {
+    const dialog = await RdDRoll.create(defender, rollData,
+      {
+        html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-defense-possession.html'
+      },
+      {
+        name: 'conjurer',
+        label: 'Conjurer une Possession',
+        callbacks: [
+          { action: async (r) => await this.$onRollConjuration(r) }
+        ]
+      }
+    );
+    dialog.render(true);
+  }
+
+  /* -------------------------------------------- */
+  static async $onRollPossession(rollData, isSuccess) {
+    rollData.possession.isSuccess = isSuccess;
+    this.$updateEtatPossession(rollData.possession);
+    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html');
+  }
+
+  /* -------------------------------------------- */
+  static async $onRollConjuration(rollData) {
+    let actor = game.actors.get(rollData.possession.system.possedeid)
+    if (!rollData.rolled.isSuccess) {
+      if (rollData.isECNIDefender) {
+        rollData.possession.system.compteur--
+      } else {
+        rollData.possession.system.compteur++
+      }
+      let update = { _id: rollData.possession._id, "system.compteur": rollData.possession.system.compteur }
+      await actor.updateEmbeddedDocuments('Item', [update])
+    }
+
+    this.$updateEtatPossession(rollData.possession)
+
+    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html')
+    if (rollData.possession.isPosseder || rollData.possession.isConjurer) {
+      // conjuration
+      actor.deleteEmbeddedDocuments("Item", [rollData.possession._id])
+    }
+  }
+
+  /* -------------------------------------------- */
+  static $updateEtatPossession(possession) {
     possession.ptsConjuration = 0
     possession.ptsPossession = 0
     console.log("Possession", possession)
@@ -47,111 +173,6 @@ export class RdDPossession {
     }
   }
 
-  /* -------------------------------------------- */
-  static async resultConjuration(rollData) {
-    let actor = game.actors.get(rollData.possession.system.possedeid)
-    if (!rollData.rolled.isSuccess) {
-      if (rollData.isECNIDefender) {
-        rollData.possession.system.compteur--
-      } else {
-        rollData.possession.system.compteur++
-      }
-      let update = { _id: rollData.possession._id, "system.compteur": rollData.possession.system.compteur }
-      await actor.updateEmbeddedDocuments('Item', [update])
-    }
-
-    this.updateEtatPossession(rollData.possession)
-    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html')
-    if (rollData.possession.isPosseder || rollData.possession.isConjurer) {
-      actor.deleteEmbeddedDocuments("Item", [rollData.possession._id])
-    }
-  }
-
-  /* -------------------------------------------- */
-  static async onDefensePossession(attackerId, defenderId, possessionId) {
-    let attacker = game.actors.get(attackerId)
-    let defender = game.actors.get(defenderId)
-    let possession = attacker.getPossession(possessionId) ?? defender.getPossession(possessionId) ;
-    if (!possession) {
-      ui.notifications.warn("Une erreur s'est produite : Aucune possession trouvée !!")
-      return
-    }
-    // Update for draconic roll
-    let rollData = {
-      mode: "conjuration",
-      isECNIDefender: defender.type == "entite",
-      possession: duplicate(possession),
-      attacker: attacker,
-      defender: defender,
-      competence: defender.getDraconicOuPossession(),
-      selectedCarac: defender.system.carac.reve,
-      forceCarac: { 'reve-actuel': { label: "Rêve Actuel", value: defender.getReveActuel() } }
-    }
-    rollData.competence.system.defaut_carac = 'reve-actuel'
-
-
-    const dialog = await RdDRoll.create(defender, rollData,
-      {
-        html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-defense-possession.html'
-      },
-      {
-        name: 'conjurer',
-        label: 'Conjurer une Possession',
-        callbacks: [
-          { action: async r => await this.resultConjuration(r) }
-        ]
-      }
-    );
-    dialog.render(true)
-  }
-
-  /* -------------------------------------------- */
-  static async onAttaquePossession(attacker, competence, possession = undefined) {
-    const target = RdDCombat.getTarget()
-    if (target == undefined) {
-      ui.notifications.warn((game.user.targets?.size ?? 0) > 1
-        ? "Vous devez choisir <strong>une seule</strong> cible à posséder!"
-        : "Vous devez choisir une cible à posséder!");
-      return;
-    }
-
-    const defender = target.actor;
-    possession = duplicate(possession ?? this.searchPossessionFromEntite(attacker, defender) ??(await this.createPossession(attacker, defender)));
-    
-    this.updateEtatPossession(possession)
-    let rollData = {
-      mode: "possession",
-      isECNIDefender: defender.type == "entite",
-      competence: competence,
-      possession: possession,
-      attacker: attacker,
-      defender: defender
-    };
-    if (attacker.isCreature()) {
-      RdDItemCompetenceCreature.setRollDataCreature(rollData)
-    }
-
-    const dialog = await RdDRoll.create(attacker, rollData,
-      {
-        html: 'systems/foundryvtt-reve-de-dragon/templates/dialog-roll-competence.html'
-      }, {
-      name: 'jet-possession',
-      label: rollData.isECNIDefender ? 'Conjurer la possession' : 'Possession',
-      callbacks: [
-        { condition: r => (r.rolled.isSuccess), action: async r => await this._onRollPossession(r, true) },
-        { condition: r => (r.rolled.isEchec), action: async r => await this._onRollPossession(r, false) },
-      ]
-    });
-    dialog.render(true)
-  }
-
-  /* -------------------------------------------- */
-  static async _onRollPossession(rollData, isSuccess) {
-    rollData.possession.isSuccess = isSuccess;
-    this.updateEtatPossession(rollData.possession);
-    await RdDResolutionTable.displayRollData(rollData, this, 'chat-resultat-possession.html');
-  }
-
   /* -------------------------------------------- */
   static async createPossession(attacker, defender) {
     let possessionData = {

module/settings/regles-optionelles.js

@@ -18,6 +18,7 @@ const listeReglesOptionelles = [
   { group: 'Règles générales', name: 'appliquer-fatigue', descr: "Appliquer les règles de fatigue"},
   { group: 'Règles générales', name: 'afficher-colonnes-reussite', descr: "Afficher le nombre de colonnes de réussite ou d'échec", default: false },
 
+  { group: 'Confirmations', name: 'confirmer-combat-sans-cible',         descr: "Confirmer avant une attaque sans cible", scope: "client"},
   { group: 'Confirmations', name: 'confirmation-tmr',                    descr: "Confirmer pour monter dans les TMR", scope: "client"},
   { group: 'Confirmations', name: 'confirmation-refouler',               descr: "Confirmer avant de refouler", scope: "client"},
   { group: 'Confirmations', name: 'confirmation-vider',                  descr: "Confirmer pour vider l'équipement", scope: "client"},

styles/simple.css

@@ -332,6 +332,22 @@ input:is(.blessure-premiers_soins, .blessure-soins_complets) {
   object-fit: cover;
   object-position: 50% 0;
 }
+.rdd-dialog-select-target img.select-token-img {
+  -webkit-box-flex: 0;
+  -ms-flex: 0 0 48px;
+  flex: 0 0 48px;
+  height: 48px;
+  width: 48px;
+  border: 0;
+  margin-right: 0.5rem;
+  object-fit: cover;
+  vertical-align: baseline;
+}
+
+.rdd-dialog-select-target li.select-target {
+  vertical-align: baseline;
+  padding: 0.1rem;
+}
 
 .dice-img {
   border-width: 0;
@@ -488,40 +504,40 @@ input:is(.blessure-premiers_soins, .blessure-soins_complets) {
   text-shadow: none;
 }
 
-.foundryvtt-reve-de-dragon .items-list {
+.foundryvtt-reve-de-dragon .item-list {
   list-style: none;
   margin: 7px 0;
   padding: 0;
   overflow-y: auto;
 }
 
-.foundryvtt-reve-de-dragon .items-list .item-header {
+.foundryvtt-reve-de-dragon .item-list .item-header {
   font-weight: bold;
 }
 
-.foundryvtt-reve-de-dragon .items-list .item {
+.foundryvtt-reve-de-dragon .item-list .item {
   height: 30px;
   line-height: 24px;
   padding: 3px 0;
   border-bottom: 1px solid #BBB;
 }
 
-.foundryvtt-reve-de-dragon .items-list .item .item-image {
+.foundryvtt-reve-de-dragon .item-list .item .item-image {
   -webkit-box-flex: 0;
   -ms-flex: 0 0 24px;
   flex: 0 0 24px;
   margin-right: 5px;
 }
 
-.foundryvtt-reve-de-dragon .items-list .item img {
+.foundryvtt-reve-de-dragon .item-list .item img {
   display: block;
 }
 
-.foundryvtt-reve-de-dragon .items-list .item-name {
+.foundryvtt-reve-de-dragon .item-list .item-name {
   margin: 0;
 }
 
-.foundryvtt-reve-de-dragon .items-list .item-controls {
+.foundryvtt-reve-de-dragon .item-list .item-controls {
   -webkit-box-flex: 0;
   -ms-flex: 0 0 86px;
   flex: 0 0 86px;
@@ -680,7 +696,7 @@ section.sheet-body{padding: 0.25rem 0.5rem;}
   padding: 0 0 0 0.25rem;
   text-align: center;
   text-transform: uppercase;
-  line-height: 2.5rem;
+  line-height: 1.2rem;
   border-top: 0 none;
   border-bottom: 0 none;
   color: rgba(52, 52, 52, 0.95);
@@ -862,7 +878,7 @@ ul, li {
   box-shadow: inset 0px 0px 1px #00000096;
   border-radius: 0.25rem;
   padding: 0.1rem;
-  flex: 1 1 5rem;
+  flex: 1 1 1.5rem;
   display: flex !important;
   align-items: center !important;
 }

system.json

@@ -1,8 +1,8 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "10.2.5",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-10.2.5.zip",
+  "version": "10.2.8",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-10.2.8.zip",
   "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v10/system.json",
   "compatibility": {
     "minimum": "10",

templates/dialog-select-target.html

@@ -0,0 +1,14 @@
+<form class="rdd-dialog-select-target">
+  <label>Choisir une seule des cibles</label>
+  <hr>
+  <ul class="flexcol item-list alterne-list">
+    {{#each tokens as |token key|}}
+    <li class="select-target item list-item flexrow" data-token-id="{{token.id}}">
+      <img class="select-token-img flex-shrink" src="{{token.img}}" title="{{token.name}}" />
+      <a>
+      <label>{{token.name}}</label>
+      </a>
+    </li>
+    {{/each}}
+  </ul>
+</form>