Empoignade V2

assets/actions/empoignade.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" style="height: 256px; width: 256px;"><g class="" transform="translate(0,0)" style=""><path d="M243.512 23.29c-27.105 18.337-53.533 32.92-82.274 45.337-2.843 17.364-3.948 34.497-4.05 51.584 28.913 15.41 56.096 32.85 83.33 49.634l7.045 4.344-3.432 7.482c-12.12 26.572-24.33 47.087-46.245 70.3l-5.184 5.512-6.46-3.904c-32.974-19.974-74.472-38.724-113.373-53.95l6.826-17.374c36.79 14.4 75.11 32.32 108.153 51.504 15.396-17.198 25.326-33.354 34.713-52.89-43.44-26.91-86.13-53.51-134.69-70.632-23.012 20.357-37.705 45.243-51.942 70.74 8.324 25.495 6.596 53.376-6.596 77.46 48.58-.593 97.994 2.23 150.666 10.26l5.658.837 1.787 5.44c8.85 26.46 11.79 54.41 8.325 83.588l-.987 8.432-8.466-.187c-40.508-.864-80.175-2.138-118.17.234 1.634 15.94-2.31 30.972-7.724 45.025 13.427 28.54 27.38 55.8 48.29 79.39 41.27-19.05 73.564-31.288 115.93-42.85-3.407-13.72-6.918-26.36-11.097-33.62-5.122-8.9-10.207-13.057-17.85-15.256-15.284-4.4-44.533 2.293-92.894 19.454l-6.243-17.594c48.907-17.354 79.702-26.894 104.283-19.82 9.133 2.628 16.884 8.004 23.066 15.46 14.487-7.627 28.415-16.79 42.053-26.996 12.34-45.92 37.29-81.42 66.626-112.107-7.226-13.52-13.208-27.204-20.563-40.613l-3.394-6.168 5-4.965c23.275-23.13 47.34-40.157 71.87-52.487l8.395 16.716c-20.952 10.53-41.503 25.913-61.795 45.152 12.41 23.91 22.263 45.5 39.457 64.826 37.488-27.124 74.943-51.39 116.84-74.938-13.96-30.473-31.345-58.357-56.286-79.462-32.2 13.38-62.527 17.39-92.61 12.29-14.223 13.25-30.094 22.23-48.756 23.337-29.017 1.722-60.74-15.74-99.174-57.672l6.858-6.295.017-.028.006.006 6.88-6.314c36.702 40.043 63.74 52.87 84.32 51.65 18.514-1.1 35.03-14.95 51.684-35.406-28.827-31.81-64.174-59.94-97.822-84.465zM39.324 277.884c-6.06.022-12.104.098-18.142.223 1.673 26.288 5.512 51.288 14.052 73.732 45.88-5.82 93.308-4.96 141.15-3.87 1.518-21.27-.253-41.69-6.058-61.212-45.528-6.565-88.59-9.03-131.002-8.873z" fill="#fff" fill-opacity="1"></path></g></svg>

changelog.md

@@ -8,8 +8,17 @@
   - l'encaissement indique une blessure dans le tchat... même si ce n'est que de l'endurance
   - les blurettes suivent les règles des entités de cauchemar (p322)
 - Nouvelle fenêtre de jets de dés
-  - Attaque/défense des créatures
+  - attaque/défense des créatures
   - les attaques/parades avec une arme trop lourde se font en demi-surprise
+  - les demandes de défense disparaîssent une fois prises en compte
+  - empoignade
+    - l'empoignade est possible avec une initiative d'empoignade, ou en cours d'empoignade
+    - seule la dague, le pugilat et la dague sont possibles en cours d'empoignade
+    - jet de Dextérité/Dague pour utiliser la dague en cours d'empoignade
+    - attaquer avec une arme un empoigneur donne un +4 si pas d'empoignade
+    - les dommages de l'empoignade ajoutent/enlèvent un point d'empoignade
+    - le statut d'empoignade est affiché sur les tokens
+    - les défenses contre une empoignade sont corrigées
 
 ## 13.0.13 - L'épanouissement d'Illysis
 

css/foundryvtt-reve-de-dragon.css

@@ -648,6 +648,15 @@ select,
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-conditions roll-section[name="coeur"] select[name="coeur"] {
   max-width: 4rem;
 }
+.system-foundryvtt-reve-de-dragon .roll-dialog roll-conditions roll-section[name="empoignade"] img {
+  /* image de d100 */
+  max-width: 1rem;
+  max-height: 1rem;
+  gap: 0;
+  margin: 0;
+  padding: 0;
+  filter: invert(0.8);
+}
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-conditions roll-section[name="tricher"] img {
   /* image de d100 */
   max-width: 2.5rem;

less/roll-dialog.less

@@ -224,6 +224,15 @@
     max-width: 4rem;
   }
 
+  roll-conditions roll-section[name="empoignade"] img {
+    /* image de d100 */
+    max-width: 1rem;
+    max-height: 1rem;
+    gap: 0;
+    margin: 0;
+    padding: 0;
+    filter: invert(0.8);
+  }
   roll-conditions roll-section[name="tricher"] img {
     /* image de d100 */
     max-width: 2.5rem;

module/actor.js

@@ -185,7 +185,7 @@ export class RdDActor extends RdDBaseActorSang {
     const actions = []
     const uniques = []
 
-    const addAttaque = (arme, main = undefined, action = 'attaque') => {
+    const addAttaque = (arme, main = undefined) => {
       const dommages = RdDItemArme.valeurMain(arme.system.dommages, main)
       const forceRequise = RdDItemArme.valeurMain(arme.system.force ?? 0, main)
       const ecaillesEfficacite = arme.system.magique ? arme.system.ecaille_efficacite : 0;
@@ -218,6 +218,7 @@ export class RdDActor extends RdDBaseActorSang {
       })
     }
 
+    addAttaque(RdDItemArme.empoignade(this), ATTAQUE_TYPE.CORPS_A_CORPS)
     this.itemTypes[ITEM_TYPES.arme]
       .filter(it => it.isAttaque())
       .sort(Misc.ascending(it => it.name))
@@ -227,9 +228,7 @@ export class RdDActor extends RdDBaseActorSang {
         if (arme.system.lancer && arme.system.resistance > 0) { addAttaque(arme, ATTAQUE_TYPE.LANCER) }
         if (arme.system.tir) { addAttaque(arme, ATTAQUE_TYPE.TIR) }
       })
-
       addAttaque(RdDItemArme.pugilat(this), ATTAQUE_TYPE.CORPS_A_CORPS)
-    addAttaque(RdDItemArme.empoignade(this), ATTAQUE_TYPE.CORPS_A_CORPS, 'empoignade')
 
     return actions
   }
@@ -3040,6 +3039,8 @@ export class RdDActor extends RdDBaseActorSang {
         await this.onDeleteOwnedCaseTmr(item, options, id)
         break
       case ITEM_TYPES.empoignade:
+        await this.setEffect(STATUSES.StatusGrappled, false)
+        await this.setEffect(STATUSES.StatusGrappling, false)
         await RdDEmpoignade.deleteLinkedEmpoignade(this.id, item)
         break
     }

module/actor/base-actor-reve.js

@@ -126,6 +126,8 @@ export class RdDBaseActorReve extends RdDBaseActor {
   async remiseANeuf() { }
   async appliquerAjoutExperience(rollData, hideChatMessage = 'show') { }
 
+  computeResumeBlessure() {}
+  countBlessures(filter = it => !it.isContusion()) { return 0 }
   async santeIncDec(name, inc, isCritique = false) { }
 
   async finDeRound(options = { terminer: false }) {
@@ -204,6 +206,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
   getPossession(possessionId) {
     return this.itemTypes[ITEM_TYPES.possession].find(it => it.system.possessionid == possessionId);
   }
+
   getEmpoignades() {
     return this.itemTypes[ITEM_TYPES.empoignade];
   }
@@ -245,7 +248,7 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   async setEffect(statusId, status) {
     if (this.isEffectAllowed(statusId)) {
-      const effect = this.getEffectByStatus(statusId);
+      const effect = this.getEffectByStatus(statusId)
       if (!status && effect) {
         await this.deleteEmbeddedDocuments('ActiveEffect', [effect.id], { render: true })
       }

module/constants.js

@@ -60,7 +60,7 @@ export const RDD_CONFIG = {
   icons: {
     armesDisparates: 'systems/foundryvtt-reve-de-dragon/assets/actions/armes-disparates.svg',
     demiReve: 'systems/foundryvtt-reve-de-dragon/assets/actions/sort.svg',
-    empoignade: 'systems/foundryvtt-reve-de-dragon/icons/empoignade.webp',
+    empoignade: 'systems/foundryvtt-reve-de-dragon/assets/actions/empoignade.svg',
     forceWeak: 'systems/foundryvtt-reve-de-dragon/assets/actions/weak.svg',
   },
   encaissement: {

module/initiative.mjs

@@ -58,6 +58,7 @@ export class RdDInitiative {
     return {
       roll: roll,
       value: value,
+      rang: formule.phase.rang,
       init: formule.phase.rang + value / 100,
       label: formule.phase.label
     }

module/item/arme.js

@@ -27,6 +27,7 @@ export const ATTAQUE_TYPE = {
   TIR: '(tir)',
   LANCER: '(lancer)'
 }
+export const ATTAQUE_TYPE_MELEE = [ATTAQUE_TYPE.UNE_MAIN, ATTAQUE_TYPE.DEUX_MAINS, ATTAQUE_TYPE.CORPS_A_CORPS]
 
 export const CORPS_A_CORPS = 'Corps à corps'
 export const PUGILAT = 'pugilat'
@@ -254,6 +255,14 @@ export class RdDItemArme extends RdDItem {
     return this.system.resistance > 0 || (this.system.tir != '' && this.system.portee_courte > 0)
   }
 
+  isEmpoignade() {
+    return this.system.mortalite == RDD_CONFIG.encaissement.empoignade
+  }
+
+  isUtilisableEmpoigne() {
+    return this.system.baseInit == 3 || this.system.baseInit == 4 || this.system.competence == "Dague"
+  }
+
   static pugilat(actor) {
     return RdDItemArme.$corpsACorps(actor, 'Pugilat', PUGILAT)
   }

module/rdd-bonus.js

@@ -74,6 +74,7 @@ export class RdDBonus {
       dmgForceInsuffisante: Math.min(0, actor.getForce() - (attaque.forceRequise ?? 0)),
       dmgDiffLibre: ReglesOptionnelles.isUsing('degat-ajout-malus-libre') ? Math.abs(attaque.diff ?? 0) : 0
     }
+    dmg.isEmpoignade = dmg.mortalite == RDD_CONFIG.encaissement.empoignade
     dmg.total = dmg.dmgSurprise + dmg.dmgTactique + dmg.dmgArme + dmg.dmgActor + dmg.dmgParticuliere + dmg.dmgForceInsuffisante + dmg.dmgDiffLibre
     return dmg
   }

module/rdd-combat.js

@@ -56,6 +56,12 @@ export class RdDCombatManager extends Combat {
     }
   }
 
+
+  static getCombatant(actorId, tokenId) {
+    return game.combat.combatants.find(it => it.actor.id == actorId &&
+      it.token.id == tokenId
+    );
+  }
   /* -------------------------------------------- */
   async nextRound() {
     await this.finDeRound();
@@ -402,7 +408,6 @@ export class RdDCombat {
   /* -------------------------------------------- */
   static registerChatCallbacks(html) {
     for (let button of [
-      '.button-defense',
       '.button-parade',
       '.button-esquive',
       '.button-encaisser',
@@ -474,8 +479,6 @@ export class RdDCombat {
 
     switch (button) {
       case '.particuliere-attaque': return await this.choixParticuliere(attackerRoll, event.currentTarget.attributes['data-mode'].value);
-      case '.button-defense': return this.defenseV2(attackerRoll);
-
       case '.button-parade': return this.parade(attackerRoll, armeParadeId);
       case '.button-esquive': return this.esquive(attackerRoll, compId, competence);
       case '.button-encaisser': return this.encaisser(attackerRoll, defenderRoll);
@@ -725,24 +728,24 @@ export class RdDCombat {
   async _chatMessageDefenseV2(paramDemandeDefense) {
     const attackerRoll = paramDemandeDefense.attackerRoll;
     RollBasicParts.loadSurprises(attackerRoll)
-    attackerRoll.passeArme = attackerRoll.passeArme ?? foundry.utils.randomID(16)
     attackerRoll.dmg = RdDBonus.dmgRollV2(attackerRoll, attackerRoll.current.attaque)
-    const attaque = RollDialog.saveParts(attackerRoll)
+
-    const defense = {
+    const defenseData = RollBasicParts.prepareDefense(attackerRoll)
-      attackerRoll: attaque,
-      ids: RollBasicParts.reverseIds(attaque),
-      passeArme: attaque.passeArme ?? foundry.utils.randomID(16)
-    }
 
     const choixDefense = await ChatMessage.create({
       // message privé: du défenseur à lui même (et aux GMs)
       speaker: ChatMessage.getSpeaker(this.defender, canvas.tokens.get(this.defenderTokenId)),
       alias: this.attacker?.getAlias(),
       whisper: ChatUtility.getOwners(this.defender),
-      content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense.hbs', attackerRoll)
+      content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-defense.hbs', defenseData)
     });
     // flag pour garder les jets d'attaque/defense
-    ChatUtility.setMessageData(choixDefense, 'rollData', defense)
+    ChatUtility.setMessageData(choixDefense, 'demande-defense', true)
+    ChatUtility.setMessageData(choixDefense, 'rollData', {
+      ids: defenseData.ids,
+      attackerRoll: RollDialog.saveParts(attackerRoll),
+      passeArme: defenseData.passeArme
+    })
   }
 
   /* -------------------------------------------- */
@@ -1052,7 +1055,7 @@ export class RdDCombat {
     dialog.render(true);
   }
 
-  async defenseV2(attackerRoll) {
+  async defenseV2(attackerRoll, callbacks = []) {
     // this._prepareParade(attackerRoll, arme, competence);
     RollDialog.loadRollData(attackerRoll)
     await this.doRollDefense({
@@ -1065,7 +1068,7 @@ export class RdDCombat {
       type: { allowed: [ROLL_TYPE_DEFENSE], current: ROLL_TYPE_DEFENSE },
       attackerRoll: attackerRoll,
       passeArme: attackerRoll.passeArme,
-    })
+    }, callbacks)
   }
 
   async doRollDefense(rollData, callbacks = []) {

module/rdd-empoignade.js

@@ -4,6 +4,8 @@ import { ChatUtility } from "./chat-utility.js";
 import { RdDRollResult } from "./rdd-roll-result.js";
 import { RdDRoll } from "./rdd-roll.js";
 import { MappingCreatureArme } from "./item/mapping-creature-arme.mjs";
+import { MAP_PHASE } from "./initiative.mjs";
+import { RdDCombatManager } from "./rdd-combat.js";
 
 /* -------------------------------------------- */
 export class RdDEmpoignade {
@@ -12,6 +14,49 @@ export class RdDEmpoignade {
   static init() {
   }
 
+  /* -------------------------------------------- */
+  static isCombatantEmpoignade(actorId, tokenId) {
+    const combatant = RdDCombatManager.getCombatant(actorId, tokenId)
+    return MAP_PHASE.empoignade.rang == combatant?.system.init.rang
+  }
+
+  static async ajustementEmpoignade(attacker, defender, adjust = 1) {
+    const empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
+    const empId = empoignade?.system.empoignadeid ?? foundry.utils.randomID(16)
+    if (empoignade) {
+      if (empoignade.system.empoigneurid == defender.id) {
+        adjust = - adjust
+      }
+      empoignade.system.pointsemp += adjust
+      await RdDEmpoignade.$updateEtatEmpoignade(empoignade, attacker, defender)
+    }
+    else {
+      await RdDEmpoignade.$createEtatEmpoignade({
+        name: `Empoignade de ${attacker.name} sur ${defender.name}`,
+        type: ITEM_TYPES.empoignade,
+        system: {
+          description: "",
+          empoignadeid: empId,
+          empoigneurid: attacker.id,
+          empoigneid: defender.id,
+          pointsemp: adjust,
+          empoigneurname: attacker.name,
+          empoignename: defender.name
+        }
+      }, attacker, defender)
+    }
+    const result = RdDEmpoignade.getEmpoignadeById(defender, empId);
+    const defGrappled = result.system.pointsemp == (result.system.empoigneid == defender.id ? 2 : -2)
+    const attGrappled = result.system.pointsemp == (result.system.empoigneurid == attacker.id ? -2 : 2)
+    const grappling = Math.abs(result.system.pointsemp) > 0
+    await defender.setEffect(STATUSES.StatusGrappling, grappling && !defGrappled)
+    await attacker.setEffect(STATUSES.StatusGrappling, grappling && !attGrappled)
+    await defender.setEffect(STATUSES.StatusGrappled, defGrappled)
+    await attacker.setEffect(STATUSES.StatusGrappled, attGrappled)
+    return result
+  }
+
+
   /* -------------------------------------------- */
   static registerChatCallbacks(html) {
     $(html).on("click", '.defense-empoignade-cac', event => {
@@ -237,10 +282,7 @@ export class RdDEmpoignade {
 
 
     if (rollData.rolled.isSuccess && isNouvelle) {
-      const objectEmpoignade = rollData.empoignade.toObject();
+      RdDEmpoignade.$createEtatEmpoignade(rollData.empoignade)
-      // Creer l'empoignade sur attaquant/defenseur
-      attacker.creerObjetParMJ(objectEmpoignade);
-      defender.creerObjetParMJ(objectEmpoignade);
     }
 
     rollData.empoignade.isSuccess = rollData.rolled.isSuccess;
@@ -259,7 +301,7 @@ export class RdDEmpoignade {
       return
     }
 
-    let empoignade = this.getEmpoignade(attacker, defender)
+    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
 
     if (!empoignade) {
       ui.notifications.warn("Une erreur s'est produite : Aucune empoignade trouvée !!")
@@ -317,18 +359,33 @@ export class RdDEmpoignade {
   }
 
   /* -------------------------------------------- */
-  static async $updateEtatEmpoignade(empoignade) {
+  static async $createEtatEmpoignade(empoignade) {
-    console.log("UPDATE Empoignade", empoignade)
+    console.log("CREATE Empoignade", empoignade)
 
     let defender = game.actors.get(empoignade.system.empoigneid)
-    let emp = RdDEmpoignade.getEmpoignadeById(defender, empoignade.system.empoignadeid)
-    let update = { _id: emp._id, "system.pointsemp": empoignade.system.pointsemp, "system.ausol": empoignade.system.ausol }
-    await defender.updateEmbeddedDocuments('Item', [update])
-
     let attacker = game.actors.get(empoignade.system.empoigneurid)
-    emp = RdDEmpoignade.getEmpoignadeById(attacker, empoignade.system.empoignadeid)
+
-    update = { _id: emp._id, "system.pointsemp": empoignade.system.pointsemp, "system.ausol": empoignade.system.ausol }
+    // Creer l'empoignade sur attaquant/defenseur
-    await attacker.updateEmbeddedDocuments('Item', [update])
+    await attacker.creerObjetParMJ(empoignade)
+    await defender.creerObjetParMJ(empoignade)
+  }
+
+  /* -------------------------------------------- */
+  static async $updateEtatEmpoignade(empoignade, attacker, defender) {
+    console.log("UPDATE Empoignade", empoignade)
+    const belligerants = [
+      attacker ?? game.actors.get(empoignade.system.empoigneurid),
+      defender ?? game.actors.get(empoignade.system.empoigneid)]
+
+    await Promise.all(
+      belligerants.map(async belligerant => {
+        const emp = RdDEmpoignade.getEmpoignadeById(belligerant, empoignade.system.empoignadeid)
+        return await belligerant.updateEmbeddedDocuments('Item', [{
+          _id: emp._id,
+          "system.pointsemp": empoignade.system.pointsemp,
+          "system.ausol": empoignade.system.ausol
+        }])
+      }))
   }
 
   /* -------------------------------------------- */
@@ -347,7 +404,7 @@ export class RdDEmpoignade {
     if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
       return
     }
-    let empoignade = this.getEmpoignade(attacker, defender)
+    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
 
     empoignade.system.ausol = true
     await this.$updateEtatEmpoignade(empoignade)
@@ -366,7 +423,7 @@ export class RdDEmpoignade {
     if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
       return
     }
-    let empoignade = this.getEmpoignade(attacker, defender)
+    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
 
     await defender.setEffect(STATUSES.StatusProne, true);
     await this.$deleteEmpoignade(empoignade)
@@ -382,7 +439,7 @@ export class RdDEmpoignade {
     if (!RdDEmpoignade.isActionAutorisee("immobilise", attacker, defender)) {
       return
     }
-    let empoignade = this.getEmpoignade(attacker, defender)
+    let empoignade = RdDEmpoignade.getEmpoignade(attacker, defender)
 
     //console.log("Perte d'endurance :!!!", perteMode)
     let endValue = defender.system.sante.endurance.value
@@ -423,9 +480,17 @@ export class RdDEmpoignade {
   /* -------------------------------------------- */
   static async createEmpoignade(attacker, defender) {
     return await Item.create({
-      name: "Empoignade en cours de " + attacker.name + ' sur ' + defender.name,
+      name: "Empoignade de " + attacker.name + ' sur ' + defender.name,
-      type: 'empoignade',
+      type: ITEM_TYPES.empoignade,
-      system: { description: "", empoignadeid: foundry.utils.randomID(16), compteempoigne: 0, empoigneurid: attacker.id, empoigneid: defender.id, ptsemp: 0, empoigneurname: attacker.name, empoignename: defender.name }
+      system: {
+        description: "",
+        empoignadeid: foundry.utils.randomID(16),
+        empoigneurid: attacker.id,
+        empoigneid: defender.id,
+        pointsemp: 0,
+        empoigneurname: attacker.name,
+        empoignename: defender.name
+      }
     },
       {
         temporary: true

module/rdd-roll.js

@@ -334,7 +334,7 @@ export class RdDRoll extends Dialog {
     // Mise à jour valeurs
     this.html.find(".dialog-roll-title").text(this._getTitle(rollData));
     this.html.find("input.check-mortalite").prop('checked', rollData.dmg.mortalite == RDD_CONFIG.encaissement.nonmortel);
-    this.html.find("label.dmg-arme-actor").text(rollData.dmg.mortalite == EMPOIGNADE ? EMPOIGNADE : Misc.toSignedString(rollData.dmg.total));
+    this.html.find("label.dmg-arme-actor").text(rollData.dmg.isEmpoignade ? EMPOIGNADE : Misc.toSignedString(rollData.dmg.total));
     this.html.find("label.arme-mortalite").text(rollData.dmg.mortalite);
     this.html.find("div.placeholder-ajustements").empty().append(adjustements);
     this.html.find("div.placeholder-resolution").empty().append(resolutionTable)

module/roll/chat-roll-result.mjs

@@ -5,13 +5,13 @@ import { RdDCombat } from "../rdd-combat.js"
 import { ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE } from "./roll-constants.mjs"
 import { RdDResolutionTable } from "../rdd-resolution-table.js"
 import { RDD_CONFIG, renderTemplate } from "../constants.js"
-import { EMPOIGNADE } from "../item/arme.js"
 import { RdDTextEditor } from "../apps/rdd-text-roll-editor.js"
 import { RollTypeCuisine } from "./roll-type-cuisine.mjs"
 import { RollTypeMeditation } from "./roll-type-meditation.mjs"
 import { PART_DEFENSE } from "./roll-part-defense.mjs"
 import { PART_ATTAQUE } from "./roll-part-attaque.mjs"
 import { RdDRollTables } from "../rdd-rolltables.js"
+import { RdDEmpoignade } from "../rdd-empoignade.js"
 
 export default class ChatRollResult {
   static init() {
@@ -67,7 +67,7 @@ export default class ChatRollResult {
   isShowEncaissement(roll) {
     switch (roll.type.current) {
       case ROLL_TYPE_DEFENSE:
-        return roll.rolled.isEchec && roll.attackerRoll?.dmg.mortalite != EMPOIGNADE
+        return roll.rolled.isEchec
     }
     return false
   }
@@ -132,6 +132,7 @@ export default class ChatRollResult {
   async chatListeners(html) {
     $(html).on("click", '.appel-chance', event => this.onClickAppelChance(event))
     $(html).on("click", '.appel-destinee', event => this.onClickAppelDestinee(event))
+    $(html).on("click", '.button-defense', event => this.onClickDefense(event))
     $(html).on("click", '.encaissement', event => this.onClickEncaissement(event))
     $(html).on("click", '.resister-recul', event => this.onClickRecul(event))
     $(html).on("click", '.choix-particuliere', event => this.onClickChoixParticuliere(event))
@@ -219,19 +220,42 @@ export default class ChatRollResult {
     })
   }
 
-  async onClickEncaissement(event) {
+  async onClickDefense(event) {
     const chatMessage = ChatUtility.getChatMessage(event)
     const savedRoll = this.loadChatMessageRoll(chatMessage)
+    const attackerRoll = savedRoll.attackerRoll
+    this.getCombat(attackerRoll)?.defenseV2(attackerRoll,
+      [roll => { ChatUtility.removeChatMessageId(chatMessage.id) }]
+    )
+  }
+
+  async onClickEncaissement(event) {
+    const chatMessage = ChatUtility.getChatMessage(event)
+    const isMessageDemande = ChatUtility.getMessageData(chatMessage, 'demande-defense')
+    const savedRoll = this.loadChatMessageRoll(chatMessage)
     const attaque = savedRoll.attackerRoll
-    const defender = game.actors.get(savedRoll.ids.actorId)
-    const attacker = game.actors.get(savedRoll.ids.opponentId)
     const defenderToken = savedRoll.ids.actorTokenId ? canvas.tokens.get(savedRoll.ids.actorTokenId) : undefined
     const attackerToken = savedRoll.ids.opponentTokenId ? canvas.tokens.get(savedRoll.ids.opponentTokenId) : undefined
+    switch (attaque.dmg.mortalite) {
+      case RDD_CONFIG.encaissement.empoignade:
+        savedRoll.done = savedRoll.done ?? {}
+        savedRoll.done.empoignade = await RdDEmpoignade.ajustementEmpoignade(attackerToken.actor, defenderToken.actor)
+        break
+      case RDD_CONFIG.encaissement.entiteincarnee:
+      case RDD_CONFIG.encaissement.nonmortel:
+      case RDD_CONFIG.encaissement.mortel:
+        const defender = defenderToken?.actor ?? game.actors.get(savedRoll.ids.actorId)
+        const attacker = attackerToken?.actor ?? game.actors.get(savedRoll.ids.opponentId)
         await defender?.encaisserDommages(attaque.dmg, attacker, undefined, attackerToken, defenderToken)
-
+        break
+    }
+    if (isMessageDemande) {
+      ChatUtility.removeChatMessageId(chatMessage.id)
+    } else {
       savedRoll.done.encaissement = true
       await this.updateChatMessage(chatMessage, savedRoll)
     }
+  }
 
   async onClickRecul(event) {
     const chatMessage = ChatUtility.getChatMessage(event)

module/roll/roll-basic-parts.mjs

@@ -54,13 +54,27 @@ export class RollBasicParts {
     }
   }
 
+  static prepareDefense(attackerRoll) {
+    if (!attackerRoll.passeArme) {
+      attackerRoll.passeArme = foundry.utils.randomID(16);
+    }
+    return {
+      ids: RollBasicParts.reverseIds(attackerRoll),
+      active: attackerRoll.opponent,
+      opponent: attackerRoll.active,
+      attackerRoll: attackerRoll,
+      passeArme: attackerRoll.passeArme,
+      show: { encaissement: true }
+    }
+  }
+
   static reverseIds(rollData) {
     return {
       sceneId: rollData.ids.sceneId,
       actorId: rollData.ids.opponentId,
       actorTokenId: rollData.ids.opponentTokenId,
       opponentId: rollData.ids.actorId,
-      opponentTokenId: rollData.actorTokenId
+      opponentTokenId: rollData.ids.actorTokenId
     }
   }
 

module/roll/roll-dialog-adapter.mjs

@@ -124,7 +124,7 @@ export class RollDialogAdapter {
 
     const attaque = rollData.current.attaque;
     const choix = []
-    const isEmpoignade = attaque.dmg.mortalite == 'empoignade';
+    const isEmpoignade = attaque.dmg.isEmpoignade
     const isCharge = attaque.tactique == 'charge'
     /* TODO: cas de créatures faisant des lancers, Glou, Glipzouk */
     const isMeleeDiffNegative = (attaque.comp.type == ITEM_TYPES.competencecreature || rollData.current.carac.key == CARACS.MELEE)

module/roll/roll-dialog.mjs

@@ -44,6 +44,7 @@ import { RollTypeCuisine } from "./roll-type-cuisine.mjs";
 import { RollPartCuisine } from "./roll-part-cuisine.mjs";
 import { OptionsAvancees, ROLL_DIALOG_V2_TEST } from "../settings/options-avancees.js";
 import { ActorImpacts } from "../technical/actor-impacts.mjs";
+import { RollPartEmpoignade } from "./roll-part-empoignade.mjs";
 
 
 const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api
@@ -85,6 +86,7 @@ const ROLL_PARTS = [
   new RollPartConditions(),
   new RollPartEthylisme(),
   new RollPartMalusArmure(),
+  new RollPartEmpoignade(),
   new RollPartEncTotal(),
   new RollPartSurEnc(),
   new RollPartAppelMoral(),

module/roll/roll-part-attaque.mjs

@@ -1,6 +1,10 @@
 import { RDD_CONFIG } from "../constants.js"
+import { ATTAQUE_TYPE_MELEE } from "../item/arme.js"
 import { RdDBonus } from "../rdd-bonus.js"
-import { DIFF, ROLL_TYPE_ATTAQUE } from "./roll-constants.mjs"
+import { CARACS } from "../rdd-carac.js"
+import { RdDEmpoignade } from "../rdd-empoignade.js"
+import { DIFF, ROLL_TYPE_ATTAQUE, ROLL_TYPE_COMP } from "./roll-constants.mjs"
+import RollDialog from "./roll-dialog.mjs"
 import { PART_CARAC } from "./roll-part-carac.mjs"
 import { PART_COMP } from "./roll-part-comp.mjs"
 import { PART_DIFF } from "./roll-part-diff.mjs"
@@ -12,6 +16,10 @@ export const PART_ATTAQUE = 'attaque'
 
 const TACTIQUES = RdDBonus.tactiques.filter(it => it.isTactique)
 
+const FILTER_ATTAQUE_EMPOIGNADE = attaque => attaque.arme.isEmpoignade()
+const FILTER_ATTAQUE_NON_EMPOIGNADE = attaque => !attaque.arme.isEmpoignade()
+const FILTER_ATTAQUE_EMPOIGNE = attaque => attaque.arme.isUtilisableEmpoigne() && ATTAQUE_TYPE_MELEE.includes(attaque.main)
+
 export class RollPartAttaque extends RollPartSelect {
 
   get code() { return PART_ATTAQUE }
@@ -22,7 +30,8 @@ export class RollPartAttaque extends RollPartSelect {
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)
     const attaques = rollData.active.actor.listAttaques()
-    refs.attaques = attaques.map(it => RollPartAttaque.$extractAttaque(it, rollData.active.actor))
+    refs.all = attaques.map(it => RollPartAttaque.$extractAttaque(it, rollData.active.actor))
+    this.filterAttaquesEmpoignade(rollData)
     refs.tactiques = TACTIQUES
     if (refs.attaques.length > 0) {
       const attaque = this.findAttaque(refs.attaques, this.getSaved(rollData))
@@ -30,6 +39,10 @@ export class RollPartAttaque extends RollPartSelect {
     }
   }
 
+  isAttaqueEmpoignade(it) {
+    return it.arme.isEmpoignade()
+  }
+
   store(rollData, targetData) {
     super.store(rollData, targetData)
     this.getSaved(targetData).dmg = this.getCurrent(rollData).dmg
@@ -59,10 +72,23 @@ export class RollPartAttaque extends RollPartSelect {
   }
 
   prepareContext(rollData) {
+    this.filterAttaquesEmpoignade(rollData)
     const current = this.getCurrent(rollData)
     current.dmg = RdDBonus.dmgRollV2(rollData, current)
   }
 
+  filterAttaquesEmpoignade(rollData) {
+    const refs = this.getRefs(rollData)
+    const isEmpoignade = RdDEmpoignade.isCombatantEmpoignade(rollData.ids.actorId, rollData.ids.actorTokenId)
+    refs.isEmpoignadeEnCours = RdDEmpoignade.isEmpoignadeEnCours(rollData.active.actor)
+    const filterAttaques = isEmpoignade ?
+      FILTER_ATTAQUE_EMPOIGNADE
+      : refs.isEmpoignadeEnCours
+        ? FILTER_ATTAQUE_EMPOIGNE
+        : FILTER_ATTAQUE_NON_EMPOIGNADE
+    refs.attaques = refs.all.filter(filterAttaques)
+  }
+
   getAjustements(rollData) {
     const current = this.getCurrent(rollData)
     const tactique = current.tactique ? [{ label: current.tactique.label, value: current.tactique.attaque }] : []
@@ -79,6 +105,7 @@ export class RollPartAttaque extends RollPartSelect {
     const selectAttaque = rollDialog.element.querySelector(`roll-section[name="${this.code}"] select[name="select-attaque"]`)
     const selectTactique = rollDialog.element.querySelector(`roll-section[name="${this.code}"] select[name="select-tactique"]`)
     const checkMortalite = rollDialog.element.querySelector(`roll-section[name="${this.code}"] input[name="check-mortalite"]`)
+    const utiliserDagueEmpoignade = rollDialog.element.querySelector(`roll-section[name="${this.code}"] a.utiliser-dague-empoignade`)
     const current = this.getCurrent(rollDialog.rollData)
 
     selectAttaque.addEventListener("change", e => {
@@ -99,6 +126,23 @@ export class RollPartAttaque extends RollPartSelect {
       current.dmg.mortalite = (e.currentTarget.checked ? RDD_CONFIG.encaissement.mortel : RDD_CONFIG.encaissement.nonmortel)
       rollDialog.render()
     })
+    utiliserDagueEmpoignade?.addEventListener("click", e => {
+      e.preventDefault()
+      const rollData = rollDialog.rollData
+      this.utiliserDagueEmpoignade(rollData)
+    })
+  }
+
+  utiliserDagueEmpoignade(rollData) {
+    RollDialog.create({
+      ids: { actorId: rollData.ids.actorId, actorTokenId: rollData.ids.actorTokenId },
+      type: { allowed: [ROLL_TYPE_COMP], current: ROLL_TYPE_COMP },
+      selected: {
+        carac: { key: CARACS.DEXTERITE, forced: true },
+        comp: { key: 'Dague', forced: true },
+        diff: { type: DIFF.IMPOSEE, value: -4 }
+      }
+    })
   }
 
   impactOtherPart(part, rollData) {

module/roll/roll-part-carac.mjs

@@ -1,3 +1,4 @@
+import { Grammar } from "../grammar.js"
 import { RollPartSelect } from "./roll-part-select.mjs"
 import { ROLLDIALOG_SECTION } from "./roll-part.mjs"
 
@@ -12,8 +13,14 @@ export class RollPartCarac extends RollPartSelect {
 
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)
+    const selected = this.getSelected(rollData)
     const actor = rollData.active.actor
     refs.all = [...this.$getActorCaracs(actor), ...this.$getCaracCompetenceCreature(actor)]
+      .filter(c => !selected.forced ||
+            (selected.key ?
+              Grammar.includesLowerCaseNoAccent(c.label, selected.key)
+              : c.key == '')
+          )
     refs.caracs = refs.all
     this.$selectCarac(rollData)
   }

module/roll/roll-part-comp.mjs

@@ -18,12 +18,16 @@ export class RollPartComp extends RollPartSelect {
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)
     const selected = this.getSelected(rollData)
-    refs.all = this.$getActorComps(rollData)
+    const all = this.$getActorComps(rollData)
-      .filter(comp => !selected.forced ||
+    if (selected.forced) {
-        (selected.key ?
+      refs.all = all.filter(comp => Grammar.equalsInsensitive(comp.label, selected.key))
-          Grammar.includesLowerCaseNoAccent(comp.name, selected.key)
+      if (refs.all.length == 0) {
-          : comp.key == '')
+        refs.all = all.filter(comp => Grammar.includesLowerCaseNoAccent(comp.label, selected.key))
-      )
+      }
+    }
+    else {
+      refs.all = all
+    }
     refs.comps = refs.all
     this.$selectComp(rollData)
   }

module/roll/roll-part-defense.mjs

@@ -1,4 +1,4 @@
-import { ITEM_TYPES } from "../constants.js"
+import { ITEM_TYPES, RDD_CONFIG } from "../constants.js"
 import { ATTAQUE_TYPE, RdDItemArme } from "../item/arme.js"
 import { CARACS } from "../rdd-carac.js"
 import { DIFF, ROLL_TYPE_DEFENSE } from "./roll-constants.mjs"
@@ -15,6 +15,8 @@ export class RollPartDefense extends RollPartSelect {
 
   get code() { return PART_DEFENSE }
   get section() { return ROLLDIALOG_SECTION.CHOIX }
+
+  isValid(rollData) { return rollData.attackerRoll != undefined }
   visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_DEFENSE) }
 
   static getDiffAttaque(attackerRoll) {
@@ -27,13 +29,22 @@ export class RollPartDefense extends RollPartSelect {
     const attackerRoll = rollData.attackerRoll
     const defenseur = rollData.active.actor
     refs.isDistance = [ATTAQUE_TYPE.TIR, ATTAQUE_TYPE.LANCER].find(it => it == attackerRoll?.main)
-    const esquives = refs.isDistance == ATTAQUE_TYPE.TIR ? [] : defenseur.getCompetencesEsquive()
+    const isEmpoignade = attackerRoll.dmg.isEmpoignade
-      .map(it => RollPartDefense.$extractEsquive(it, defenseur))
+    const isEmpoignadeEnCours = isEmpoignade && defenseur.itemTypes[ITEM_TYPES.empoignade].find(it =>
+      [it.system.empoigneurid, it.system.empoigneid].includes(rollData.ids.opponentId) &&
+      it.system.pointsemp != 0)
 
-    const parades = defenseur.items.filter(it => it.isParade() && (!refs.isDistance || it.isBouclier()))
+    const esquives = (refs.isDistance == ATTAQUE_TYPE.TIR || isEmpoignadeEnCours)
-      .map(it => RollPartDefense.$extractParade(it, attackerRoll?.arme, defenseur))
+      ? []
+      : defenseur.getCompetencesEsquive()
+    const parades = isEmpoignade
+      ? [RdDItemArme.empoignade(defenseur)]
+      : defenseur.items.filter(it => it.isParade() && (!refs.isDistance || it.isBouclier()))
 
-    refs.defenses = [...esquives, ...parades].filter(it => it != undefined)
+    refs.defenses = [
+      ...esquives.map(it => RollPartDefense.$extractEsquive(it, defenseur)),
+      ...parades.map(it => RollPartDefense.$extractParade(it, attackerRoll?.arme, defenseur))
+    ]
     this.$selectDefense(rollData)
   }
 

module/roll/roll-part-empoignade.mjs

@@ -0,0 +1,31 @@
+import { RDD_CONFIG } from "../constants.js"
+import { ATTAQUE_TYPE_MELEE } from "../item/arme.js"
+import { RdDEmpoignade } from "../rdd-empoignade.js"
+import { ROLL_TYPE_ATTAQUE } from "./roll-constants.mjs"
+import { PART_ATTAQUE } from "./roll-part-attaque.mjs"
+import { RollPartCheckbox } from "./roll-part-checkbox.mjs"
+
+const EMPOIGNADE = "empoignade"
+
+export class RollPartEmpoignade extends RollPartCheckbox {
+
+  get code() { return EMPOIGNADE }
+
+  isValid(rollData) {
+    return RdDEmpoignade.isCombatantEmpoignade(rollData.ids.opponentId, rollData.ids.opponentTokenId) &&
+      !RdDEmpoignade.isCombatantEmpoignade(rollData.ids.actorId, rollData.ids.actorTokenId)
+  }
+
+  visible(rollData) {
+    return rollData.type.current == ROLL_TYPE_ATTAQUE &&
+      ATTAQUE_TYPE_MELEE.includes(rollData.current[PART_ATTAQUE].main) &&
+      RdDEmpoignade.isCombatantEmpoignade(rollData.ids.opponentId, rollData.ids.opponentTokenId) &&
+      !RdDEmpoignade.isCombatantEmpoignade(rollData.ids.actorId, rollData.ids.actorTokenId) &&
+      !RdDEmpoignade.isEmpoignadeEnCours(rollData.active.actor)
+  }
+  
+
+  getCheckboxIcon(rollData) { return `<img src="${RDD_CONFIG.icons.empoignade}">` }
+  getCheckboxLabel(rollData) { return "vs. empoigneur" }
+  getCheckboxValue(rollData) { return 4 }
+}

module/roll/roll-type.mjs

@@ -47,6 +47,7 @@ export class RollType {
   }
 
   setDiffType(rollData, type) {
+    type = rollData.selected[PART_DIFF].type ?? type
     rollData.current[PART_DIFF].type = type
     this.setRollDataType(rollData)
   }

module/settings/status-effects.js

@@ -22,8 +22,8 @@ export const demiReveStatusEffect = {
   rdd: true, id: STATUSES.StatusDemiReve, name: 'EFFECT.StatusDemiReve', img: RDD_CONFIG.icons.demiReve
 };
 const rddStatusEffects = [
-  { rdd: true, id: STATUSES.StatusGrappling, tint: '#33cc33', name: 'EFFECT.StatusGrappling', img: RDD_CONFIG.icons.empoignade },
+  { rdd: true, id: STATUSES.StatusGrappling, name: 'EFFECT.StatusGrappling', img: RDD_CONFIG.icons.empoignade },
-  { rdd: true, id: STATUSES.StatusGrappled, tint: '#ff9900', name: 'EFFECT.StatusGrappled', img: RDD_CONFIG.icons.empoignade },
+  { rdd: true, id: STATUSES.StatusGrappled, tint: '#d5633d', name: 'EFFECT.StatusGrappled', img: RDD_CONFIG.icons.empoignade },
 
   { rdd: true, id: STATUSES.StatusRestrained, name: 'EFFECT.StatusRestrained', img: 'icons/svg/net.svg' },
   { rdd: true, id: STATUSES.StatusStunned, name: 'EFFECT.StatusStunned', img: 'icons/svg/stoned.svg', "duration.rounds": 1 },
@@ -45,8 +45,9 @@ const statusSurpriseTotale = new Set([STATUSES.StatusUnconscious, STATUSES.Statu
 export class StatusEffects extends FormApplication {
 
   static onReady() {
-    const rddEffectIds = rddStatusEffects.map(it => it.id);
+    const rddEffectIds = rddStatusEffects.map(it => it.id)
     rddStatusEffects.forEach(it => {
+      it.name = game.i18n.localize(it.name)
       it.statuses = new Set([it.id])
     })
     const defaultStatusEffectIds = CONFIG.statusEffects.map(it => it.id);

templates/chat-demande-defense.hbs

@@ -1,25 +1,24 @@
-{{log this}}
 <div class="roll-chat" data-passearme="{{passeArme}}">
   <div class="chat-img">
-    <img src="{{opponent.img}}" data-tooltip="{{opponent.name}}" />
+    <img src="{{active.img}}" data-tooltip="{{active.name}}" />
   </div>
 
   <div class="chat-header">
-    <h4>Défense de  {{opponent.name}}</h4>
+    <h4>Défense de {{active.name}}</h4>
   </div>
 
   <div class="chat-resume">
-    {{#if (eq opponent.surprise.key 'totale')}}
+    {{#if (eq active.surprise.key 'totale')}}
-      <span><strong>{{opponent.name}}</strong> est totalement surpris</span>
+      <span><strong>{{active.name}}</strong> est totalement surpris</span>
     {{else}}
-      <span><strong>{{opponent.name}}</strong> doit se défendre
+      <span><strong>{{active.name}}</strong> doit se défendre
-        {{~#if (eq opponent.surprise.key 'demi')}} avec une significative {{/if}} d'une attaque
+        {{~#if (eq active.surprise.key 'demi')}} avec une significative {{/if}} d'une attaque
-        {{~#if particuliere}} <strong>particulière en
+        {{~#if attackerRoll.particuliere}} <strong>particulière en
-          {{~#if (eq particuliere 'finesse')}} finesse
+          {{~#if (eq attackerRoll.particuliere 'finesse')}} finesse
           {{else if (eq particuliere 'force')}} force
           {{else if (eq particuliere 'rapidite')}} rapidité
           {{/if~}}</strong>
-        {{/if}} de {{active.name}} ({{current.attaque.label}}):
+        {{/if}} de {{opponent.name}} ({{attackerRoll.current.attaque.label}}):
       </span>
     {{/if}}
   </div>
@@ -28,30 +27,23 @@
   </div>
 
   <div class="chat-actions">
-    {{#unless (eq opponent.surprise.key 'totale')}}
+    {{#unless (eq active.surprise.key 'totale')}}
       <a class='chat-card-button button-defense'
-              data-attackerId='{{ids.actorId}}'
+              data-attackerId='{{ids.opponentId}}'
-              data-attackerTokenId='{{ids.actorTokenId}}'
+              data-attackerTokenId='{{ids.opponentTokenId}}'
-              data-defenderTokenId='{{ids.opponentTokenId}}'
+              data-defenderId='{{ids.actorId}}'
+              data-defenderTokenId='{{ids.actorTokenId}}'
             >
       <img src="systems/foundryvtt-reve-de-dragon/assets/actions/defense.svg"/>
             Se défendre
-            {{#if (or (eq attaqueCategorie 'tir') (eq attaqueCategorie 'lancer'))}}
+            {{#if (or (eq attackerRoll.attaqueCategorie 'tir') (eq attackerRoll.attaqueCategorie 'lancer'))}}
               (difficulté à déterminer)
             {{else}}
-              à {{current.diff.value}}
+              à {{attackerRoll.current.diff.value}}
             {{/if}}
       </a>
     {{/unless}}
-    {{#unless (eq dmg.mortalite 'empoignade')}}
+    {{> 'partial-encaissement'}}
-      <a class='chat-card-button encaissement' 
-              data-tooltip="Encaisser à {{plusMoins dmg.total}} {{#if (eq dmg.mortalite 'non-mortel')~}}(non-mortel){{/if}}"
-            >
-        <img src="systems/foundryvtt-reve-de-dragon/assets/ui/encaisser.svg"/>
-        Encaisser à {{plusMoins dmg.total}}
-        {{#if (eq dmg.mortalite 'non-mortel')~}}(non-mortel){{/if}}
-      </a>
-    {{/unless}}
   </div>
 
   <div class="chat-buttons">

templates/roll/result/partial-encaissement.hbs

@@ -1,15 +1,29 @@
+{{log 'partial-encaissement' this}}
 {{#if show.encaissement}}
   {{#if done.encaissement}}
     <span class='chat-card-info'>
-    <img src="systems/foundryvtt-reve-de-dragon/assets/ui/encaisser.svg"/>
+    {{#if (eq attackerRoll.dmg.mortalite 'empoignade')}}
+      <img src="systems/foundryvtt-reve-de-dragon/assets/actions/empoignade.svg"/>
+      {{opponent.name}} a {{done.empoignade.system.pointsemp}} point d'empoignade contre {{active.name}}.
+      {{#if (gt done.empoignade.system.pointsemp 2)}} Si {{active.name}} ne se libère pas, il sera immobilisé à la fin du round{{/if}}
+    {{else}}
+      <img src="systems/foundryvtt-reve-de-dragon/assets/actions/encaisser.svg"/>
       {{active.name}} a encaissé
+    {{/if}}
     </span>
+  {{else}}
+    {{#if (eq attackerRoll.dmg.mortalite 'empoignade')}}
+      <a class='chat-card-button encaissement' data-tooltip="Marquer un point d'empoignade">
+        <img src="systems/foundryvtt-reve-de-dragon/assets/actions/empoignade.svg"/>
+        Marquer un point d'empoignade
+      </a>
     {{else}}
       <a class='chat-card-button encaissement' 
         data-tooltip="Encaisser à {{plusMoins attackerRoll.dmg.total}} {{#if (eq attackerRoll.dmg.mortalite 'non-mortel')~}}(non-mortel){{/if}}"
         >
-    <img src="systems/foundryvtt-reve-de-dragon/assets/ui/encaisser.svg"/> Encaisser à {{plusMoins attackerRoll.dmg.total}}
+        <img src="systems/foundryvtt-reve-de-dragon/assets/actions/encaisser.svg"/> Encaisser à {{plusMoins attackerRoll.dmg.total}}
         {{#if (eq attackerRoll.dmg.mortalite 'non-mortel')~}}(non-mortel){{/if}}
       </a>
     {{/if}}
+  {{/if}}
 {{/if}}

templates/roll/roll-part-attaque.hbs

@@ -15,10 +15,23 @@
       {{selectOptions refs.tactiques selected=current.tactique.key valueAttr="key" labelAttr="label"}}
     </select>
   </subline>
+  {{#if (and refs.isEmpoignadeEnCours (eq current.arme.system.competence 'Dague'))}}
     <subline>
+      <span>
+      Pour pouvoir attaquer avec une dague en cours d'empoignade, il faut réussir:<br>
+      <a class='chat-card-button utiliser-dague-empoignade'>DEXTÉRITÉ / Dague à -4</a>
+      <br>En cas d'échec total, {{rollData.active.name}} sera désarmé.
+      </span>
+    </subline>
+  {{/if}}
   {{#if (eq current.arme.system.mortalite 'empoignade')}}
-      Empoignade, pas de dommages directs
+    <subline>
+      Empoignade, pas de dommages directs.<br>
+      Si {{either rollData.opponent.name}} est équipé d'une arme de mêlée, ou attaque
+      à mains nues (pugilat), il bénéficie d'un bonus de +4 à son attaque.
+    </subline>
   {{else}}
+    <subline>
     {{#if (and (ne current.arme.system.mortalite 'non-mortel') (eq current.dmg.penetration 0))}}
       <input name="check-mortalite" type="checkbox" {{#if (eq current.dmg.mortalite 'mortel')}}checked{{/if}} />
     {{/if}}
@@ -26,8 +39,8 @@
         Dommages: {{plusMoins current.dmg.total}} ({{current.dmg.mortalite}})
         {{~#if current.dmg.penetration}}, pénétration {{current.dmg.penetration}}{{/if}}
       </label>
-    {{/if}}
     </subline>
+  {{/if}}
   {{#if rollData.active.effets}}
   <subline>
     <span class="status-surprise">