Merge pull request 'v13' (#771) from VincentVk/foundryvtt-reve-de-dragon:v13 into v13

Reviewed-on: #771
2025-09-26 10:54:39 +02:00
parent c84af21c7e d26ab59c51
commit 160f10a639
69 changed files with 580 additions and 480 deletions
--- a/changelog.md
+++ b/changelog.md
@@ -3,19 +3,24 @@
 ## 13.0.9 - Le combat d'Illysis
 - Fix
  - La montée en TMR fonctionne
+- ajout d'un status "Force insuffisante"
+- clarification des maladresses à l'attaque (en demi surprise, ou à cause d'un échec total)
 - Nouvelle fenêtre de jets de dés
+  - ajout du statut "Force insuffisante" aux acteurs si la 
+    force est insuffisante pour l'arme
  - avancement du mode attaque
    - choix de tactique
-    - choix des dommages mortel/non-mortel, affichage
+    - choix mortel/non-mortel pour les dommages
+    - affichage des dommages ajustés delon les choix
    - affichage du statut de surprise de l'attaquant
    - affichage du statut de surprise du défenseur
-    - prise en compte des significatives (force insuffisante, demi-surprises)
+    - prise en compte des significatives (demi-surprises)
  - avancement du mode défense
    - sélection esquive/parade
    - affichage du statut de surprise du défenseur
    - prise en compte des significatives (demi-surprises, armes disparates,
-      force insuffisante, particulière en finesse)
-
+      particulière en finesse)
+  - impossible de faire un jet "actif" en surprise totale (attaque, parade, ...)

 ## 13.0.8 - Le renouveau d'Illysis

--- a/css/foundryvtt-reve-de-dragon.css
+++ b/css/foundryvtt-reve-de-dragon.css
@@ -424,7 +424,7 @@ select,
 .system-foundryvtt-reve-de-dragon .roll-dialog {
  font-family: CaslonAntique;
  display: grid;
-  grid-template-areas: "header header     header     header     header     header     header" "action action     action     action     action     action     action" "mode   separation separation separation separation separation separation" "mode   carac      carac      carac      comp       comp       resume" "mode   choix      choix      choix      choix      choix      modifiers" "mode   resolution resolution resolution resolution resolution modifiers" "mode   chances    chances    chances    chances    chances    buttons" "footer footer     footer     footer     footer     footer     footer";
+  grid-template-areas: "header header     header     header     header     header     header" "action action     action     action     action     action     action" "type   separation separation separation separation separation separation" "type   carac      carac      carac      comp       comp       resume" "type   choix      choix      choix      choix      choix      modifiers" "type   resolution resolution resolution resolution resolution modifiers" "type   chances    chances    chances    chances    chances    buttons" "footer footer     footer     footer     footer     footer     footer";
  grid-template-columns: 2rem 1rem 1fr 1fr 2fr 2fr 3fr;
  gap: 0.2rem;
 }
@@ -461,26 +461,26 @@ select,
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-buttons {
  grid-area: buttons;
 }
-.system-foundryvtt-reve-de-dragon .roll-dialog roll-mode {
-  grid-area: mode;
+.system-foundryvtt-reve-de-dragon .roll-dialog roll-type {
+  grid-area: type;
  display: flex;
  flex-direction: column;
 }
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-conditions roll-section[name="rollmode"] button[data-checked="true"],
-.system-foundryvtt-reve-de-dragon .roll-dialog roll-mode button[data-checked="true"] {
+.system-foundryvtt-reve-de-dragon .roll-dialog roll-type button[data-checked="true"] {
  background-color: var(--color-text-selection-bg);
  color: var(--color-controls);
 }
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-conditions roll-section[name="rollmode"] button[data-checked="true"] i,
-.system-foundryvtt-reve-de-dragon .roll-dialog roll-mode button[data-checked="true"] i {
+.system-foundryvtt-reve-de-dragon .roll-dialog roll-type button[data-checked="true"] i {
  filter: invert(0.8);
 }
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-conditions roll-section[name="rollmode"] button[data-checked="true"] img,
-.system-foundryvtt-reve-de-dragon .roll-dialog roll-mode button[data-checked="true"] img {
+.system-foundryvtt-reve-de-dragon .roll-dialog roll-type button[data-checked="true"] img {
  filter: invert(0.2);
 }
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-conditions roll-section[name="rollmode"] button,
-.system-foundryvtt-reve-de-dragon .roll-dialog roll-mode button {
+.system-foundryvtt-reve-de-dragon .roll-dialog roll-type button {
  height: 1.8rem;
  width: 1.8rem;
  gap: 0.5rem;
@@ -489,11 +489,11 @@ select,
  color: var(--color-controls);
 }
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-conditions roll-section[name="rollmode"] button i,
-.system-foundryvtt-reve-de-dragon .roll-dialog roll-mode button i {
+.system-foundryvtt-reve-de-dragon .roll-dialog roll-type button i {
  filter: invert(0.2);
 }
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-conditions roll-section[name="rollmode"] button img,
-.system-foundryvtt-reve-de-dragon .roll-dialog roll-mode button img {
+.system-foundryvtt-reve-de-dragon .roll-dialog roll-type button img {
  filter: invert(0.8);
 }
 .system-foundryvtt-reve-de-dragon .roll-dialog :is(roll-carac, roll-comp) {
@@ -564,6 +564,9 @@ select,
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-choix roll-section roll-part-detail subline span.status-surprise img {
  filter: invert(0.8);
 }
+.system-foundryvtt-reve-de-dragon .roll-dialog roll-choix roll-section roll-part-detail subline label {
+  align-content: center;
+}
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-section selected-numeric-value {
  display: flow;
  width: 2.5rem;
--- a/less/roll-dialog.less
+++ b/less/roll-dialog.less
@@ -4,11 +4,11 @@
  grid-template-areas:
    "header header     header     header     header     header     header"
    "action action     action     action     action     action     action"
-    "mode   separation separation separation separation separation separation"
-    "mode   carac      carac      carac      comp       comp       resume"
-    "mode   choix      choix      choix      choix      choix      modifiers"
-    "mode   resolution resolution resolution resolution resolution modifiers"
-    "mode   chances    chances    chances    chances    chances    buttons"
+    "type   separation separation separation separation separation separation"
+    "type   carac      carac      carac      comp       comp       resume"
+    "type   choix      choix      choix      choix      choix      modifiers"
+    "type   resolution resolution resolution resolution resolution modifiers"
+    "type   chances    chances    chances    chances    chances    buttons"
    "footer footer     footer     footer     footer     footer     footer";
  grid-template-columns: 2rem 1rem 1fr 1fr 2fr 2fr 3fr;
  gap: 0.2rem;
@@ -27,13 +27,13 @@
  roll-resume { grid-area: resume; }
  roll-buttons  { grid-area: buttons; }
  
-  roll-mode {
-    grid-area: mode;
+  roll-type {
+    grid-area: type;
    display: flex;
    flex-direction: column;
  }
  roll-conditions roll-section[name="rollmode"],
-  roll-mode {
+  roll-type {
    button[data-checked="true"] {
      background-color: var(--color-text-selection-bg);
      color: var(--color-controls);
@@ -95,7 +95,7 @@
      display: flex;
      flex-direction: column;
      grid-area: img;
-      img{
+      img {
        border: 0;
        padding: 1px;
        max-height: 3rem;
@@ -126,6 +126,9 @@
            filter: invert(0.8);
          }
        }
+        label {
+          align-content: center;
+        }
      }
    }
  }
--- a/module/actor.js
+++ b/module/actor.js
@@ -3053,11 +3053,11 @@ export class RdDActor extends RdDBaseActorSang {
    const oeuvre = this.items.get(oeuvreId)
    const rollData = {
      title: `Interpretation de ${oeuvre.name} par ${this.name}`,
-      mode: {
-        allowed: ["oeuvre"]
+      type: {
+        allowed: ["oeuvre"],
+        current: "oeuvre",
      },
      selected: {
-        mode: "oeuvre",
        oeuvre: { key: oeuvre.id },
      },
      ids: {
@@ -3065,9 +3065,9 @@ export class RdDActor extends RdDBaseActorSang {
      }
    }
    await RollDialog.create(rollData, {
-      onRoll: (dialog) => {
-        this._onCloseRollDialog(),
-          dialog.close()
+      onRollDone: (dialog) => {
+        this._onCloseRollDialog()
+        dialog.close()
      },
      customChatMessage: true,
      callbacks: [callbackAction]
--- a/module/rdd-combat.js
+++ b/module/rdd-combat.js
@@ -19,6 +19,7 @@ import RollDialog from "./roll/roll-dialog.mjs";
 import { PART_DEFENSE } from "./roll/roll-part-defense.mjs";
 import { PART_ATTAQUE } from "./roll/roll-part-attaque.mjs";
 import { RollDialogAdapter } from "./roll/roll-dialog-adapter.mjs";
+import { ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE } from "./roll/roll-constants.mjs";

 /* -------------------------------------------- */
 const premierRoundInit = [
@@ -559,27 +560,42 @@ export class RdDCombat {

  /* -------------------------------------------- */
  static isEchecTotal(rollData) {
-    if (!rollData.attackerRoll && rollData.ajustements.surprise.used) {
-      return rollData.rolled.isEchec && rollData.rolled.code != 'notSign';
+    if (rollData.ids /* roll V2*/) {
+      // TODO: en cas de demi-surprise à l'attaque, tout échec est un echec total.
+      // TODO: en cas de demi-surprise en défense, pas de changement à la règle de base
+      return rollData.rolled.isETotal
    }
-    return rollData.rolled.isETotal;
+    if (rollData.mode == ROLL_TYPE_ATTAQUE && rollData.surprise == 'demi') {
+      // échec normal à l'attaque en demi surprise
+      return rollData.rolled.isEchec && rollData.rolled.code != 'notSign'
+    }
+    return rollData.rolled.isETotal
  }

  /* -------------------------------------------- */
  static isParticuliere(rollData) {
-    if (!rollData.attackerRoll && rollData.ajustements.surprise.used) {
-      return false;
+    if (rollData.ids /* roll V2*/) {
+      return rollData.rolled.isPart
    }
-    return rollData.rolled.isPart;
+    if (rollData.attackerRoll || !rollData.ajustements.surprise.used) {
+      return rollData.rolled.isPart
+    }
+    return false
  }

  /* -------------------------------------------- */
  static isReussite(rollData) {
-    switch (rollData.ajustements.surprise.used) {
-      case 'totale': return false;
-      case 'demi': return rollData.rolled.isSign;
+    if (rollData.ids /* roll V2*/) {
+      return rollData.rolled.isSuccess
    }
-    return rollData.rolled.isSuccess;
+    if (!rollData.ajustements.surprise.used) {
+      return rollData.rolled.isSuccess
+    }
+    switch (rollData.ajustements.surprise.used) {
+      case 'totale': return false
+      case 'demi': return rollData.rolled.isSign
+    }
+    return rollData.rolled.isSuccess
  }

  /* -------------------------------------------- */
@@ -686,6 +702,7 @@ export class RdDCombat {
  /* -------------------------------------------- */
  _prepareAttaque(competence, arme) {
    let rollData = {
+      mode: ROLL_TYPE_ATTAQUE,
      alias: this.attacker?.getAlias(),
      passeArme: foundry.utils.randomID(16),
      mortalite: arme?.system.mortalite,
@@ -883,6 +900,7 @@ export class RdDCombat {
    const choixEchecTotal = await ChatMessage.create({
      whisper: ChatUtility.getOwners(this.attacker),
      content: await renderTemplate('systems/foundryvtt-reve-de-dragon/templates/chat-demande-attaque-etotal.hbs', {
+        rolled: attackerRoll.rolled,
        attackerId: this.attackerId,
        attacker: this.attacker,
        attackerToken: this.attackerToken,
@@ -961,25 +979,20 @@ export class RdDCombat {
        opponentTokenId: this.attackerTokenId,
        opponentId: this.attackerId,
      },
-      mode: {
-        allowed: ['defense'],
-        current: 'defense'
-      },
+      type: { allowed: ['defense'], current: 'defense' },
      attaque: RollDialogAdapter.mapActionAttaque(attackerRoll),
      passeArme: attackerRoll.passeArme,
    }

    await RollDialog.create(rollData, {
-      onRoll: (dialog) => {
-        this._onCloseRollDialog(),
-          dialog.close()
-      },
+      onRollDone: (dialog) => { dialog.close() },
      customChatMessage: true,
-      callbacks: [async (actor, rd) => {
-        this.removeChatMessageActionsPasseArme(rd.passeArme)
+      callbacks: [async (roll) => {
+        this.removeChatMessageActionsPasseArme(roll.passeArme)
        // defense:  esquive / arme de parade / competence de défense
-        await rd.active.actor.incDecItemUse(rd.current[PART_DEFENSE].defense?.id, !RdDCombat.isParticuliere(rd))
-        await this._onDefenseV2(rd)
+        if (!RdDCombat.isParticuliere(roll))
+          await roll.active.actor.incDecItemUse(roll.current[PART_DEFENSE].defense?.id,)
+        await this._onDefense(roll)
      }]
    })
  }
@@ -988,6 +1001,7 @@ export class RdDCombat {
  /* -------------------------------------------- */
  _prepareParade(attackerRoll, armeParade, competenceParade) {
    let defenderRoll = {
+      mode: ROLL_TYPE_DEFENSE,
      alias: this.defender?.getAlias(),
      passeArme: attackerRoll.passeArme,
      diffLibre: attackerRoll.diffLibre,
@@ -1010,17 +1024,63 @@ export class RdDCombat {
    return defenderRoll;
  }

-  async _onParade(defenderRoll) {
-    if (RdDCombat.isReussite(defenderRoll)) {
-      await this._onParadeNormale(defenderRoll)
-      if (RdDCombat.isParticuliere(defenderRoll)) {
-        await this._onParadeParticuliere(defenderRoll)
+  async _onDefense(rollData) {
+    if (RdDCombat.isReussite(rollData)) {
+      await this._onDefenseNormale(rollData)
+      if (RdDCombat.isParticuliere(rollData)) {
+        await this._onDefenseParticuliere(rollData)
      }
-      return
    }
-    await this._onParadeEchec(defenderRoll)
+    else {
+      await this._onDefenseEchec(dialog, rollData)
+    }
  }
-  async _onDefenseV2(defenderRoll) {
+
+  async _onDefenseParticuliere(rollData) {
+    console.log("RdDCombat._onDefenseParticuliere >>>", rollData);
+    if (/*TODO: parade?*/!rollData.attackerRoll?.isPart) {
+      // TODO: attaquant doit jouer résistance et peut être désarmé p132
+      ChatUtility.createChatWithRollMode(
+        { content: `(à gérer) L'attaquant doit jouer résistance et peut être désarmé (p132)` },
+        this.defender)
+    }
+    ChatUtility.createChatWithRollMode(
+      { content: "<strong>Vous pouvez esquiver une deuxième fois!</strong>" },
+      this.defender);
+  }
+
+  async _onDefenseNormale(rollData) {
+    console.log("RdDCombat._onDefenseNormale >>>", rollData);
+    // console.log("RdDCombat._onEsquiveNormal >>>", rollData);
+    // await RdDRollResult.displayRollData(rollData, this.defender, 'chat-resultat-esquive.hbs');
+    // this.removeChatMessageActionsPasseArme(rollData.passeArme);
+    //TODO
+    await this.computeRecul(rollData);
+    await this.computeDeteriorationArme(rollData);
+    await RdDRollResult.displayRollData(rollData, this.defender, 'chat-resultat-parade.hbs');
+    this.removeChatMessageActionsPasseArme(rollData.passeArme);
+  }
+
+  async _onDefenseEchec(rollData) {
+    console.log("RdDCombat._onDefenseEchec >>>", rollData);
+    // console.log("RdDCombat._onEsquiveEchec >>>", rollData);
+
+    // await RdDRollResult.displayRollData(rollData, this.defender, 'chat-resultat-esquive.hbs');
+
+    // this.removeChatMessageActionsPasseArme(rollData.passeArme);
+    // this._sendMessageDefense(rollData.attackerRoll, rollData, { defense: true })
+
+    await RdDRollResult.displayRollData(rollData, this.defender, 'chat-resultat-parade.hbs');
+
+    this.removeChatMessageActionsPasseArme(rollData.passeArme);
+    this._sendMessageDefense(rollData.attackerRoll, rollData, { defense: true });
+  }
+
+
+
+
+
+  async _onParade(defenderRoll) {
    if (RdDCombat.isReussite(defenderRoll)) {
      await this._onParadeNormale(defenderRoll)
      if (RdDCombat.isParticuliere(defenderRoll)) {
@@ -1090,6 +1150,7 @@ export class RdDCombat {
  /* -------------------------------------------- */
  _prepareEsquive(attackerRoll, competence) {
    let rollData = {
+      mode: ROLL_TYPE_DEFENSE,
      alias: this.defender.getAlias(),
      passeArme: attackerRoll.passeArme,
      diffLibre: attackerRoll.diffLibre,
--- a/module/rdd-resolution-table.js
+++ b/module/rdd-resolution-table.js
@@ -184,47 +184,15 @@ export class RdDResolutionTable {
    return Math.max(Math.floor(carac * (diff + 10) / 2), 1);
  }

-  /* -------------------------------------------- */
-  static isEchec(rollData) {
-    switch (rollData.surprise) {
-      case 'demi': return !rollData.rolled.isSign;
-      case 'totale': return true;
-    }
-    return rollData.rolled.isEchec;
-  }
-
-  /* -------------------------------------------- */
-  static isEchecTotal(rollData) {
-    if (rollData.arme && rollData.surprise == 'demi') {
-      return rollData.rolled.isEchec;
-    }
-    return rollData.rolled.isETotal;
-  }
-
-  /* -------------------------------------------- */
-  static isParticuliere(rollData) {
-    if (rollData.arme && rollData.surprise) {
-      return false;
-    }
-    return rollData.rolled.isPart;
-  }
-
-  /* -------------------------------------------- */
-  static isReussite(rollData) {
-    switch (rollData.surprise) {
-      case 'demi': return rollData.rolled.isSign;
-      case 'totale': return false;
-    }
-    return rollData.rolled.isSuccess;
-  }
-
  /* -------------------------------------------- */
  static computeReussite(chances, roll, diviseur) {
-    const reussite = reussites.find(x => x.condition(chances, roll));
-    if (diviseur > 1 && reussite.code == 'norm') {
-      return reussiteInsuffisante;
+    const reussite = reussites.find(x => x.condition(chances, roll))
+    if (diviseur > 1 && reussite.isSuccess) {
+      if (chances > roll * diviseur){
+        return reussiteInsuffisante
+      }
    }
-    return reussite;
+    return reussite
  }

  /* -------------------------------------------- */
--- a/module/roll/roll-basic-parts.mjs
+++ b/module/roll/roll-basic-parts.mjs
@@ -1,4 +1,8 @@
 import { ActorToken } from "../actor-token.mjs"
+import { StatusEffects } from "../settings/status-effects.js"
+import { ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE } from "./roll-constants.mjs"
+import { PART_ATTAQUE } from "./roll-part-attaque.mjs"
+import { PART_DEFENSE } from "./roll-part-defense.mjs"

 export class RollBasicParts {

@@ -6,23 +10,46 @@ export class RollBasicParts {
    rollData.ids.sceneId = rollData.ids.sceneId ?? canvas.scene.id
    rollData.active = RollBasicParts.$getActor(rollData)
    rollData.opponent = RollBasicParts.$getOpponent(rollData)
-    if (rollData.mode.opposed == undefined) {
-      rollData.mode.opposed = rollData.opponent != null
+    if (rollData.type.opposed == undefined) {
+      rollData.type.opposed = rollData.opponent != null
+    }
+  }
+
+  loadSurprises(rollData, type) {
+    if (!rollData.type.passif) {
+      this.loadSurprise(rollData.active, this.getForceRequiseActiveActor(rollData, type))
+      this.loadSurprise(rollData.opponent, 0)
+    }
+  }
+
+  loadSurprise(who, forceRequise) {
+    if (who?.actor) {
+      foundry.utils.mergeObject(who,
+        StatusEffects.getActorEffetSurprise(who.actor, forceRequise),
+        { overwrite: true, inPlace: true })
+    }
+  }
+
+  getForceRequiseActiveActor(rollData, type) {
+    switch (type) {
+      case ROLL_TYPE_ATTAQUE: return rollData.current[PART_ATTAQUE].attaque.forceRequise
+      case ROLL_TYPE_DEFENSE: return rollData.current[PART_DEFENSE].forceRequise
+      default: return 0
    }
  }

  initFrom(rollData) {
    return {
      selected: {},
-      mode: {
-        current: rollData.mode.current
+      type: {
+        current: rollData.type.current
      },
      ids: {
        sceneId: rollData.ids.sceneId,
        actorId: rollData.active.id,
        actorTokenId: rollData.active.tokenId,
-        opponentId: rollData.mode.opposed ? rollData.opponent.id : undefined,
-        opponentTokenId: rollData.mode.opposed ? rollData.opponent.tokenId : undefined,
+        opponentId: rollData.type.opposed ? rollData.opponent.id : undefined,
+        opponentTokenId: rollData.type.opposed ? rollData.opponent.tokenId : undefined,
      }
    }
  }
--- a/module/roll/roll-chat-result.mjs
+++ b/module/roll/roll-chat-result.mjs
@@ -0,0 +1,15 @@
+export class RollChatResult {
+  constructor(rollType) {
+    this.rollType = rollType
+  }
+
+  async display(rollData) {
+    const template = this.rollType.chatResultTemplate()
+    const chatContent = await renderTemplate(template, rollData)
+  
+    ChatMessage.create({
+      whisper: ChatUtility.getOwners(this),
+      content: chatContent
+    })
+  }
+}
--- a/module/roll/roll-constants.mjs
+++ b/module/roll/roll-constants.mjs
@@ -1,14 +1,14 @@

-export const ROLL_MODE_ATTAQUE = 'attaque'
-export const ROLL_MODE_COMP = 'comp'
-export const ROLL_MODE_DEFENSE = 'defense'
-export const ROLL_MODE_JEU = 'jeu'
-export const ROLL_MODE_MEDITATION = 'meditation'
-export const ROLL_MODE_OEUVRE = 'oeuvre'
-export const ROLL_MODE_SORT = 'sort'
-export const ROLL_MODE_TACHE = 'tache'
+export const ROLL_TYPE_ATTAQUE = 'attaque'
+export const ROLL_TYPE_COMP = 'comp'
+export const ROLL_TYPE_DEFENSE = 'defense'
+export const ROLL_TYPE_JEU = 'jeu'
+export const ROLL_TYPE_MEDITATION = 'meditation'
+export const ROLL_TYPE_OEUVRE = 'oeuvre'
+export const ROLL_TYPE_SORT = 'sort'
+export const ROLL_TYPE_TACHE = 'tache'

-export const DIFF_MODE = {
+export const DIFF = {
  LIBRE: 'libre',
  ATTAQUE: 'attaque',
  IMPOSEE: 'imposee',
@@ -17,12 +17,12 @@ export const DIFF_MODE = {
  AUCUN: 'aucun'
 }

-export const DIFF_MODES = {
-  [DIFF_MODE.LIBRE]: { key: DIFF_MODE.LIBRE, label: "Difficulté libre", libre: true, visible: true, max: 0 },
-  [DIFF_MODE.ATTAQUE]: { key: DIFF_MODE.ATTAQUE, label: "Difficulté d'attaque", libre: true, visible: true, max: 0 },
-  [DIFF_MODE.IMPOSEE]: { key: DIFF_MODE.IMPOSEE, label: "Diffficulté imposée", libre: false, visible: true, max: 0 },
-  [DIFF_MODE.DEFENSE]: { key: DIFF_MODE.DEFENSE, label: "Diffficulté défense", libre: false, visible: true, max: 0 },
-  [DIFF_MODE.DEFAUT]: { key: DIFF_MODE.DEFAUT, label: "Difficulté", libre: true, visible: true, max: 5 },
-  [DIFF_MODE.AUCUN]: { key: DIFF_MODE.AUCUN, label: "", libre: false, visible: false, max: 0 },
+export const DIFFS = {
+  [DIFF.LIBRE]: { key: DIFF.LIBRE, label: "Difficulté libre", libre: true, visible: true, max: 0 },
+  [DIFF.ATTAQUE]: { key: DIFF.ATTAQUE, label: "Difficulté d'attaque", libre: true, visible: true, max: 0 },
+  [DIFF.IMPOSEE]: { key: DIFF.IMPOSEE, label: "Diffficulté imposée", libre: false, visible: true, max: 0 },
+  [DIFF.DEFENSE]: { key: DIFF.DEFENSE, label: "Diffficulté défense", libre: false, visible: true, max: 0 },
+  [DIFF.DEFAUT]: { key: DIFF.DEFAUT, label: "Difficulté", libre: true, visible: true, max: 5 },
+  [DIFF.AUCUN]: { key: DIFF.AUCUN, label: "", libre: false, visible: false, max: 0 },
 }

--- a/module/roll/roll-dialog-adapter.mjs
+++ b/module/roll/roll-dialog-adapter.mjs
@@ -4,8 +4,9 @@ import { PART_COMP } from "./roll-part-comp.mjs";
 import { RdDResolutionTable } from "../rdd-resolution-table.js";
 import { ReglesOptionnelles } from "../settings/regles-optionnelles.js";
 import { PART_OEUVRE } from "./roll-part-oeuvre.mjs";
-import { ATTAQUE_TYPE, RdDItemArme } from "../item/arme.js";
+import { RdDItemArme } from "../item/arme.js";
 import { RdDBonus } from "../rdd-bonus.js";
+import { ROLL_TYPE_ATTAQUE } from "./roll-constants.mjs";

 /* -------------------------------------------- */
 export class RollDialogAdapter {
@@ -36,7 +37,9 @@ export class RollDialogAdapter {
  }

  async rollChances(rollData, chances) {
-    const rolled = await RdDResolutionTable.rollChances(chances, rollData.current.sign, rollData.current.resultat)
+    const rolled = await RdDResolutionTable.rollChances(chances,
+      rollData.current.sign,
+      rollData.current.resultat)
    rolled.caracValue = rollData.current.carac.value
    rolled.finalLevel = rollData.current.totaldiff
    rolled.bonus = rollData.current.bonus ?? 0
@@ -59,7 +62,7 @@ export class RollDialogAdapter {
    const compKey = rollData.current.comp?.key
    if (compKey) {
      rollData.competence = rollData.refs[PART_COMP].all.find(it => it.key == compKey)?.comp
-      rollData.jetResistance = rollData.mode.jetResistance
+      rollData.jetResistance = rollData.type.jetResistance
    }
    const oeuvreKey = rollData.current.oeuvre?.key
    if (oeuvreKey) {
--- a/module/roll/roll-dialog.mjs
+++ b/module/roll/roll-dialog.mjs
@@ -1,18 +1,18 @@
 import { Misc } from "../misc.js";
-import { RollModeComp } from "./roll-mode-comp.mjs";
-import { RollModeTache } from "./roll-mode-tache.mjs";
-import { RollModeAttaque } from "./roll-mode-attaque.mjs";
-import { RollModeDefense } from "./roll-mode-defense.mjs";
-import { RollModeMeditation } from "./roll-mode-meditation.mjs";
-import { RollModeSort } from "./roll-mode-sort.mjs";
-import { RollModeOeuvre } from "./roll-mode-oeuvre.mjs";
-import { RollModeJeu } from "./roll-mode-jeu.mjs";
+import { RollTypeComp } from "./roll-type-comp.mjs";
+import { RollTypeTache } from "./roll-type-tache.mjs";
+import { RollTypeAttaque } from "./roll-type-attaque.mjs";
+import { RollTypeDefense } from "./roll-type-defense.mjs";
+import { RollTypeMeditation } from "./roll-type-meditation.mjs";
+import { RollTypeSort } from "./roll-type-sort.mjs";
+import { RollTypeOeuvre } from "./roll-type-oeuvre.mjs";
+import { RollTypeJeu } from "./roll-type-jeu.mjs";

 import { RollPartAction } from "./roll-part-action.mjs";
 import { RollPartActor } from "./roll-part-actor.mjs";
 import { RollPartAppelMoral } from "./roll-part-appelmoral.mjs";
 import { RollPartAstrologique } from "./roll-part-astrologique.mjs";
-import { RollPartCarac } from "./roll-part-carac.mjs";
+import { PART_CARAC, RollPartCarac } from "./roll-part-carac.mjs";
 import { RollPartCoeur } from "./roll-part-coeur.mjs";
 import { PART_COMP, RollPartComp } from "./roll-part-comp.mjs";
 import { RollPartConditions } from "./roll-part-conditions.mjs";
@@ -37,23 +37,22 @@ import { RollPartAttaque } from "./roll-part-attaque.mjs";
 import { RollPartDefense } from "./roll-part-defense.mjs";
 import { RollDialogAdapter } from "./roll-dialog-adapter.mjs";
 import { ROLLDIALOG_SECTION } from "./roll-part.mjs";
-import { ROLL_MODE_COMP } from "./roll-constants.mjs";
+import { ROLL_TYPE_COMP } from "./roll-constants.mjs";
+import { RollChatResult } from "./roll-chat-result.mjs";

 const { HandlebarsApplicationMixin, ApplicationV2 } = foundry.applications.api
 const doNothing = (dialog) => { }

-const ROLL_MODE_TABS = [
-  new RollModeComp(),
-  new RollModeTache(),
-  new RollModeAttaque(),
-  new RollModeDefense(),
-  // new RollModeParade??
-  // new RollModeEsquive??
-  // new RollModeResistance ??
-  new RollModeSort(),
-  new RollModeMeditation(),
-  new RollModeOeuvre(),
-  new RollModeJeu(),
+const ALL_ROLL_TYPES = [
+  new RollTypeComp(),
+  new RollTypeTache(),
+  new RollTypeAttaque(),
+  new RollTypeDefense(),
+  // new RollTypeResistance ??
+  new RollTypeSort(),
+  new RollTypeMeditation(),
+  new RollTypeOeuvre(),
+  new RollTypeJeu(),
 ]

 const BASIC_PARTS = new RollBasicParts()
@@ -95,7 +94,7 @@ const ROLL_PARTS = [
 * @extends {Dialog}
 * # Principes
 * - une seule fenêtre de dialogue (classe RollDialog)
- * - plusieurs modes de fonctionnement (classe RollMode)
+ * - plusieurs "types"s de fonctionnement (classe RollType)
 * - gestion uniforme des modificateurs (classe RollPart)
 * - un objet rollData contient les informations liées à un jet de dés
 * - un rollData doit pouvoir être "réduit" pour fournir les informations significatives
@@ -106,15 +105,15 @@ const ROLL_PARTS = [
 * - TODO: une classe de base RollChatMessage gerera les messages correspondant aux résultats du dés
 * - TODO: réfléchir aux messages supplémentaires gérés par RdDCombat ?
 *
- * ## Modes de fonctionnement - RollMode
+ * ## Types de fonctionnement - RollType
 * 
- * Un mode de fonctionnement (RollMode) détermine quelles parties (RollPart) de la
+ * Un type de fonctionnement (RollType) détermine quelles parties (RollPart) de la
 * fenêtre RollDialog sont actives, mais aussi quels sont les effets du jet.
 * 
- * - chaque mode de fonctionnement peut impacter les RollPart utilisés, les données
+ * - chaque type de fonctionnement peut impacter les RollPart utilisés, les données
 *   attendues et ajoutées au rollData.
- * - chaque mode de fonctionnement peut définir le template de ChatMessage correspondant
- * - Le mode de fonctionnement détermine aussi quelles sont les effets du jet:
+ * - chaque type de fonctionnement peut définir le template de ChatMessage correspondant
+ * - Le type de fonctionnement détermine aussi quelles sont les effets du jet:
 *    - quelle ChatMessage afficher dans le tchat?
 *    - en cas d'attaque/de défense, quelles sont les suites à donner?
 *    - en cas de lancement de sort, réduire les points de rêve
@@ -176,14 +175,14 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2

    foundry.applications.handlebars.loadTemplates({
      'roll-section': 'systems/foundryvtt-reve-de-dragon/templates/roll/roll-section.hbs',
-      'roll-mode': 'systems/foundryvtt-reve-de-dragon/templates/roll/roll-mode.hbs',
+      'roll-type': 'systems/foundryvtt-reve-de-dragon/templates/roll/roll-type.hbs',
      'roll-table': 'systems/foundryvtt-reve-de-dragon/templates/roll/roll-table.hbs',
      'roll-ajustements': 'systems/foundryvtt-reve-de-dragon/templates/roll/roll-ajustements.hbs',
      'roll-chances': 'systems/foundryvtt-reve-de-dragon/templates/roll/roll-chances.hbs',
      'roll-button': 'systems/foundryvtt-reve-de-dragon/templates/roll/roll-button.hbs',
    })

-    foundry.applications.handlebars.loadTemplates(ROLL_MODE_TABS.map(m => m.template))
+    foundry.applications.handlebars.loadTemplates(ALL_ROLL_TYPES.map(m => m.template))
    foundry.applications.handlebars.loadTemplates(ROLL_PARTS.map(p => p.template))
    ROLL_PARTS.forEach(p => p.onReady())

@@ -217,7 +216,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
    })
  }

-  
+
  static async create(rollData, rollOptions = {}) {
    const rollDialog = new RollDialog(rollData, rollOptions)
    rollDialog.render(true)
@@ -250,17 +249,14 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
  constructor(rollData, rollOptions) {
    super()
    this.rollData = rollData
-    // const callbacks = this.rollOptions.callbacks.map(c =>
-    //   r => r.activve.actor Promise.all(this.rollOptions.callbacks.map(async callback => await callback(rollData.active.actor, rollData)))
-    // )
    this.rollOptions = {
      callbacks: [
-        async (actor, r) => await actor.appliquerAjoutExperience(r),
-        async (actor, r) => await actor.appliquerAppelMoral(r),
+        async r => await r.active.actor.appliquerAjoutExperience(r),
+        async r => await r.active.actor.appliquerAppelMoral(r),
        ...(rollOptions.callbacks ?? [])
      ],
      customChatMessage: rollOptions.customChatMessage,
-      onRoll: rollOptions.onRoll ?? doNothing
+      onRollDone: rollOptions.onRollDone ?? doNothing
    }
    this.$loadParts()
  }
@@ -270,17 +266,17 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
    const rollData = this.rollData;
    rollData.current = rollData.current ?? {}
    rollData.selected = rollData.selected ?? {}
-    rollData.mode = rollData.mode ?? {}
-    rollData.mode.retry = rollData.mode.retry ?? false
+    rollData.type = rollData.type ?? {}
+    rollData.type.retry = rollData.type.retry ?? false
    BASIC_PARTS.restore(rollData)

-    const loadedMode = ROLL_MODE_TABS.find(m => m.code == rollData.mode?.current)?.code
-    const allowedModes = ROLL_MODE_TABS.filter(m => m.isAllowed(rollData) && m.visible(rollData)).map(m => m.code)
+    const loadedType = ALL_ROLL_TYPES.find(m => m.code == rollData.type?.current)?.code
+    const allowedTypes = ALL_ROLL_TYPES.filter(m => m.isAllowed(rollData) && m.visible(rollData)).map(m => m.code)

-    rollData.mode.allowed = rollData.mode.retry ? [loadedMode] : rollData.mode.allowed ?? ROLL_MODE_TABS.map(m => m.code)
-    rollData.mode.current = allowedModes.find(m => m == rollData.mode?.current) ?? (allowedModes.length > 0 ? allowedModes[0] : ROLL_MODE_COMP)
+    rollData.type.allowed = rollData.type.retry ? [loadedType] : rollData.type.allowed ?? ALL_ROLL_TYPES.map(m => m.code)
+    rollData.type.current = allowedTypes.find(m => m == rollData.type?.current) ?? (allowedTypes.length > 0 ? allowedTypes[0] : ROLL_TYPE_COMP)

-    this.getSelectedMode().setRollDataMode(rollData)
+    this.getSelectedType().setRollDataType(rollData)

    rollData.refs = this.$prepareRefs(rollData)
    rollData.options = rollData.options ?? { showDice: true, rollMode: game.settings.get("core", "rollMode") }
@@ -292,13 +288,17 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
        p.loadRefs(rollData)
        p.prepareContext(rollData)
      })
-    this.selectMode();
+    this.selectType();
  }

-  selectMode() {
-    this.rollData.mode.label = this.getSelectedMode().title(this.rollData)
-    this.getSelectedMode().setRollDataMode(this.rollData)
-    this.getSelectedMode().onSelect(this.rollData);
+  selectType() {
+    const selectedType = this.getSelectedType();
+    this.rollData.type.label = selectedType.title(this.rollData)
+    selectedType.setRollDataType(this.rollData)
+    selectedType.onSelect(this.rollData)
+
+    ROLL_PARTS.find(it => it.code == PART_CARAC).filterCaracs(this.rollData)
+    ROLL_PARTS.find(it => it.code == PART_COMP).filterComps(this.rollData)
  }

  $prepareRefs(rollData) {
@@ -329,12 +329,12 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
        this.roll()
      }
    )
-    const buttonsMode = this.element.querySelectorAll(`button[name="roll-mode"]`)
-    buttonsMode?.forEach(it => it.addEventListener(
+    const buttonsType = this.element.querySelectorAll(`button[name="roll-type"]`)
+    buttonsType?.forEach(it => it.addEventListener(
      "click", e => {
        e.preventDefault()
-        this.rollData.mode.current = e.currentTarget.dataset.mode
-        this.selectMode()
+        this.rollData.type.current = e.currentTarget.dataset.type
+        this.selectType()
        this.render()
      }
    ))
@@ -355,14 +355,14 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
    return await foundry.applications.handlebars.renderTemplate('roll-table', { carac, diff })
  }

-
  async _prepareContext() {
    const rollData = this.rollData

-    const modes = ROLL_MODE_TABS.filter(m => m.isAllowed(rollData) && m.visible(rollData))
-      .map(m => m.toModeData(rollData))
-    this.setModeTitle()
-
+    const types = ALL_ROLL_TYPES.filter(m => m.isAllowed(rollData) && m.visible(rollData))
+      .map(m => m.toTypeData(rollData))
+    BASIC_PARTS.loadSurprises(this.rollData, this.getSelectedType().code)
+    this.rollData.type.label = this.getSelectedType()?.title(this.rollData)
+    //TOCHECK: set type.label ?
    const visibleRollParts = this.getActiveParts()
    visibleRollParts.forEach(p => p.applyExternalImpacts(visibleRollParts, rollData))

@@ -376,7 +376,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
    const context = await super._prepareContext()
    return foundry.utils.mergeObject(
      {
-        modes: modes,
+        types: types,
        templates: templates,
        rollData: rollData,
      }, context)
@@ -401,12 +401,8 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
      .reduce(Misc.sum(), 0)
  }

-  setModeTitle() {
-    this.rollData.mode.label = this.getSelectedMode()?.title(this.rollData)
-  }
-
-  getSelectedMode() {
-    return ROLL_MODE_TABS.find(m => m.code == this.rollData.mode.current)
+  getSelectedType() {
+    return ALL_ROLL_TYPES.find(m => m.code == this.rollData.type.current)
  }

  async roll() {
@@ -415,11 +411,13 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
    console.info('Roll parts:', this.$saveParts())
    const rolled = await this.$rollDice(rollData)
    rollData.rolled = rolled
-    Promise.all(this.rollOptions.callbacks.map(async callback => await callback(rollData.active.actor, rollData)))
+    Promise.all(this.rollOptions.callbacks.map(async callback => await callback(rollData)))
    if (!this.rollOptions.customChatMessage) {
+      const rollChatResult = new RollChatResult(this.getSelectedType())
+      await rollChatResult.display(this.rollData)
      rollData.active.actor.$onRollCompetence(this.rollData)
    }
-    this.rollOptions.onRoll(this)
+    this.rollOptions.onRollDone(this)
  }


--- a/module/roll/roll-mode-attaque.mjs
+++ b/module/roll/roll-mode-attaque.mjs
@@ -1,13 +0,0 @@
-import { DIFF_MODE, ROLL_MODE_ATTAQUE } from "./roll-constants.mjs"
-import { RollMode } from "./roll-mode.mjs"
-
-export class RollModeAttaque extends RollMode {
-  get code() { return ROLL_MODE_ATTAQUE }
-  get name() { return `Attaquer` }
-
-  title(rollData) { return `attaque` }
-
-  onSelect(rollData) {
-    this.setDiffMode(rollData, DIFF_MODE.ATTAQUE)
-  }
-}
--- a/module/roll/roll-mode-comp.mjs
+++ b/module/roll/roll-mode-comp.mjs
@@ -1,9 +0,0 @@
-import { ROLL_MODE_COMP } from "./roll-constants.mjs"
-import { RollMode } from "./roll-mode.mjs"
-
-export class RollModeComp extends RollMode {
-  get code() { return ROLL_MODE_COMP }
-  get name() { return `Jet de caractéristique / compétence` }
-
-  title(rollData) { return `fait un jet ${rollData.mode.opposed ? ' contre ' : ''}` }
-}
--- a/module/roll/roll-mode-defense.mjs
+++ b/module/roll/roll-mode-defense.mjs
@@ -1,17 +0,0 @@
-import { DIFF_MODE, ROLL_MODE_DEFENSE } from "./roll-constants.mjs"
-import { RollMode } from "./roll-mode.mjs"
-
-export class RollModeDefense extends RollMode {
-  get code() { return ROLL_MODE_DEFENSE }
-  get name() { return `Se défendre` }
-
-  title(rollData) { return `se défend${rollData.opponent ? ' de' : ''}` }
-
-  getOpponent(rollData) {
-    return rollData.attacker
-  }
-
-  onSelect(rollData) {
-    this.setDiffMode(rollData, DIFF_MODE.DEFENSE)
-  }
-}
--- a/module/roll/roll-mode-sort.mjs
+++ b/module/roll/roll-mode-sort.mjs
@@ -1,15 +0,0 @@
-import { DIFF_MODE, ROLL_MODE_SORT } from "./roll-constants.mjs"
-import { RollMode } from "./roll-mode.mjs"
-import { PART_SORT } from "./roll-part-sort.mjs"
-
-export class RollModeSort extends RollMode {
-  get code() { return ROLL_MODE_SORT }
-  get name() { return `lancer un sort` }
-
-  visible(rollData) { return rollData.active.actor.isHautRevant() }
-  title(rollData) { return `lance le sort:` }
-
-  onSelect(rollData) {
-    this.setDiffMode(rollData, DIFF_MODE.AUCUN)
-  }
-}
--- a/module/roll/roll-mode.mjs
+++ b/module/roll/roll-mode.mjs
@@ -1,54 +0,0 @@
-import { DIFF_MODE } from "./roll-constants.mjs"
-import { PART_DIFF } from "./roll-part-diff.mjs"
-
-const DEFAULT_DIFF_MODES = [DIFF_MODE.LIBRE, DIFF_MODE.IMPOSEE, DIFF_MODE.DEFAUT]
-
-export class RollMode {
-
-  onReady() { }
-
-  get code() { throw new Error(`Pas de code défini pour ${this}`) }
-  get name() { return this.code }
-  get icon() { return `systems/foundryvtt-reve-de-dragon/assets/actions/${this.code}.svg` }
-
-  toModeData(rollData) {
-    return { code: this.code, name: this.name, icon: this.icon, section: 'mode', template: this.template, selected: this.isSelected(rollData) }
-  }
-
-  isAllowed(rollData) { return rollData.mode.allowed == undefined || rollData.mode.allowed.includes(this.code) }
-  visible(rollData) { return true }
-
-  title(rollData) { return this.code }
-  isSelected(rollData) { return rollData.mode.current == this.code }
-
-  setRollDataMode(rollData) {
-    rollData.mode.opposed = rollData.opponent != undefined
-    rollData.mode.resistance = false /** TODO */
-  }
-
-  onSelect(rollData) {
-    const mode = [
-      rollData.current[PART_DIFF].mode,
-      this.modeFromOpponents(rollData),
-      rollData.selected[PART_DIFF].mode].find(m => DEFAULT_DIFF_MODES.includes(m))
-
-    this.setDiffMode(rollData, mode ??
-      DIFF_MODE.DEFAUT)
-  }
-
-
-  modeFromOpponents(rollData) {
-    if (rollData.mode.opposed) {
-      if (rollData.mode.resistance) {
-        return DIFF_MODE.IMPOSEE
-      }
-      return DIFF_MODE.LIBRE
-    }
-    return undefined
-  }
-
-  setDiffMode(rollData, mode) {
-    rollData.current[PART_DIFF].mode = mode
-    this.setRollDataMode(rollData)
-  }
-}
--- a/module/roll/roll-part-action.mjs
+++ b/module/roll/roll-part-action.mjs
@@ -8,12 +8,12 @@ export class RollPartAction extends RollPart {
  get section() { return ROLLDIALOG_SECTION.ACTION }

  title(rollData) {
-    return rollData.mode.label
+    return rollData.type.label
  }

  prepareContext(rollData) {
    const current = this.getCurrent(rollData)
-    current.verb = rollData.mode.label
+    current.verb = rollData.type.label
  }

 }
--- a/module/roll/roll-part-astrologique.mjs
+++ b/module/roll/roll-part-astrologique.mjs
@@ -10,10 +10,8 @@ export class RollPartAstrologique extends RollPartCheckbox {
  get useCheckboxTemplate() { return false }

  visible(rollData) {
-    return this.$isUsingAstrologie() && (
-      this.isJetChance(rollData)
-      || this.isLancementRituel(rollData)
-    )
+    return this.$isUsingAstrologie()
+      && (this.isJetChance(rollData) || this.isLancementRituel(rollData))
  }

  isLancementRituel(rollData) {
--- a/module/roll/roll-part-attaque.mjs
+++ b/module/roll/roll-part-attaque.mjs
@@ -1,6 +1,6 @@
 import { RdDBonus } from "../rdd-bonus.js"
 import { StatusEffects } from "../settings/status-effects.js"
-import { ROLL_MODE_ATTAQUE } from "./roll-constants.mjs"
+import { ROLL_TYPE_ATTAQUE } from "./roll-constants.mjs"
 import { PART_CARAC } from "./roll-part-carac.mjs"
 import { PART_COMP } from "./roll-part-comp.mjs"
 import { RollPartSelect } from "./roll-part-select.mjs"
@@ -16,7 +16,7 @@ export class RollPartAttaque extends RollPartSelect {
  get code() { return PART_ATTAQUE }
  get section() { return ROLLDIALOG_SECTION.CHOIX }

-  visible(rollData) { return this.isRollMode(rollData, ROLL_MODE_ATTAQUE) }
+  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_ATTAQUE) }

  loadRefs(rollData) {
    const refs = this.getRefs(rollData)
@@ -41,25 +41,25 @@ export class RollPartAttaque extends RollPartSelect {

  prepareContext(rollData) {
    const current = this.getCurrent(rollData)
-    current.defenseur = StatusEffects.getActorEffetSurprise(rollData.opponent?.actor, 0)
-    current.attaquant = StatusEffects.getActorEffetSurprise(rollData.active.actor, current.attaque.forceRequise)
    current.dmg = this.$dmgRollV2(rollData, current)
  }

  $dmgRollV2(rollData, current) {
    const actor = rollData.active.actor
-    const defender = rollData.opponent?.actor
-    const dmgArme = RdDBonus.dmgArme(current.attaque.arme, current.attaque.dommagesArme)
+    const attaque = current.attaque
+    const arme = attaque.arme
+    const dmgArme = RdDBonus.dmgArme(arme, attaque.dommagesArme)
+
    const dmg = {
      total: 0,
      dmgArme: dmgArme,
-      penetration: current.attaque.arme.penetration(),
+      penetration: arme.penetration(),
      dmgTactique: current.tactique?.dmg ?? 0,
      dmgParticuliere: 0, // TODO RdDBonus._dmgParticuliere(rollData),
-      dmgSurprise: current.surpriseDefenseur?.dmg ?? 0,
-      mortalite: RdDBonus.mortalite(current.dmg?.mortalite, current.attaque.arme.system.mortalite, defender?.isEntite()),
-      dmgActor: RdDBonus.bonusDmg(actor, current.attaque.carac.key, dmgArme, current.attaque.forceRequise),
-      dmgForceInsuffisante: Math.min(0, actor.getForce() - current.attaque.forceRequise)
+      dmgSurprise: rollData.opponent?.surprise?.dmg ?? 0,
+      mortalite: RdDBonus.mortalite(current.dmg?.mortalite, arme.system.mortalite, rollData.opponent?.actor?.isEntite()),
+      dmgActor: RdDBonus.bonusDmg(actor, attaque.carac.key, dmgArme, attaque.forceRequise),
+      dmgForceInsuffisante: Math.min(0, actor.getForce() - attaque.forceRequise)
    }
    dmg.total = dmg.dmgSurprise + dmg.dmgTactique + dmg.dmgArme + dmg.dmgActor + dmg.dmgParticuliere + dmg.dmgForceInsuffisante
    return dmg
@@ -71,8 +71,8 @@ export class RollPartAttaque extends RollPartSelect {
    if (current.tactique) {
      ajustements.push({ label: current.tactique.label, diff: current.tactique.attaque })
    }
-    if (current.surpriseDefenseur) {
-      ajustements.push({ label: current.surpriseDefenseur.label, diff: current.surpriseDefenseur.attaque })
+    if (rollData.opponent?.surprise) {
+      ajustements.push({ label: rollData.opponent.surprise.label, diff: rollData.opponent.surprise.attaque })
    }
    return ajustements
  }
@@ -92,7 +92,6 @@ export class RollPartAttaque extends RollPartSelect {
      const selectOptions = e.currentTarget.options
      const index = selectOptions.selectedIndex
      this.$selectAttaque(rollDialog.rollData, selectOptions[index]?.value)
-      rollDialog.setModeTitle()
      rollDialog.render()
    })

@@ -115,7 +114,6 @@ export class RollPartAttaque extends RollPartSelect {
      switch (part.code) {
        case PART_CARAC: return part.filterCaracs(rollData, [current.attaque.carac.key])
        case PART_COMP: return part.filterComps(rollData, [current.attaque.comp?.name])
-        case PART_SIGN: return part.setArme(rollData, current.attaque.forceRequise, false)
      }
    }
    return undefined
--- a/module/roll/roll-part-carac.mjs
+++ b/module/roll/roll-part-carac.mjs
@@ -36,7 +36,7 @@ export class RollPartCarac extends RollPartSelect {
    }
  }

-  filterCaracs(rollData, allowed) {
+  filterCaracs(rollData, allowed = []) {
    allowed = allowed.filter(it => it != undefined)
    const refs = this.getRefs(rollData)
    refs.caracs = allowed.length > 0
--- a/module/roll/roll-part-comp.mjs
+++ b/module/roll/roll-part-comp.mjs
@@ -45,7 +45,7 @@ export class RollPartComp extends RollPartSelect {
    }
  }

-  filterComps(rollData, allowed) {
+  filterComps(rollData, allowed = []) {
    allowed = allowed.filter(it => it != undefined)
    const refs = this.getRefs(rollData)
    refs.comps = allowed.length > 0
--- a/module/roll/roll-part-defense.mjs
+++ b/module/roll/roll-part-defense.mjs
@@ -4,7 +4,7 @@ import { ATTAQUE_TYPE, RdDItemArme } from "../item/arme.js"
 import { RdDBonus } from "../rdd-bonus.js"
 import { CARACS } from "../rdd-carac.js"
 import { StatusEffects } from "../settings/status-effects.js"
-import { DIFF_MODE, ROLL_MODE_DEFENSE } from "./roll-constants.mjs"
+import { DIFF, ROLL_TYPE_DEFENSE } from "./roll-constants.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"
@@ -18,7 +18,7 @@ export class RollPartDefense extends RollPartSelect {

  get code() { return PART_DEFENSE }
  get section() { return ROLLDIALOG_SECTION.CHOIX }
-  visible(rollData) { return this.isRollMode(rollData, ROLL_MODE_DEFENSE) }
+  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_DEFENSE) }

  static getDiffAttaque(attackerRoll) {
    // TODO: rollDataV2?
@@ -47,6 +47,7 @@ export class RollPartDefense extends RollPartSelect {
      img: esquive.img,
      // TODO: carac pour créatures
      carac: defenseur.isPersonnage() ? CARACS.DEROBEE : esquive.name,
+      verb: "esquive",
      comp: esquive
    }
  }
@@ -61,6 +62,7 @@ export class RollPartDefense extends RollPartSelect {
      img: armeDefense.img,
      // TODO: carac pour créatures
      carac: defenseur.isPersonnage() ? CARACS.MELEE : comp.name,
+      verb: "pare",
      comp: comp,
      arme: armeDefense,
      forceRequise: armeDefense ? RdDItemArme.valeurMain(armeDefense.system.force ?? 0, RdDItemArme.getMainAttaque(comp)) : 0,
@@ -69,9 +71,6 @@ export class RollPartDefense extends RollPartSelect {
  }

  prepareContext(rollData) {
-    const current = this.getCurrent(rollData)
-    current.defenseur = StatusEffects.getActorEffetSurprise(rollData.active.actor, current.forceRequise)
-
    // current.dmg = this.$dmgRollV2(rollData, current)
  }

@@ -92,7 +91,6 @@ export class RollPartDefense extends RollPartSelect {
      const selectOptions = e.currentTarget.options
      const index = selectOptions.selectedIndex
      this.$selectDefense(rollDialog.rollData, selectOptions[index]?.value)
-      rollDialog.setModeTitle()
      rollDialog.render()
    })
  }
@@ -104,7 +102,7 @@ export class RollPartDefense extends RollPartSelect {
        case PART_CARAC: return part.filterCaracs(rollData, [current.carac])
        case PART_COMP: return part.filterComps(rollData, [current.comp?.name])
        case PART_DIFF: return part.setDiff(rollData, this.getDiffDefense(rollData))
-        case PART_SIGN: return part.setArme(rollData, current.forceRequise, this.isArmeDisparate(rollData))
+        case PART_SIGN: return part.setArmeDisparate(rollData, this.isArmeDisparate(rollData))
      }
    }
    return undefined
@@ -122,12 +120,12 @@ export class RollPartDefense extends RollPartSelect {
  getDiffDefense(rollData) {
    const current = this.getCurrent(rollData)
    const refs = this.getRefs(rollData)
-    if (refs.isDistance) {
+    if (refs.isDistance || !rollData.attaque) {
      // Déterminer la difficulté de parade
-      return { diff: 0, mode: DIFF_MODE.LIBRE }
+      return { diff: 0, type: DIFF.LIBRE }
    }
    else {
-      return { diff: rollData.attaque.diff, mode: DIFF_MODE.DEFENSE }
+      return { diff: rollData.attaque.diff ?? 0, type: DIFF.DEFENSE }
    }
  }
 }
--- a/module/roll/roll-part-diff.mjs
+++ b/module/roll/roll-part-diff.mjs
@@ -1,9 +1,9 @@
-import { DIFF_MODE, DIFF_MODES, ROLL_MODE_MEDITATION, ROLL_MODE_OEUVRE, ROLL_MODE_SORT, ROLL_MODE_TACHE } from "./roll-constants.mjs";
+import { DIFF, DIFFS, ROLL_TYPE_MEDITATION, ROLL_TYPE_OEUVRE, ROLL_TYPE_SORT, ROLL_TYPE_TACHE } from "./roll-constants.mjs";
 import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs";

 export const PART_DIFF = "diff"

-const EXCLUDED_ROLL_MODES = [ROLL_MODE_TACHE, ROLL_MODE_MEDITATION, ROLL_MODE_SORT, ROLL_MODE_OEUVRE]
+const EXCLUDED_ROLL_TYPES = [ROLL_TYPE_TACHE, ROLL_TYPE_MEDITATION, ROLL_TYPE_SORT, ROLL_TYPE_OEUVRE]

 export class RollPartDiff extends RollPart {

@@ -14,37 +14,37 @@ export class RollPartDiff extends RollPart {
    const current = this.getCurrent(rollData)
    const saved = this.getSaved(rollData)
    current.value = saved?.value ?? current.value ?? 0
-    current.mode = saved?.mode ?? current.mode
+    current.type = saved?.type ?? current.type
  }

  store(rollData, targetData) {
    const current = this.getCurrent(rollData)
    this.setSaved(targetData, {
      value: current.value,
-      mode: current.mode
+      type: current.type
    })
  }

  visible(rollData) {
-    if (EXCLUDED_ROLL_MODES.includes(rollData.mode.current)) {
+    if (EXCLUDED_ROLL_TYPES.includes(rollData.type.current)) {
      return false
    }
    const current = this.getCurrent(rollData)
    /* TODO: affiner les cas où afficher ou non. devrait s'afficher pour les jets basiques (même si pas d'opposant sélectionné)*/
-    return Object.values(DIFF_MODE).includes(current.mode)
+    return Object.values(DIFF).includes(current.type)
  }

  prepareContext(rollData) {
    const current = this.getCurrent(rollData)
-    const diffMode = DIFF_MODES[current.mode] ?? DIFF_MODES[DIFF_MODE.AUCUN]
+    const diffType = DIFFS[current.type] ?? DIFFS[DIFF.AUCUN]
    foundry.utils.mergeObject(current,
      {
-        mode: diffMode.key,
-        label: diffMode?.label ?? '',
+        type: diffType.key,
+        label: diffType?.label ?? '',
        value: current.value ?? 0,
-        disabled: !diffMode.libre,
+        disabled: !diffType.libre,
        min: -10,
-        max: diffMode.max
+        max: diffType.max
      },
      { inplace: true }
    )
@@ -53,7 +53,7 @@ export class RollPartDiff extends RollPart {
  setDiff(rollData, diffDefense) {
    const current = this.getCurrent(rollData)
    current.value = diffDefense.diff
-    current.mode = diffDefense.mode
+    current.type = diffDefense.type
  }

  getAjustements(rollData) {
--- a/module/roll/roll-part-jeu.mjs
+++ b/module/roll/roll-part-jeu.mjs
@@ -1,7 +1,7 @@
 import { Grammar } from "../grammar.js"
 import { ITEM_TYPES } from "../constants.js"
 import { CARACS } from "../rdd-carac.js"
-import { ROLL_MODE_JEU } from "./roll-constants.mjs"
+import { ROLL_TYPE_JEU } from "./roll-constants.mjs"
 import { PART_CARAC } from "./roll-part-carac.mjs"
 import { PART_COMP } from "./roll-part-comp.mjs"
 import { RollPartSelect } from "./roll-part-select.mjs"
@@ -17,7 +17,7 @@ export class RollPartJeu extends RollPartSelect {
  get section() { return ROLLDIALOG_SECTION.CHOIX }

  isValid(rollData) { return rollData.active.actor.isPersonnage() }
-  visible(rollData) { return this.isRollMode(rollData, ROLL_MODE_JEU) }
+  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_JEU) }

  loadRefs(rollData) {
    const refs = this.getRefs(rollData)
@@ -68,8 +68,8 @@ export class RollPartJeu extends RollPartSelect {

  prepareContext(rollData) {
    const current = this.getCurrent(rollData)
-    if (rollData.mode.current == ROLL_MODE_JEU && current) {
-      rollData.mode.opposed = true
+    if (rollData.type.current == ROLL_TYPE_JEU && current) {
+      rollData.type.opposed = true
    }
  }

@@ -86,7 +86,6 @@ export class RollPartJeu extends RollPartSelect {
      const selectOptions = e.currentTarget.options
      const index = selectOptions.selectedIndex
      this.$selectJeu(rollDialog.rollData, selectOptions[index]?.value)
-      rollDialog.setModeTitle()
      rollDialog.render()
    })
  }
--- a/module/roll/roll-part-meditation.mjs
+++ b/module/roll/roll-part-meditation.mjs
@@ -3,7 +3,7 @@ import { Grammar } from "../grammar.js"
 import { CARACS, RdDCarac } from "../rdd-carac.js"
 import { RdDTimestamp } from "../time/rdd-timestamp.js"
 import { TMRUtility } from "../tmr-utility.js"
-import { ROLL_MODE_MEDITATION } from "./roll-constants.mjs"
+import { ROLL_TYPE_MEDITATION } from "./roll-constants.mjs"
 import { PART_CARAC } from "./roll-part-carac.mjs"
 import { PART_COMP } from "./roll-part-comp.mjs"
 import { RollPartSelect } from "./roll-part-select.mjs"
@@ -17,7 +17,7 @@ export class RollPartMeditation extends RollPartSelect {
  get section() { return ROLLDIALOG_SECTION.CHOIX }

  isValid(rollData) { return rollData.active.actor.isPersonnage() && rollData.active.actor.isHautRevant() }
-  visible(rollData) { return this.isRollMode(rollData, ROLL_MODE_MEDITATION) }
+  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_MEDITATION) }

  loadRefs(rollData) {
    const refs = this.getRefs(rollData)
@@ -86,7 +86,6 @@ export class RollPartMeditation extends RollPartSelect {
      const index = selectOptions.selectedIndex
      this.$selectMeditation(rollDialog.rollData, selectOptions[index]?.value)
      rollDialog.render()
-      rollDialog.setModeTitle()
    })

    this.setupListenerCondition(rollDialog, 'isComportement')
--- a/module/roll/roll-part-oeuvre.mjs
+++ b/module/roll/roll-part-oeuvre.mjs
@@ -2,7 +2,7 @@ import { ITEM_TYPES } from "../constants.js"
 import { Grammar } from "../grammar.js"
 import { Misc } from "../misc.js"
 import { CARACS } from "../rdd-carac.js"
-import { ROLL_MODE_OEUVRE } from "./roll-constants.mjs"
+import { ROLL_TYPE_OEUVRE } from "./roll-constants.mjs"
 import { PART_CARAC } from "./roll-part-carac.mjs"
 import { PART_COMP } from "./roll-part-comp.mjs"
 import { RollPartSelect } from "./roll-part-select.mjs"
@@ -38,7 +38,7 @@ export class RollPartOeuvre extends RollPartSelect {
  get section() { return ROLLDIALOG_SECTION.CHOIX }

  isValid(rollData) { return rollData.active.actor.isPersonnage() }
-  visible(rollData) { return this.isRollMode(rollData, ROLL_MODE_OEUVRE) }
+  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_OEUVRE) }

  loadRefs(rollData) {
    const refs = this.getRefs(rollData)
@@ -80,7 +80,6 @@ export class RollPartOeuvre extends RollPartSelect {
      const selectOptions = e.currentTarget.options
      const index = selectOptions.selectedIndex
      this.$selectOeuvre(rollDialog.rollData, selectOptions[index]?.value)
-      rollDialog.setModeTitle()
      rollDialog.render()
    })
  }
--- a/module/roll/roll-part-opponent.mjs
+++ b/module/roll/roll-part-opponent.mjs
@@ -7,6 +7,6 @@ export class RollPartOpponent extends RollPart {
  get code() { return OPPONENT }
  get section() { return ROLLDIALOG_SECTION.ACTION }

-  visible(rollData) { return rollData.mode.opposed }
+  visible(rollData) { return rollData.type.opposed }
  title(rollData) { return rollData.opponent?.name ?? '' }
 }
--- a/module/roll/roll-part-sign.mjs
+++ b/module/roll/roll-part-sign.mjs
@@ -1,7 +1,7 @@
 import { Misc } from "../misc.js"
 import { ReglesOptionnelles } from "../settings/regles-optionnelles.js"
 import { StatusEffects } from "../settings/status-effects.js"
-import { ROLL_MODE_ATTAQUE, ROLL_MODE_DEFENSE } from "./roll-constants.mjs"
+import { ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE } from "./roll-constants.mjs"
 import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"

 export const PART_SIGN = "sign"
@@ -24,7 +24,7 @@ export class RollPartSign extends RollPart {
  }

  isCombat(rollData) {
-    return [ROLL_MODE_ATTAQUE, ROLL_MODE_DEFENSE].includes(rollData.mode.current) || rollData.mode.isCombat
+    return [ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE].includes(rollData.type.current) || rollData.type.isCombat
  }

  prepareContext(rollData) {
@@ -32,15 +32,14 @@ export class RollPartSign extends RollPart {
  }

  setFromState(rollData) {
-    if (rollData.mode.retry) {
+    if (rollData.type.retry) {
      return
    }
    const actor = rollData.active.actor;
    const isCombat = this.isCombat(rollData)
    const current = this.getCurrent(rollData)
    current.armeDisparate = isCombat && current.armeDisparate
-    current.forceRequise = current.forceRequise ?? 0
-    current.surprise = actor.getSurprise(isCombat)
+    current.surprise = actor.getSurprise(isCombat) // TODO: could be from rollData.active.surprise??
    current.reasons = actor.getEffects(it => StatusEffects.niveauSurprise(it) > 0).map(it => it.name)
    current.diviseur = 1
    if (current.surprise == 'demi') {
@@ -53,10 +52,6 @@ export class RollPartSign extends RollPart {
      current.diviseur *= 2
      current.reasons.push('Armes disparates')
    }
-    if (this.isForceInsuffisante(actor, current)) {
-      current.diviseur *= 2
-      current.reasons.push('Force insuffisante')
-    }
    if (this.isAttaqueFinesse(rollData)) {
      current.diviseur *= 2
      current.reasons.push('Particulière en finesse')
@@ -70,16 +65,7 @@ export class RollPartSign extends RollPart {
  }

  isAttaqueFinesse(rollData) {
-    return ROLL_MODE_DEFENSE == rollData.mode.current && rollData.attaque.particuliere == 'finesse'
-  }
-
-  isForceInsuffisante(actor, current) {
-    if (actor?.isPersonnage()) {
-      const requise = current.forceRequise
-      const force = parseInt(actor.system.carac.force.value)
-      return requise > force
-    }
-    return false
+    return ROLL_TYPE_DEFENSE == rollData.type.current && rollData.attaque?.particuliere == 'finesse'
  }

  isParadeArmeDisparate(current) {
@@ -106,9 +92,7 @@ export class RollPartSign extends RollPart {
    })
  }

-  setArme(rollData, forceRequise, armeDisparate) {
-    const current = this.getCurrent(rollData)
-    current.armeDisparate = armeDisparate
-    current.forceRequise = forceRequise
+  setArmeDisparate(rollData, armeDisparate) {
+    this.getCurrent(rollData).armeDisparate = armeDisparate
  }
 }
--- a/module/roll/roll-part-sort.mjs
+++ b/module/roll/roll-part-sort.mjs
@@ -1,5 +1,5 @@
 import { ITEM_TYPES } from "../constants.js"
-import { ROLL_MODE_SORT } from "./roll-constants.mjs"
+import { ROLL_TYPE_SORT } from "./roll-constants.mjs"
 import { PART_CARAC } from "./roll-part-carac.mjs"
 import { PART_COMP } from "./roll-part-comp.mjs"
 import { ROLLDIALOG_SECTION } from "./roll-part.mjs"
@@ -18,7 +18,7 @@ export class RollPartSort extends RollPartSelect {
  get section() { return ROLLDIALOG_SECTION.CHOIX }

  isValid(rollData) { return rollData.active.actor.isPersonnage() && rollData.active.actor.isHautRevant() }
-  visible(rollData) { return this.isRollMode(rollData, ROLL_MODE_SORT) }
+  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_SORT) }

  loadRefs(rollData) {
    const refs = this.getRefs(rollData)
@@ -98,7 +98,6 @@ export class RollPartSort extends RollPartSelect {
      const selectOptions = e.currentTarget.options
      const index = selectOptions.selectedIndex
      this.$selectSort(rollDialog.rollData, selectOptions[index]?.value)
-      rollDialog.setModeTitle()
      rollDialog.render()
    })

--- a/module/roll/roll-part-tache.mjs
+++ b/module/roll/roll-part-tache.mjs
@@ -1,6 +1,6 @@
 import { ITEM_TYPES } from "../constants.js"
 import { Grammar } from "../grammar.js"
-import { ROLL_MODE_TACHE } from "./roll-constants.mjs"
+import { ROLL_TYPE_TACHE } from "./roll-constants.mjs"
 import { PART_CARAC } from "./roll-part-carac.mjs"
 import { PART_COMP } from "./roll-part-comp.mjs"
 import { RollPartSelect } from "./roll-part-select.mjs"
@@ -14,7 +14,7 @@ export class RollPartTache extends RollPartSelect {
  get section() { return ROLLDIALOG_SECTION.CHOIX }

  isValid(rollData) { return rollData.active.actor.isPersonnage() }
-  visible(rollData) { return this.isRollMode(rollData, ROLL_MODE_TACHE) }
+  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_TACHE) }

  loadRefs(rollData) {
    const refs = this.getRefs(rollData)
@@ -48,7 +48,6 @@ export class RollPartTache extends RollPartSelect {
      const selectOptions = e.currentTarget.options
      const index = selectOptions.selectedIndex
      this.$selectTache(rollDialog.rollData, selectOptions[index]?.value)
-      rollDialog.setModeTitle()
      rollDialog.render()
    })
  }
--- a/module/roll/roll-part.mjs
+++ b/module/roll/roll-part.mjs
@@ -60,7 +60,7 @@ export class RollPart {
   * @returns une chaîne vide si rien ne doit être affiché
  */
  title() { return '' }
-  isRollMode(rollData, mode) { return rollData.mode.current == mode }
+  isRollType(rollData, type) { return rollData.type.current == type }

  isActive(rollData) { return this.isValid(rollData) && this.visible(rollData) }
  isValid(rollData) { return true }
--- a/module/roll/roll-type-attaque.mjs
+++ b/module/roll/roll-type-attaque.mjs
@@ -0,0 +1,13 @@
+import { DIFF, ROLL_TYPE_ATTAQUE } from "./roll-constants.mjs"
+import { RollType } from "./roll-type.mjs"
+
+export class RollTypeAttaque extends RollType {
+  get code() { return ROLL_TYPE_ATTAQUE }
+  get name() { return `Attaquer` }
+
+  title(rollData) { return `attaque` }
+
+  onSelect(rollData) {
+    this.setDiffType(rollData, DIFF.ATTAQUE)
+  }
+}
--- a/module/roll/roll-type-comp.mjs
+++ b/module/roll/roll-type-comp.mjs
@@ -0,0 +1,10 @@
+import { ROLL_TYPE_COMP } from "./roll-constants.mjs"
+import { RollType } from "./roll-type.mjs"
+
+export class RollTypeComp extends RollType {
+  get code() { return ROLL_TYPE_COMP }
+  get name() { return `Jet de caractéristique / compétence` }
+
+  title(rollData) { return `fait un jet ${rollData.type.opposed ? ' contre ' : ''}` }
+
+}
--- a/module/roll/roll-type-defense.mjs
+++ b/module/roll/roll-type-defense.mjs
@@ -0,0 +1,17 @@
+import { DIFF, ROLL_TYPE_DEFENSE } from "./roll-constants.mjs"
+import { RollType } from "./roll-type.mjs"
+
+export class RollTypeDefense extends RollType {
+  get code() { return ROLL_TYPE_DEFENSE }
+  get name() { return `Se défendre` }
+
+  title(rollData) { return `se défend${rollData.opponent ? ' de' : ''}` }
+
+  getOpponent(rollData) {
+    return rollData.attacker
+  }
+
+  onSelect(rollData) {
+    this.setDiffType(rollData, DIFF.DEFENSE)
+  }
+}
--- a/module/roll/roll-type-jeu.mjs
+++ b/module/roll/roll-type-jeu.mjs
@@ -1,9 +1,9 @@
 import { PART_JEU } from "./roll-part-jeu.mjs"
-import { RollMode } from "./roll-mode.mjs"
-import { ROLL_MODE_JEU } from "./roll-constants.mjs"
+import { RollType } from "./roll-type.mjs"
+import { ROLL_TYPE_JEU } from "./roll-constants.mjs"

-export class RollModeJeu extends RollMode {
-  get code() { return ROLL_MODE_JEU }
+export class RollTypeJeu extends RollType {
+  get code() { return ROLL_TYPE_JEU }
  get name() { return `Jouer` }

  visible(rollData) { return rollData.active.actor.isPersonnage() }
--- a/module/roll/roll-type-meditation.mjs
+++ b/module/roll/roll-type-meditation.mjs
@@ -1,9 +1,9 @@
-import { DIFF_MODE, ROLL_MODE_MEDITATION } from "./roll-constants.mjs"
+import { DIFF, ROLL_TYPE_MEDITATION } from "./roll-constants.mjs"
 import { PART_MEDITATION } from "./roll-part-meditation.mjs"
-import { RollMode } from "./roll-mode.mjs"
+import { RollType } from "./roll-type.mjs"

-export class RollModeMeditation extends RollMode {
-  get code() { return ROLL_MODE_MEDITATION }
+export class RollTypeMeditation extends RollType {
+  get code() { return ROLL_TYPE_MEDITATION }
  get name() { return `Méditation draconique` }

  visible(rollData) { return rollData.active.actor.isHautRevant() }
@@ -14,6 +14,6 @@ export class RollModeMeditation extends RollMode {
  }

  onSelect(rollData) {
-    this.setDiffMode(rollData, DIFF_MODE.AUCUN)
+    this.setDiffType(rollData, DIFF.AUCUN)
  }
 }
--- a/module/roll/roll-type-oeuvre.mjs
+++ b/module/roll/roll-type-oeuvre.mjs
@@ -1,9 +1,9 @@
-import { DIFF_MODE, ROLL_MODE_OEUVRE } from "./roll-constants.mjs"
+import { DIFF, ROLL_TYPE_OEUVRE } from "./roll-constants.mjs"
 import { PART_OEUVRE } from "./roll-part-oeuvre.mjs"
-import { RollMode } from "./roll-mode.mjs"
+import { RollType } from "./roll-type.mjs"

-export class RollModeOeuvre extends RollMode {
-  get code() { return ROLL_MODE_OEUVRE }
+export class RollTypeOeuvre extends RollType {
+  get code() { return ROLL_TYPE_OEUVRE }
  get name() { return `Interpréter une oeuvre` }

  visible(rollData) { return rollData.active.actor.isPersonnage() }
@@ -13,7 +13,7 @@ export class RollModeOeuvre extends RollMode {
  }

  onSelect(rollData) {
-    this.setDiffMode(rollData, DIFF_MODE.AUCUN)
+    this.setDiffType(rollData, DIFF.AUCUN)
  }
 }

--- a/module/roll/roll-type-sort.mjs
+++ b/module/roll/roll-type-sort.mjs
@@ -0,0 +1,14 @@
+import { DIFF, ROLL_TYPE_SORT } from "./roll-constants.mjs"
+import { RollType } from "./roll-type.mjs"
+
+export class RollTypeSort extends RollType {
+  get code() { return ROLL_TYPE_SORT }
+  get name() { return `lancer un sort` }
+
+  visible(rollData) { return rollData.active.actor.isHautRevant() }
+  title(rollData) { return `lance le sort:` }
+
+  onSelect(rollData) {
+    this.setDiffType(rollData, DIFF.AUCUN)
+  }
+}
--- a/module/roll/roll-type-tache.mjs
+++ b/module/roll/roll-type-tache.mjs
@@ -1,9 +1,9 @@
-import { DIFF_MODE, ROLL_MODE_TACHE } from "./roll-constants.mjs"
+import { DIFF, ROLL_TYPE_TACHE } from "./roll-constants.mjs"
 import { PART_TACHE } from "./roll-part-tache.mjs"
-import { RollMode } from "./roll-mode.mjs"
+import { RollType } from "./roll-type.mjs"

-export class RollModeTache extends RollMode {
-  get code() { return ROLL_MODE_TACHE }
+export class RollTypeTache extends RollType {
+  get code() { return ROLL_TYPE_TACHE }
  get name() { return `Travailler à une tâche` }

  visible(rollData) { return rollData.active.actor.isPersonnage() }
@@ -14,6 +14,6 @@ export class RollModeTache extends RollMode {
  }

  onSelect(rollData) {
-    this.setDiffMode(rollData, DIFF_MODE.AUCUN)
+    this.setDiffType(rollData, DIFF.AUCUN)
  }
 }
--- a/module/roll/roll-type.mjs
+++ b/module/roll/roll-type.mjs
@@ -0,0 +1,55 @@
+import { DIFF } from "./roll-constants.mjs"
+import { PART_DIFF } from "./roll-part-diff.mjs"
+
+const DEFAULT_DIFF_TYPES = [DIFF.LIBRE, DIFF.IMPOSEE, DIFF.DEFAUT]
+
+export class RollType {
+
+  onReady() { }
+
+  get code() { throw new Error(`Pas de code défini pour ${this}`) }
+  get name() { return this.code }
+  get icon() { return `systems/foundryvtt-reve-de-dragon/assets/actions/${this.code}.svg` }
+  get chatResultTemplate() { return `systems/foundryvtt-reve-de-dragon/templates/roll/result/chat-${this.code}.hbs` }
+  
+  toTypeData(rollData) {
+    return { code: this.code, name: this.name, icon: this.icon, section: 'type', template: this.template, selected: this.isSelected(rollData) }
+  }
+
+  isAllowed(rollData) { return rollData.type.allowed == undefined || rollData.type.allowed.includes(this.code) }
+  visible(rollData) { return true }
+
+  title(rollData) { return this.code }
+  isSelected(rollData) { return rollData.type.current == this.code }
+
+  setRollDataType(rollData) {
+    rollData.type.opposed = rollData.opponent != undefined
+    rollData.type.resistance = false /** TODO */
+  }
+
+  onSelect(rollData) {
+    const possibleTypes = [
+      rollData.current[PART_DIFF].type,
+      this.typeFromOpponents(rollData),
+      rollData.selected[PART_DIFF].type
+    ]
+    const type = possibleTypes.find(m => DEFAULT_DIFF_TYPES.includes(m)) ??DIFF.DEFAUT
+    this.setDiffType(rollData, type)
+  }
+
+
+  typeFromOpponents(rollData) {
+    if (rollData.type.opposed) {
+      if (rollData.type.resistance) {
+        return DIFF.IMPOSEE
+      }
+      return DIFF.LIBRE
+    }
+    return undefined
+  }
+
+  setDiffType(rollData, type) {
+    rollData.current[PART_DIFF].type = type
+    this.setRollDataType(rollData)
+  }
+}
--- a/templates/chat-demande-attaque-etotal.hbs
+++ b/templates/chat-demande-attaque-etotal.hbs
@@ -1,5 +1,11 @@
 <div data-passearme="{{passeArme}}">
-  <h4 class="rdd-roll-etotal"><strong>Echec total en attaque</strong></h4>
+  <h4 class="rdd-roll-etotal">Maladresse à l'attaque:<br>échec
+  {{#if rolled.isETotal}}
+  total
+  {{else}}
+  en demi-surprise
+  {{/if}}
+  </h4>
  <br>
  {{#if (eq attacker.type 'personnage')}}
    {{#unless essais.attaqueChance}}
--- a/templates/chat-demande-defense.hbs
+++ b/templates/chat-demande-defense.hbs
@@ -49,45 +49,46 @@
            {{/if}}
          </a>
          <br>
-          {{/if}}
-          {{#each armes as |arme key|}}
-            <a class='chat-card-button parer-button'
-              data-attackerId='{{../attackerId}}' data-defenderTokenId='{{../defenderToken.id}}' data-attackerTokenId='{{../attackerToken.id}}'
-              data-armeid='{{arme._id}}'>
-              Parer avec {{arme.name}}
-              {{#if (or (eq ../attaqueCategorie 'tir') (eq ../attaqueCategorie 'lancer'))}}
-              (difficulté à déterminer)
-              {{else}}à {{../diffLibre }}
-              {{/if}}
-              {{#if (eq arme.typeParade 'sign')}}
-              <span class="rdd-diviseur">&times;&frac12;</span>
-              {{/if}}
-              {{#if arme.nbUsage}}(Utilisations : {{arme.nbUsage}}){{/if}}
-            </a>
-            <br>
+          {{else}}
+            {{#each armes as |arme key|}}
+              <a class='chat-card-button parer-button'
+                data-attackerId='{{../attackerId}}' data-defenderTokenId='{{../defenderToken.id}}' data-attackerTokenId='{{../attackerToken.id}}'
+                data-armeid='{{arme._id}}'>
+                Parer avec {{arme.name}}
+                {{#if (or (eq ../attaqueCategorie 'tir') (eq ../attaqueCategorie 'lancer'))}}
+                (difficulté à déterminer)
+                {{else}}à {{../diffLibre }}
+                {{/if}}
+                {{#if (eq arme.typeParade 'sign')}}
+                <span class="rdd-diviseur">&times;&frac12;</span>
+                {{/if}}
+                {{#if arme.nbUsage}}(Utilisations : {{arme.nbUsage}}){{/if}}
+              </a>
+              <br>
            {{/each}}
            {{#if mainsNues}}
-            <a class='chat-card-button parer-button'
-              data-attackerId='{{attackerId}}' data-defenderTokenId='{{defenderToken.id}}' data-attackerTokenId='{{attackerToken.id}}'
-              data-armeid='{{arme._id}}' data-competence='{{arme.system.competence}}'>
-              Parer à mains nues à {{diffLibre}}{{#if arme.nbUsage}} (Utilisations : {{arme.nbUsage}}){{/if}}
-          </a>
-          <br>
-          {{/if}}
-          {{#if (ne attaqueCategorie 'tir')}}
-          {{#each esquives as |esquive key|}}
-            <a class='chat-card-button esquiver-button' 
-              data-attackerId='{{../attackerId}}' data-defenderTokenId='{{../defenderToken.id}}' data-attackerTokenId='{{../attackerToken.id}}'
-              data-compid='{{esquive._id}}'  data-competence='{{esquive.name}}'>
-              {{esquive.name}}
-              {{#if (or (eq ../attaqueCategorie 'tir') (eq ../attaqueCategorie 'lancer'))}}
-              (difficulté à déterminer)
-              {{else}}à {{../diffLibre }}
-              {{/if}}
-              {{#if esquive.nbUsage}}(Utilisations : {{esquive.nbUsage}}){{/if}}
-            </a>
-            <br>
-            {{/each}}
+              <a class='chat-card-button parer-button'
+                data-attackerId='{{attackerId}}' data-defenderTokenId='{{defenderToken.id}}' data-attackerTokenId='{{attackerToken.id}}'
+                data-armeid='{{arme._id}}' data-competence='{{arme.system.competence}}'>
+                Parer à mains nues à {{diffLibre}}{{#if arme.nbUsage}} (Utilisations : {{arme.nbUsage}}){{/if}}
+              </a>
+              <br>
+            {{/if}}
+            {{#if (ne attaqueCategorie 'tir')}}
+              {{#each esquives as |esquive key|}}
+                <a class='chat-card-button esquiver-button' 
+                  data-attackerId='{{../attackerId}}' data-defenderTokenId='{{../defenderToken.id}}' data-attackerTokenId='{{../attackerToken.id}}'
+                  data-compid='{{esquive._id}}'  data-competence='{{esquive.name}}'>
+                  {{esquive.name}}
+                  {{#if (or (eq ../attaqueCategorie 'tir') (eq ../attaqueCategorie 'lancer'))}}
+                  (difficulté à déterminer)
+                  {{else}}à {{../diffLibre }}
+                  {{/if}}
+                  {{#if esquive.nbUsage}}(Utilisations : {{esquive.nbUsage}}){{/if}}
+                </a>
+                <br>
+              {{/each}}
+            {{/if}}
          {{/if}}
        {{/if}}
      {{/unless}}
--- a/templates/chat-infojet.hbs
+++ b/templates/chat-infojet.hbs
@@ -2,7 +2,6 @@
  <span {{#if ajustements}}class="tooltip-overflow tooltip-dotted" {{/if}}>
    <span>
      <span>{{rolled.caracValue}} à {{plusMoins rolled.finalLevel}}</span>
-      {{log rolled}}
      {{#if (and rolled.factorHtml (gt rolled.factorHtml 1))}}
        <span class="rdd-diviseur">&times;{{{rolled.factorHtml}}}</span>
        <span>= {{rolled.score}}%</span>
--- a/templates/roll/result/chat-attaque.hbs
+++ b/templates/roll/result/chat-attaque.hbs
--- a/templates/roll/result/chat-competence.hbs
+++ b/templates/roll/result/chat-competence.hbs
--- a/templates/roll/result/chat-defense.hbs
+++ b/templates/roll/result/chat-defense.hbs
@@ -0,0 +1,31 @@
+<h4>
+  {{log this}}
+  <img class="chat-icon" src="{{competence.img}}" data-tooltip="{{competence.name}}" />
+  {{alias}} esquive une attaque à {{diffLibre}}</h4>
+<p>{{selectedCarac.label}}{{#unless (eq selectedCarac.label competence.name)}} / {{competence.name}}{{/unless}}</p>
+{{> "systems/foundryvtt-reve-de-dragon/templates/chat-infojet.hbs"}}
+<hr>
+<p>
+  {{#if rolled.isSuccess}}
+  <span>Attaque esquivée!</span>
+    {{#if rolled.isPart}}
+    <!-- TODO: cas de parade à mains nues, texte à modifier -->
+    <span><strong>{{alias}} peut faire une deuxième esquive!</strong></span>
+    {{/if}}
+  {{else}}
+  <span>L'esquive de {{alias}} a échoué!</span>
+  {{/if}}
+  {{> "systems/foundryvtt-reve-de-dragon/templates/chat-info-appel-au-moral.hbs"}}
+</p>
+
+{{#if attackerRoll.tactique}}
+<p>
+  {{#if (eq attackerRoll.tactique 'charge')}}
+  <img class="chat-icon" src="icons/svg/thrust.svg" data-tooltip="charge" height="32" width="32" />
+  C'était une charge, les parades de l'adversaire de {{alias}} auront un -4 et il ne pourra pas esquiver!
+  {{ else if (eq attackerRoll.tactique 'feinte')}}
+  <img class="chat-icon" src="systems/foundryvtt-reve-de-dragon/icons/heures/hd06.svg" data-tooltip="feinte" height="32" width="32" />
+  C'était une feinte!
+  {{/if}}
+</p>
+{{/if}}
--- a/templates/roll/result/chat-jeu.hbs
+++ b/templates/roll/result/chat-jeu.hbs
--- a/templates/roll/result/chat-meditation.hbs
+++ b/templates/roll/result/chat-meditation.hbs
--- a/templates/roll/result/chat-oeuvre.hbs
+++ b/templates/roll/result/chat-oeuvre.hbs
--- a/templates/roll/result/chat-sort.hbs
+++ b/templates/roll/result/chat-sort.hbs
--- a/templates/roll/result/chat-tache.hbs
+++ b/templates/roll/result/chat-tache.hbs
--- a/templates/roll/roll-button.hbs
+++ b/templates/roll/roll-button.hbs
@@ -1,6 +1,14 @@
+{{#if (or rollData.type.passif (ne rollData.active.surprise.key 'totale'))}}
 <button name="roll-dialog-button">Lancer
 {{rollData.current.carac.value}} à {{plusMoins rollData.current.totaldiff}}
  {{#if rollData.current.significative.used}}
    <span class="rdd-diviseur">&times;{{{rollData.current.significative.label}}}</span>
  {{/if}}
 </button>
+{{else}}
+<button name="roll-dialog-button" disabled>
+  <i class="fa-solid fa-ban"></i>
+  Surprise totale!
+  <i class="fa-solid fa-ban"></i>
+</button>
+{{/if}}
--- a/templates/roll/roll-dialog.hbs
+++ b/templates/roll/roll-dialog.hbs
@@ -1,10 +1,6 @@
 <form class="roll-dialog">
  <roll-header></roll-header>
-  <roll-mode>
-    {{#each modes as |mode|}}
-    {{> 'roll-mode' mode}}
-    {{/each}}
-  </roll-mode>
+  <roll-type>{{> 'roll-type' types=types}}</roll-type>
  <roll-action>{{#each templates as |template|}}{{> 'roll-section' rollData=@root.rollData currentsection='action'}}{{/each}}</roll-action>
  <roll-carac>{{#each templates as |template|}}{{> 'roll-section' rollData=@root.rollData currentsection='carac'}}{{/each}}</roll-carac>
  <roll-comp>{{#each templates as |template|}}{{> 'roll-section' rollData=@root.rollData currentsection='comp'}}{{/each}}</roll-comp>
--- a/templates/roll/roll-mode.hbs
+++ b/templates/roll/roll-mode.hbs
@@ -1,3 +0,0 @@
-<button name="roll-mode" data-tooltip="{{name}}" data-mode="{{code}}" data-checked="{{selected}}">
-  <img src="{{icon}}">
-</button>
--- a/templates/roll/roll-part-astrologique.hbs
+++ b/templates/roll/roll-part-astrologique.hbs
@@ -1,2 +1,2 @@
 <input name="{{code}}" type="checkbox" {{#if current.checked}}checked{{/if}}/>
-<label for="{{code}}">{{current.label}}</label>
+<label for="{{code}}">{{refs.label}}</label>
--- a/templates/roll/roll-part-attaque.hbs
+++ b/templates/roll/roll-part-attaque.hbs
@@ -1,5 +1,5 @@
 <subline>
-  <select name="select-attaque" {{#if rollData.mode.retry}}disabled{{/if}}>
+  <select name="select-attaque" {{#if rollData.type.retry}}disabled{{/if}}>
    {{selectOptions refs.attaques selected=current.key valueAttr="key" labelAttr="label"}}
  </select>
 </subline>
@@ -11,7 +11,7 @@
 <roll-part-detail>
  <subline>
    <label for="select-tactique">Tactique:</label>
-    <select name="select-tactique" {{#if rollData.mode.retry}}disabled{{/if}}>
+    <select name="select-tactique" {{#if rollData.type.retry}}disabled{{/if}}>
      {{selectOptions refs.tactiques selected=current.tactique.key valueAttr="key" labelAttr="label"}}
    </select>
  </subline>
@@ -28,22 +28,22 @@
      </label>
    {{/if}}
  </subline>
-  {{#if current.attaquant.effets}}
+  {{#if rollData.active.effets}}
  <subline>
    <span class="status-surprise">
-      Attaquant en&nbsp;<strong>{{lowerFirst current.attaquant.surprise.label}}</strong>:&nbsp;
-      {{#each current.attaquant.effets as |effect|}}
+      Attaquant en&nbsp;<strong>{{lowerFirst rollData.active.surprise.label}}</strong>:&nbsp;
+      {{#each rollData.active.effets as |effect|}}
        {{localize effect.name}}
        <img class="button-effect-img" src="{{effect.img}}" data-tooltip="{{localize effect.name}}" data-effect="{{effect.id}}"/>
      {{/each}}
    </span>
  </subline>
  {{/if}}
-  {{#if current.defenseur.surprise}}
+  {{#if rollData.opponent.surprise}}
  <subline>
    <span class="status-surprise">
-      Defenseur en&nbsp;<strong>{{lowerFirst current.defenseur.surprise.label}}</strong>:&nbsp;
-      {{#each current.defenseur.effets as |effect|}}
+      Defenseur en&nbsp;<strong>{{lowerFirst rollData.opponent.surprise.label}}</strong>:&nbsp;
+      {{#each rollData.opponent.effets as |effect|}}
        {{localize effect.name}}
        <img class="button-effect-img" src="{{effect.img}}" data-tooltip="{{localize effect.name}}" data-effect="{{effect.id}}"/>
      {{/each}}
--- a/templates/roll/roll-part-carac.hbs
+++ b/templates/roll/roll-part-carac.hbs
@@ -1,4 +1,4 @@
-<select name="select-carac" {{#if (or rollData.mode.retry (eq refs.caracs.length 1))}}disabled{{/if}}>
+<select name="select-carac" {{#if (or rollData.type.retry (eq refs.caracs.length 1))}}disabled{{/if}}>
  {{selectOptions refs.caracs selected=current.key valueAttr="key" labelAttr="label"}}
 </select>
 <selected-numeric-value>{{current.value}}</selected-numeric-value>
--- a/templates/roll/roll-part-coeur.hbs
+++ b/templates/roll/roll-part-coeur.hbs
@@ -1,5 +1,5 @@
 <label for="{{code}}">Coeur</label>
-<select name="{{code}}" {{#if rollData.mode.retry}}disabled{{/if}}>
+<select name="{{code}}" {{#if rollData.type.retry}}disabled{{/if}}>
  {{selectOptions refs.amoureux selected=current.key valueAttr="key" labelAttr="label"}}
 </select>
 {{#if current.amour}}
--- a/templates/roll/roll-part-comp.hbs
+++ b/templates/roll/roll-part-comp.hbs
@@ -1,4 +1,4 @@
-<select name="select-comp"  {{#if (or rollData.mode.retry (eq refs.comps.length 1))}}disabled{{/if}}>
+<select name="select-comp"  {{#if (or rollData.type.retry (eq refs.comps.length 1))}}disabled{{/if}}>
  {{selectOptions refs.comps selected=current.key valueAttr="key" labelAttr="label"}}
 </select>
 <selected-numeric-value>{{plusMoins current.value}}</selected-numeric-value>
--- a/templates/roll/roll-part-conditions.hbs
+++ b/templates/roll/roll-part-conditions.hbs
@@ -4,5 +4,5 @@
    step=1
    min=current.min
    max=current.max
-    disabled=rollData.mode.retry
+    disabled=rollData.type.retry
 }}
--- a/templates/roll/roll-part-defense.hbs
+++ b/templates/roll/roll-part-defense.hbs
@@ -3,15 +3,15 @@
 </roll-part-img>
 <roll-part-detail>
  <subline>
-    <select name="select-defense" {{#if rollData.mode.retry}}disabled{{/if}}>
+    <select name="select-defense" {{#if rollData.type.retry}}disabled{{/if}}>
      {{selectOptions refs.defenses selected=current.key valueAttr="key" labelAttr="label"}}
    </select>
  </subline>
-  {{#if current.defenseur.effets}}
+  {{#if rollData.active.effets}}
  <subline>
    <span class="status-surprise">
-      Defense en&nbsp;<strong>{{lowerFirst current.defenseur.surprise.label}}</strong>:&nbsp;
-      {{#each current.defenseur.effets as  |effect|}}
+      Defense en&nbsp;<strong>{{lowerFirst rollData.active.surprise.label}}</strong>:&nbsp;
+      {{#each rollData.active.effets as  |effect|}}
        {{localize effect.name}}
        <img class="button-effect-img" src="{{effect.img}}" data-tooltip="{{localize effect.name}}" data-effect="{{effect.id}}"/>
      {{/each}}
--- a/templates/roll/roll-part-diff.hbs
+++ b/templates/roll/roll-part-diff.hbs
@@ -5,6 +5,6 @@
        step=1 
        min=current.min
        max=current.max
-        disabled=(or rollData.mode.retry current.disabled)
+        disabled=(or rollData.type.retry current.disabled)
    }}
 </subline>
--- a/templates/roll/roll-part-enctotal.hbs
+++ b/templates/roll/roll-part-enctotal.hbs
@@ -9,5 +9,5 @@
    step=1
    min=-30
    max=0
-    disabled=rollData.mode.retry
+    disabled=rollData.type.retry
 }}
--- a/templates/roll/roll-part-jeu.hbs
+++ b/templates/roll/roll-part-jeu.hbs
@@ -3,7 +3,7 @@
 </roll-part-img>
 <roll-part-detail>
  <subline>
-    <select name="select-jeu" {{#if rollData.mode.retry}}disabled{{/if}}>
+    <select name="select-jeu" {{#if rollData.type.retry}}disabled{{/if}}>
      {{selectOptions refs.jeux selected=current.key valueAttr="key" labelAttr="label"}}
    </select>
    <selected-numeric-value>{{plusMoins current.value}}</selected-numeric-value>
--- a/templates/roll/roll-part-meditation.hbs
+++ b/templates/roll/roll-part-meditation.hbs
@@ -6,7 +6,7 @@
    Rêve actuel: {{rollData.active.actor.system.reve.reve.value}}
  </subline>
  <subline>
-    <select name="select-meditation" {{#if rollData.mode.retry}}disabled{{/if}}>
+    <select name="select-meditation" {{#if rollData.type.retry}}disabled{{/if}}>
      {{selectOptions refs.meditations selected=current.key valueAttr="key" labelAttr="label"}}
    </select>
    {{#if current.meditation.system.malus}}
@@ -28,14 +28,14 @@
  <subline>Durée:&nbsp;60 minutes</subline>
  <hr>
  <subline>
-    <input class="conditionMeditation" type="checkbox" name="isComportement" {{#if current.isComportement}}checked{{/if}} {{#if rollData.mode.retry}}disabled{{/if}}/>
+    <input class="conditionMeditation" type="checkbox" name="isComportement" {{#if current.isComportement}}checked{{/if}} {{#if rollData.type.retry}}disabled{{/if}}/>
    <label for="isComportement">Comportement:&nbsp;
      <span name="comportement">{{current.meditation.system.comportement}}</span>
    </label>
  </subline>

  <subline>
-    <input class="conditionMeditation" type="checkbox" name="isHeure" {{#if current.isHeure}}checked{{/if}} {{#if rollData.mode.retry}}disabled{{/if}}/>
+    <input class="conditionMeditation" type="checkbox" name="isHeure" {{#if current.isHeure}}checked{{/if}} {{#if rollData.type.retry}}disabled{{/if}}/>
    <label for="isHeure">Heure:&nbsp;
      {{#with current.meditation.system.heure as |heure|}}
      <span name="heure">{{timestamp-label heure}}</span>
@@ -45,13 +45,13 @@
  </subline>

  <subline>
-    <input class="conditionMeditation" type="checkbox" name="isPurification" {{#if current.isPurification}}checked{{/if}} {{#if rollData.mode.retry}}disabled{{/if}}/>
+    <input class="conditionMeditation" type="checkbox" name="isPurification" {{#if current.isPurification}}checked{{/if}} {{#if rollData.type.retry}}disabled{{/if}}/>
    <label for="isPurification">Purification:&nbsp;
      <span name="purification">{{current.meditation.system.purification}}</span></label>
  </subline>

  <subline>
-    <input class="conditionMeditation" type="checkbox" name="isVeture" {{#if current.isVeture}}checked{{/if}} {{#if rollData.mode.retry}}disabled{{/if}}/>
+    <input class="conditionMeditation" type="checkbox" name="isVeture" {{#if current.isVeture}}checked{{/if}} {{#if rollData.type.retry}}disabled{{/if}}/>
    <label for="isVeture">Vêture:&nbsp;
      <span name="veture">{{current.meditation.system.veture}}</span>
    </label>
--- a/templates/roll/roll-part-oeuvre.hbs
+++ b/templates/roll/roll-part-oeuvre.hbs
@@ -3,7 +3,7 @@
 </roll-part-img>
 <roll-part-detail>
  <subline>
-    <select name="select-oeuvre" {{#if rollData.mode.retry}}disabled{{/if}}>
+    <select name="select-oeuvre" {{#if rollData.type.retry}}disabled{{/if}}>
      {{selectOptions refs.oeuvres selected=current.key valueAttr="key" labelAttr="label"}}
    </select>
    {{#if current.oeuvre}}
--- a/templates/roll/roll-part-sort.hbs
+++ b/templates/roll/roll-part-sort.hbs
@@ -4,7 +4,7 @@
 <roll-part-detail>
  <subline>TMR actuelle: {{caseTmr-label rollData.active.actor.system.reve.tmrpos.coord}} {{rollData.active.actor.system.reve.tmrpos.coord}}</subline>
  <subline>
-    <select name="select-sort" {{#if rollData.mode.retry}}disabled{{/if}}>
+    <select name="select-sort" {{#if rollData.type.retry}}disabled{{/if}}>
      {{selectOptions refs.sorts selected=current.key valueAttr="key" labelAttr="label"}}
    </select>
    {{#if current.isDiffVariable}}
@@ -13,7 +13,7 @@
        step=1
        min=-20
        max=-1
-        disabled=rollData.mode.retry
+        disabled=rollData.type.retry
    }}
    {{else}}
    <selected-numeric-value>{{plusMoins current.value}}</selected-numeric-value>
@@ -28,7 +28,7 @@
          step=1
          min=1
          max=30
-          disabled=rollData.mode.retry
+          disabled=rollData.type.retry
      }}
    {{/if}}
    <span>&nbsp;(actuel: {{rollData.active.actor.system.reve.reve.value}})</span>
@@ -37,7 +37,7 @@
    {{#if current.sort.system.isrituel}}
    <i class="fa-solid fa-book-sparkles"></i>&nbsp; Rituel
    {{else}}
-    <input type="checkbox" name="reserve" {{#if current.isReserve}}checked{{/if}} {{#if rollData.mode.retry}}disabled{{/if}}/>
+    <input type="checkbox" name="reserve" {{#if current.isReserve}}checked{{/if}} {{#if rollData.type.retry}}disabled{{/if}}/>
    <label for="reserve"><i class="fa-solid fa-sparkles"></i>&nbsp; Mettre en réserve</label>
    {{/if}}
  </subline>
--- a/templates/roll/roll-part-tache.hbs
+++ b/templates/roll/roll-part-tache.hbs
@@ -3,7 +3,7 @@
 </roll-part-img>
 <roll-part-detail>
  <subline>
-    <select name="select-tache" {{#if rollData.mode.retry}}disabled{{/if}}>
+    <select name="select-tache" {{#if rollData.type.retry}}disabled{{/if}}>
      {{selectOptions refs.taches selected=current.key valueAttr="key" labelAttr="label"}}
    </select>
    <selected-numeric-value>{{plusMoins current.value}}</selected-numeric-value>
--- a/templates/roll/roll-type.hbs
+++ b/templates/roll/roll-type.hbs
@@ -0,0 +1,5 @@
+{{#each types as |type|}}
+<button name="roll-type" data-tooltip="{{name}}" data-type="{{code}}" data-checked="{{selected}}">
+  <img src="{{icon}}">
+</button>
+{{/each}}