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

@@ -9,6 +9,12 @@
 - Nouvelle fenêtre de jets de dés
   - Attaque/défense des créatures
   - les attaques/parades avec une arme trop lourde se font en demi-surprise
+  - 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
 
 ## 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;
@@ -229,7 +229,7 @@ export class RdDActor extends RdDBaseActorSang {
       })
 
     addAttaque(RdDItemArme.pugilat(this), ATTAQUE_TYPE.CORPS_A_CORPS)
-    addAttaque(RdDItemArme.empoignade(this), ATTAQUE_TYPE.CORPS_A_CORPS, 'empoignade')
+    addAttaque(RdDItemArme.empoignade(this), ATTAQUE_TYPE.CORPS_A_CORPS)
 
     return actions
   }

module/actor/base-actor-reve.js

@@ -204,6 +204,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];
   }

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-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();

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,40 @@ 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)
+    if (empoignade) {
+      if (empoignade.system.empoigneurid == defender.id) {
+        adjust = - adjust
+      }
+      empoignade.system.pointsemp += adjust
+      RdDEmpoignade.$updateEtatEmpoignade(empoignade)
+    }
+    else {
+      RdDEmpoignade.$createEtatEmpoignade( {
+        name: `Empoignade de ${attacker.name} sur ${defender.name}`,
+        type: ITEM_TYPES.empoignade,
+        system: {
+          description: "",
+          empoignadeid: foundry.utils.randomID(16),
+          empoigneurid: attacker.id,
+          empoigneid: defender.id,
+          pointsemp: adjust,
+          empoigneurname: attacker.name,
+          empoignename: defender.name
+        }
+      }
+)
+    }
+  }
+
+
   /* -------------------------------------------- */
   static registerChatCallbacks(html) {
     $(html).on("click", '.defense-empoignade-cac', event => {
@@ -237,10 +273,7 @@ export class RdDEmpoignade {
 
 
     if (rollData.rolled.isSuccess && isNouvelle) {
-      const objectEmpoignade = rollData.empoignade.toObject();
-      // Creer l'empoignade sur attaquant/defenseur
-      attacker.creerObjetParMJ(objectEmpoignade);
-      defender.creerObjetParMJ(objectEmpoignade);
+      RdDEmpoignade.$createEtatEmpoignade(rollData.empoignade)
     }
 
     rollData.empoignade.isSuccess = rollData.rolled.isSuccess;
@@ -259,7 +292,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 !!")
@@ -316,6 +349,18 @@ export class RdDEmpoignade {
     }
   }
 
+  /* -------------------------------------------- */
+  static async $createEtatEmpoignade(empoignade) {
+    console.log("CREATE Empoignade", empoignade)
+
+    let defender = game.actors.get(empoignade.system.empoigneid)
+    let attacker = game.actors.get(empoignade.system.empoigneurid)
+
+    // Creer l'empoignade sur attaquant/defenseur
+    await attacker.creerObjetParMJ(empoignade)
+    await defender.creerObjetParMJ(empoignade)
+  }
+
   /* -------------------------------------------- */
   static async $updateEtatEmpoignade(empoignade) {
     console.log("UPDATE Empoignade", empoignade)
@@ -347,7 +392,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 +411,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 +427,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 +468,17 @@ export class RdDEmpoignade {
   /* -------------------------------------------- */
   static async createEmpoignade(attacker, defender) {
     return await Item.create({
-      name: "Empoignade en cours de " + attacker.name + ' sur ' + defender.name,
-      type: 'empoignade',
-      system: { description: "", empoignadeid: foundry.utils.randomID(16), compteempoigne: 0, empoigneurid: attacker.id, empoigneid: defender.id, ptsemp: 0, empoigneurname: attacker.name, empoignename: defender.name }
+      name: "Empoignade de " + attacker.name + ' sur ' + defender.name,
+      type: ITEM_TYPES.empoignade,
+      system: {
+        description: "",
+        empoignadeid: foundry.utils.randomID(16),
+        empoigneurid: attacker.id,
+        empoigneid: defender.id,
+        pointsemp: 0,
+        empoigneurname: attacker.name,
+        empoignename: defender.name
+      }
     },
       {
         temporary: true

module/roll/chat-roll-result.mjs

@@ -12,6 +12,7 @@ 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() {
@@ -133,6 +134,7 @@ export default class ChatRollResult {
     $(html).on("click", '.appel-chance', event => this.onClickAppelChance(event))
     $(html).on("click", '.appel-destinee', event => this.onClickAppelDestinee(event))
     $(html).on("click", '.encaissement', event => this.onClickEncaissement(event))
+    $(html).on("click", '.point-empoignade', event => this.onClickMarquerEmpoignade(event))
     $(html).on("click", '.resister-recul', event => this.onClickRecul(event))
     $(html).on("click", '.choix-particuliere', event => this.onClickChoixParticuliere(event))
     $(html).on("click", '.faire-gouter', event => this.onClickFaireGouter(event))
@@ -233,6 +235,15 @@ export default class ChatRollResult {
     await this.updateChatMessage(chatMessage, savedRoll)
   }
 
+  async onClickMarquerEmpoignade(event) {
+    const chatMessage = ChatUtility.getChatMessage(event)
+    const savedRoll = this.loadChatMessageRoll(chatMessage)
+    const attaque = savedRoll.attackerRoll
+    const attackerToken = attaque.ids.actorTokenId ? canvas.tokens.get(attaque.ids.actorTokenId) : undefined
+    const defenderToken = attaque.ids.opponentTokenId ? canvas.tokens.get(attaque.ids.opponentTokenId) : undefined
+    RdDEmpoignade.ajustementEmpoignade(attackerToken.actor, defenderToken.actor)
+  }
+
   async onClickRecul(event) {
     const chatMessage = ChatUtility.getChatMessage(event)
     const savedRoll = this.loadChatMessageRoll(chatMessage)

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.mortalite == RDD_CONFIG.encaissement.empoignade
     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)
-      .filter(comp => !selected.forced ||
-        (selected.key ?
-          Grammar.includesLowerCaseNoAccent(comp.name, selected.key)
-          : comp.key == '')
-      )
+    const all = this.$getActorComps(rollData)
+    if (selected.forced) {
+      refs.all = all.filter(comp => Grammar.equalsInsensitive(comp.label, selected.key))
+      if (refs.all.length == 0) {
+        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-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)
   }

templates/chat-demande-defense.hbs

@@ -43,15 +43,20 @@
             {{/if}}
       </a>
     {{/unless}}
-    {{#unless (eq dmg.mortalite 'empoignade')}}
+    {{#if (eq dmg.mortalite 'empoignade')}}
+      <a class='chat-card-button point-empoignade' data-tooltip="Subir un point d'empoignade">
+        <img src="systems/foundryvtt-reve-de-dragon/assets/actions/empoignade.svg"/>
+        Marquer le point d'empoignade
+      </a>
+    {{else}}
       <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"/>
+        <img src="systems/foundryvtt-reve-de-dragon/assets/actions/encaisser.svg"/>
         Encaisser à {{plusMoins dmg.total}}
         {{#if (eq dmg.mortalite 'non-mortel')~}}(non-mortel){{/if}}
       </a>
-    {{/unless}}
+    {{/if}}
   </div>
 
   <div class="chat-buttons">

templates/roll/result/partial-encaissement.hbs

@@ -1,14 +1,14 @@
 {{#if show.encaissement}}
   {{#if done.encaissement}}
   <span class='chat-card-info'>
-    <img src="systems/foundryvtt-reve-de-dragon/assets/ui/encaisser.svg"/>
+    <img src="systems/foundryvtt-reve-de-dragon/assets/actions/encaisser.svg"/>
     {{active.name}} a encaissé
   </span>
   {{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}}

templates/roll/roll-part-attaque.hbs

@@ -15,19 +15,32 @@
       {{selectOptions refs.tactiques selected=current.tactique.key valueAttr="key" labelAttr="label"}}
     </select>
   </subline>
-  <subline>
-    {{#if (eq current.arme.system.mortalite 'empoignade')}}
-      Empoignade, pas de dommages directs
-    {{else}}
-      {{#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}}
+  {{#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')}}
+    <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}}
       <label for="check-mortalite">
         Dommages: {{plusMoins current.dmg.total}} ({{current.dmg.mortalite}})
         {{~#if current.dmg.penetration}}, pénétration {{current.dmg.penetration}}{{/if}}
       </label>
-    {{/if}}
-  </subline>
+    </subline>
+  {{/if}}
   {{#if rollData.active.effets}}
   <subline>
     <span class="status-surprise">