Nouveau roll-dialog: mode attaque

README.md

@@ -12,8 +12,8 @@ Pseudo : LeRatierBretonnien
 
 Mainteneur/Développeur : LeRatierBretonnien
 Développeur : VincentVk
-Tests, Compendiums, Données: Fred, Fab, Grendel
-Styles/CSS : Mandar
+Tests, Compendiums, Données: Fred, Fab, Grendel, LeRatierBretonnien, VincentVk
+Styles/CSS : Mandar, VincentVk
 
 # Mentions Légales
 
@@ -23,6 +23,6 @@ La carte des Terres Médianes du Rêve est une illustration de **Jidus**, utilis
 Les silhouettes des créatures, humanoïdes et entités sont des illustrations de **Roland Barthélémy**, et sont utilisés dans le cadre de ce projet avec son aimable autorisation.
 Merci à eux !!
 
-Toute la propriété intellectuelle leur appartient, ce système est une adpatation destinée à fonctionner sous FoundryVTT.
+Toute la propriété intellectuelle leur appartient, ce système est une adaptation destinée à fonctionner sous FoundryVTT.
 
 L'ensemble du code est sous licence Creative Commons.

changelog.md

@@ -1,5 +1,14 @@
 # 13.0
 
+## 13.0.9 - Le combat d'Illysis
+- Fix
+  - La montée en TMR fonctionne
+- Nouvelle fenêtre de jets de dés
+  - avancement du mode attaque
+    - choix de tactique
+    - choix des dommages, affichage
+    - affichage de la surprise du défenseur
+
 ## 13.0.8 - Le renouveau d'Illysis
 
 - Fix Foundry V13

css/foundryvtt-reve-de-dragon.css

@@ -526,6 +526,7 @@ select,
   grid-area: selection;
   display: flex;
   flex-direction: row;
+  margin: 0.1rem 0;
 }
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-choix roll-section roll-part-img {
   display: flex;
@@ -549,6 +550,7 @@ select,
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-choix roll-section roll-part-detail subline {
   display: flex;
   flex-direction: row;
+  margin: 0.1rem 0;
 }
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-choix roll-section roll-part-detail subline div.poesie-extrait {
   display: flex;
@@ -608,6 +610,11 @@ select,
   margin: 0 0.2rem;
   padding: 0;
 }
+.system-foundryvtt-reve-de-dragon .roll-dialog :is(roll-choix, roll-conditions, roll-carac, roll-comp) img.button-effect-img {
+  max-width: 1rem;
+  max-height: 1rem;
+  margin: 0 0.1rem;
+}
 .system-foundryvtt-reve-de-dragon .roll-dialog roll-carac select[name="select-carac"] {
   max-width: 6rem;
 }

less/roll-dialog.less

@@ -83,11 +83,14 @@
     gap: 0.2rem;
     align-items: start;
 
+    
     subline {
       grid-area: selection;
       display: flex;
       flex-direction: row;
+      margin: 0.1rem 0;
     }
+  
     roll-part-img {
       display: flex;
       flex-direction: column;
@@ -110,6 +113,7 @@
       subline {
         display: flex;
         flex-direction: row;
+        margin: 0.1rem 0;
         div.poesie-extrait{
           display: flex;
           flex-direction: column;
@@ -178,6 +182,11 @@
           margin: 0 0.2rem;
           padding: 0;
     }
+    img.button-effect-img {
+          max-width: 1rem;
+          max-height: 1rem;
+          margin: 0 0.1rem;
+    }
   }
 
   roll-carac select[name="select-carac"] {

module/actor-sheet.js

@@ -49,7 +49,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     });
     foundry.utils.mergeObject(formData.calc, {
       surenc: this.actor.computeMalusSurEncombrement(),
-      surprise: RdDBonus.find(this.actor.getSurprise(false)).descr,
+      surprise: RdDBonus.find(this.actor.getSurprise(false)).label,
       resumeBlessures: this.actor.computeResumeBlessure(this.actor.system.blessures),
       caracTotal: RdDCarac.computeTotal(this.actor.system.carac, this.actor.system.beaute),
       surEncombrementMessage: this.actor.isSurenc() ? "Sur-Encombrement!" : "",

module/actor-token.mjs

@@ -31,7 +31,7 @@ export class ActorToken {
 
   constructor(token) {
     this.name = token.name ?? token.actor.name
-    this.img = token.texture.src ?? token.actor.img
+    this.img = token.actor.isToken && token.texture.src ? token.texture.src : token.actor.img
     this.actor = token.actor
     this.id = token.actor?.id
     this.token = token

module/actor.js

@@ -170,60 +170,59 @@ export class RdDActor extends RdDBaseActorSang {
   /* -------------------------------------------- */
   /** Retourne une liste triée d'actions d'armes avec le split arme1 main / arme 2 main / lancer */
   listActionsAttaque() {
-    let actions = [
-      this.$prepareAttaqueArme(RdDItemArme.empoignade(this)),
-      this.$prepareAttaqueArme(RdDItemArme.corpsACorps(this)),
-    ]
+    const actions = []
+    const uniques = []
 
-    const armes = this.itemTypes[ITEM_TYPES.arme]
+    const addAttaque = (arme, main) => {
+      const dommages = arme.system.dommages.toString()
+      const tableauDommages = dommages.includes("/") ? dommages.split("/") : [dommages, dommages]
+      const dommagesArme = parseInt(main == '(2 mains)' ? tableauDommages[1] : tableauDommages[0])
+      const magieEfficacite = arme.system.magique ? arme.system.ecaille_efficacite : 0;
+
+      const comp = this.getCompetence(RdDActor.$getCompetenceAction(arme, main))
+      const unique = [comp.id, arme.name, dommagesArme, magieEfficacite].join('|');
+      if (uniques.includes(unique)) {
+        return
+      }
+      uniques.push(unique);
+
+      const caracCode = RdDActor.$getCaracAction(comp, main)
+      const caracValue = this.system.carac[caracCode].value
+
+      // TODO: déplacer sur RdDItemArme
+      if (arme.system.unemain && arme.system.deuxmains && !dommages.includes("/")) {
+        ui.notifications.info(`Les dommages de l'arme à 1/2 mains ${arme.name} ne sont pas corrects (ie sous la forme X/Y)`)
+      }
+      const niveau = comp?.system.niveau ?? (['(lancer)', '(tir)'].includes(main) ? -8 : -6)
+      const ajustement = (arme.parent?.getEtatGeneral() ?? 0) + magieEfficacite
+
+      actions.push({
+        name: arme.name + (main ? ' ' + main : ''),
+        action: 'attaque',
+        initOnly: false,
+        arme: arme,
+        comp: comp,
+        main: main,
+        carac: { key: caracCode, value: caracValue },
+        equipe: arme.system.equipe,
+        dommagesArme: dommagesArme,
+        initiative: RdDInitiative.calculInitiative(niveau, caracValue, ajustement)
+      })
+    }
+
+    addAttaque(RdDItemArme.empoignade(this))
+    addAttaque(RdDItemArme.corpsACorps(this))
+
+    this.itemTypes[ITEM_TYPES.arme]
       .filter(it => RdDItemArme.isAttaque(it))
-      .sort(Misc.ascending(it => it.name));
-
-    for (const arme of armes) {
-      if (arme.system.unemain && arme.system.competence) {
-        actions.push(this.$prepareAttaqueArme(arme, '(1 main)'))
-      }
-      if (arme.system.deuxmains && arme.system.competence) {
-        actions.push(this.$prepareAttaqueArme(arme, '(2 mains)'))
-      }
-      if (arme.system.lancer) {
-        actions.push(this.$prepareAttaqueArme(arme, '(lancer)'))
-      }
-      if (arme.system.tir) {
-        actions.push(this.$prepareAttaqueArme(arme, '(tir)'))
-      }
-    }
-    return actions;
-  }
-
-  /* -------------------------------------------- */
-  $prepareAttaqueArme(arme, main) {
-    const comp = this.getCompetence(RdDActor.$getCompetenceAction(arme, main))
-    const caracCode = RdDActor.$getCaracAction(comp, main)
-    const caracValue = this.system.carac[caracCode].value
-    const dommages = arme.system.dommages.toString()
-
-    // TODO: déplacer sur RdDItemArme
-    if (arme.system.unemain && arme.system.deuxmains && !dommages.includes("/")) {
-      ui.notifications.info(`Les dommages de l'arme à 1/2 mains ${arme.name} ne sont pas corrects (ie sous la forme X/Y)`)
-    }
-    const tableauDommages = dommages.includes("/") ? dommages.split("/") : [dommages, dommages]
-    const dmg = main == '(2 mains)' ? tableauDommages[1] : tableauDommages[0]
-    const niveau = comp?.system.niveau ?? (['(lancer)', '(tir)'].includes(main) ? -8 : -6)
-    const ajustement = (arme.parent?.getEtatGeneral() ?? 0) + (arme.system.magique) ? arme.system.ecaille_efficacite : 0
-
-    return {
-      name: arme.name + (main ? ' ' + main : ''),
-      action: 'attaque',
-      initOnly: false,
-      arme: arme,
-      comp: comp,
-      main: main,
-      carac: { key: caracCode, value: caracValue },
-      equipe: arme.system.equipe,
-      dmg: dmg,
-      initiative: RdDInitiative.calculInitiative(niveau, caracValue, ajustement)
-    }
+      .sort(Misc.ascending(it => it.name))
+      .forEach(arme => {
+        if (arme.system.unemain && arme.system.competence) { addAttaque(arme, '(1 main)') }
+        if (arme.system.deuxmains && arme.system.competence) { addAttaque(arme, '(2 mains)') }
+        if (arme.system.lancer) { addAttaque(arme, '(lancer)') }
+        if (arme.system.tir) { addAttaque(arme, '(tir)') }
+      })
+    return actions
   }
 
   static $getCaracAction(comp, main) {
@@ -3249,3 +3248,4 @@ export class RdDActor extends RdDBaseActorSang {
   }
 }
 
+

module/item-competencecreature.js

@@ -54,34 +54,37 @@ export class RdDItemCompetenceCreature extends Item {
     const categorieAttaque = RdDItemCompetenceCreature.getCategorieAttaque(comp)
     if (categorieAttaque != undefined) {
       const initative = RdDInitiative.calculInitiative(comp.system.niveau, comp.system.carac_value);
-      return {
+      const armeComp = new RdDItem({
+        name: comp.name,
+        type: ITEM_TYPES.arme,
+        img: comp.img,
+        system: {
+          competence: comp.name,
+          cac: categorieAttaque == "naturelle" ? "naturelle" : "",
+          niveau: comp.system.niveau,
+          initiative: initative,
+          mortalite: comp.system.mortalite,
+          dommages: comp.system.dommages,
+          equipe: true,
+          resistance: 100,
+          penetration: 0,
+          force: 0,
+          rapide: true,
+        }
+      });
+      const attaque = {
         name: comp.name,
         action: comp.isCompetencePossession() ? 'possession' : 'attaque',
         initOnly: false,
-        arme: new RdDItem({
-          name: comp.name,
-          type: ITEM_TYPES.arme,
-          img: comp.img,
-          system: {
-            competence: comp.name,
-            cac: categorieAttaque == "naturelle" ? "naturelle" : "",
-            niveau: comp.system.niveau,
-            initiative: initative,
-            equipe: true,
-            resistance: 100,
-            dommagesReels: comp.system.dommages,
-            penetration: 0,
-            force: 0,
-            rapide: true,
-          }
-        }),
+        arme: armeComp,
         comp: comp,
-        // main: '',
         carac: { key: comp.name, value: comp.system.carac_value },
         equipe: true,
+        mortalite: comp.system.mortalite,
         dmg: comp.system.dommages,
         initiative: initative
-      }
+      };
+      return attaque
     }
     return undefined;
   }

module/item/arme.js

@@ -30,6 +30,10 @@ export class RdDItemArme extends RdDItem {
     //return "systems/foundryvtt-reve-de-dragon/icons/armes_armure/epee_sord.webp";
   }
 
+  penetration() {
+    return parseInt(this.system.penetration ?? 0);
+  }
+
   /* -------------------------------------------- */
 
   static getArme(arme) {

module/rdd-bonus.js

@@ -1,21 +1,23 @@
-import { RdDCarac } from "./rdd-carac.js";
 import { RdDPossession } from "./rdd-possession.js";
 
 const conditionsTactiques = [
-  { type: '', descr: '', dmg: 0, attaque: 0, parade: 0, esquive: true },
-  { type: 'charge', descr: 'Charge', dmg: 2, attaque: 4, parade: -4, esquive: false },
-  { type: 'feinte', descr: 'Feinte', dmg: 1, attaque: 1, parade: 0, esquive: true },
-  { type: 'pret', descr: 'prêt', dmg: 0, attaque: 0, parade: 0, esquive: true },
-  { type: 'demi', descr: 'Demi-surprise', dmg: 1, attaque: 0, parade: 0, esquive: true },
-  { type: 'totale', descr: 'Surprise totale', dmg: 10, attaque: 6, parade: 0, esquive: true },
+  { key: '', label: '', dmg: 0, attaque: 0, parade: 0, esquive: true, isTactique: false },
+  { key: 'normale', label: 'Attaque normale', dmg: 0, attaque: 0, parade: 0, esquive: true, isTactique: true },
+  { key: 'charge', label: 'Charge', dmg: 2, attaque: 4, parade: -4, esquive: false, isTactique: true },
+  { key: 'feinte', label: 'Feinte', dmg: 1, attaque: 1, parade: 0, esquive: true, isTactique: true },
+  { key: 'pret', label: 'prêt', dmg: 0, attaque: 0, parade: 0, esquive: true, isTactique: false },
+  { key: 'demi', label: 'Demi-surprise', dmg: 1, attaque: 0, parade: 0, esquive: true, isTactique: false },
+  { key: 'totale', label: 'Surprise totale', dmg: 10, attaque: 6, parade: 0, esquive: true, isTactique: false },
 ];
 
 /* -------------------------------------------- */
 export class RdDBonus {
-
+  static get tactiques(){
+    return conditionsTactiques.filter(it => it.isTactique)
+  }
   /* -------------------------------------------- */
   static find(condition) {
-    return conditionsTactiques.find(e => e.type == condition) || conditionsTactiques.find(e => e.type == 'pret');
+    return conditionsTactiques.find(e => e.key == condition) || conditionsTactiques[0];
   }
 
 
@@ -32,7 +34,7 @@ export class RdDBonus {
 
   /* -------------------------------------------- */
   static dmg(rollData, actor, isEntiteIncarnee = false) {
-    const dmgArme = RdDBonus.dmgArme(rollData.arme)
+    const dmgArme = RdDBonus.dmgArme(rollData.arme, rollData.arme?.system.dommagesReels)
     let dmg = {
       total: 0,
       dmgArme: dmgArme,
@@ -49,31 +51,35 @@ export class RdDBonus {
 
   /* -------------------------------------------- */
   static description(condition) {
-    return RdDBonus.find(condition).descr;
+    return RdDBonus.find(condition).label
   }
 
   /* -------------------------------------------- */
   static dmgBonus(condition) {
-    return RdDBonus.find(condition).dmg;
+    return RdDBonus.find(condition).dmg
   }
 
   /* -------------------------------------------- */
   static bonusAttaque(condition) {
-    return RdDBonus.find(condition).attaque;
+    return RdDBonus.find(condition).attaque
   }
 
   /* -------------------------------------------- */
   static _calculMortalite(rollData, isEntiteIncarnee) {
+    return RdDBonus.mortalite(rollData.dmg?.mortalite, rollData.arme?.system.mortalite, isEntiteIncarnee)
+  }
+
+  static mortalite(mortaliteSelect, mortaliteArme, isEntiteIncarnee) {
     return isEntiteIncarnee ? "entiteincarnee"
-      : rollData.dmg?.mortalite
-      ?? rollData.arme?.system.mortalite
+      : mortaliteSelect
+      ?? mortaliteArme
       ?? "mortel";
   }
 
   /* -------------------------------------------- */
-  static dmgArme(arme) {
+  static dmgArme(arme, dommagesMain) {
     if (arme) {
-      let dmgBase = arme.system.dommagesReels ?? Number(arme.system.dommages ?? 0);
+      let dmgBase = dommagesMain ?? Number(arme.system.dommages ?? 0);
       //Le bonus dégats magiques ne peut pas faire dépasser le bonus de l'arme (cf p.278)
       return dmgBase + Math.min(dmgBase, arme.system.magique ? arme.system.ecaille_efficacite : 0);
     }
@@ -92,8 +98,8 @@ export class RdDBonus {
       return 0
     }
     switch (categorie) {
-      case "tir": return 0;
-      case "lancer": return Math.max(0, Math.min(dmgArme, dmgActor));
+      case "(tir)": case "tir": return 0
+      case "(lancer)": case "lancer": return Math.max(0, Math.min(dmgArme, dmgActor));
     }
     return dmgActor;
   }

module/roll/roll-dialog.mjs

@@ -187,7 +187,12 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
     foundry.applications.handlebars.loadTemplates(ROLL_PARTS.map(p => p.template))
     ROLL_PARTS.forEach(p => p.onReady())
 
-    Handlebars.registerHelper('roll-centered-array', (base, show) => RollDialog.centeredArray(base, show))
+    Handlebars.registerHelper('roll-centered-array', (base, show) => {
+      show = Math.abs(show)
+      const start = base - show
+      return [...Array(2 * show + 1).keys()].map(it => start + it)
+    })
+
     Handlebars.registerHelper('roll-list-item-value', (list, key, path = undefined) => {
       const selected = list.find(p => p.key == key)
       if (selected && path && path != '') {
@@ -195,6 +200,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
       }
       return selected
     })
+
     Handlebars.registerHelper('roll-part-context', (rollData, code) => {
       const rollPart = ROLL_PARTS.find(it => it.code == code)
       if (rollPart == undefined) {
@@ -211,12 +217,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
     })
   }
 
-  static centeredArray(base, show) {
-    show = Math.abs(show)
-    const start = base - show
-    return [...Array(2 * show + 1).keys()].map(it => start + it)
-  }
-
+  
   static async create(rollData, rollOptions = {}) {
     const rollDialog = new RollDialog(rollData, rollOptions)
     rollDialog.render(true)
@@ -267,30 +268,33 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
   /** pre-configure les paramètres des différentes parties de la fenêtre (par exemple, prépare les listes de caractéristiques/compétences */
   $loadParts() {
     const rollData = this.rollData;
-    const loadedMode = rollData.mode?.current
     rollData.current = rollData.current ?? {}
     rollData.selected = rollData.selected ?? {}
     rollData.mode = rollData.mode ?? {}
     rollData.mode.retry = rollData.mode.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)
+
     rollData.mode.allowed = rollData.mode.retry ? [loadedMode] : rollData.mode.allowed ?? ROLL_MODE_TABS.map(m => m.code)
-    rollData.mode.current = loadedMode ?? ROLL_MODE_TABS.find(m => m.isAllowed(rollData) && m.visible(rollData))?.code ?? ROLL_MODE_COMP
+    rollData.mode.current = allowedModes.find(m => m == rollData.mode?.current) ?? (allowedModes.length > 0 ? allowedModes[0] : ROLL_MODE_COMP)
+
     this.getSelectedMode().setRollDataMode(rollData)
-    
+
     rollData.refs = this.$prepareRefs(rollData)
     rollData.options = rollData.options ?? { showDice: true, rollMode: game.settings.get("core", "rollMode") }
-    
+
     ROLL_PARTS.forEach(p => p.initialize(rollData))
     ROLL_PARTS.forEach(p => p.restore(rollData))
     ROLL_PARTS.filter(p => p.isValid(rollData))
-    .forEach(p => {
-      p.loadRefs(rollData)
-      p.prepareContext(rollData)
-    })
+      .forEach(p => {
+        p.loadRefs(rollData)
+        p.prepareContext(rollData)
+      })
     this.selectMode();
   }
-  
+
   selectMode() {
     this.rollData.mode.label = this.getSelectedMode().title(this.rollData)
     this.getSelectedMode().setRollDataMode(this.rollData)

module/roll/roll-part-appelmoral.mjs

@@ -37,6 +37,7 @@ export class RollPartAppelMoral extends RollPartCheckbox {
     }
     return '<i class="fa-regular fa-face-meh"></i>'
   }
+
   getCheckboxLabel(rollData) { return "Appel au moral" }
   getCheckboxValue(rollData) { return 1 }
 }

module/roll/roll-part-attaque.mjs

@@ -1,12 +1,16 @@
 import { Grammar } from "../grammar.js"
+import { RdDBonus } from "../rdd-bonus.js"
+import { StatusEffects } from "../settings/status-effects.js"
 import { ROLL_MODE_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"
-import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
+import { ROLLDIALOG_SECTION } from "./roll-part.mjs"
 
 export const PART_ATTAQUE = 'attaque'
 
+const TACTIQUES = RdDBonus.tactiques.filter(it => it.isTactique)
+
 export class RollPartAttaque extends RollPartSelect {
 
   get code() { return PART_ATTAQUE }
@@ -18,7 +22,8 @@ export class RollPartAttaque extends RollPartSelect {
     const refs = this.getRefs(rollData)
     const attaques = rollData.active.actor.listAttaques()
     refs.attaques = attaques.map(it => RollPartAttaque.$extractAttaque(it, rollData.active.actor))
-    if (refs.attaques.length>0){
+    refs.tactiques = TACTIQUES
+    if (refs.attaques.length > 0) {
       this.$selectAttaque(rollData)
     }
   }
@@ -27,20 +32,69 @@ export class RollPartAttaque extends RollPartSelect {
 
   static $extractAttaque(action, actor) {
     return {
-      key: `${action.action}::${action.arme.id}::${action.comp.id}`,
+      key: `${action.action}::${action.name}`,
       label: action.name,
       action: action,
+      tactique: TACTIQUES[0],
       arme: action.arme,
       comp: action.comp,
     }
   }
 
+  prepareContext(rollData) {
+    const current = this.getCurrent(rollData)
+    const effetsSurprise = rollData.opponent?.actor?.getEffects(it => StatusEffects.niveauSurprise(it, true) > 0) ?? []
+    current.defenseur = effetsSurprise.length > 0
+      ? {
+        surprise: RdDBonus.find(rollData.opponent?.actor?.getSurprise(true)),
+        effects: effetsSurprise
+      }
+      : undefined
+    current.dmg = this.dmgRollV2(rollData, current)
+  }
+
+  getAjustements(rollData) {
+    const current = this.getCurrent(rollData)
+    const tactique = current.tactique
+    const surprise = current.defenseur?.surprise
+    const ajustements = []
+    if (tactique) {
+      ajustements.push({ label: tactique.label, diff: tactique.attaque })
+    }
+    if (surprise) {
+      ajustements.push({ label: surprise.label, diff: surprise.attaque })
+    }
+    return ajustements
+  }
+
+
+  dmgRollV2(rollData, current) {
+    const actor = rollData.active.actor
+    const defender = rollData.opponent.actor
+    const dmgArme = RdDBonus.dmgArme(current.arme, current.action.dommagesArme)
+    const dmg = {
+      total: 0,
+      dmgArme: dmgArme,
+      penetration: current.arme.penetration(),
+      dmgTactique: current.tactique?.dmg ?? 0,
+      dmgParticuliere: 0, // TODO RdDBonus._dmgParticuliere(rollData),
+      dmgSurprise: current.defenseur?.surprise.dmg ?? 0,
+      mortalite: RdDBonus.mortalite(current.dmg?.mortalite, current.arme.system.mortalite, defender?.isEntite()),
+      dmgActor: RdDBonus.bonusDmg(actor, current.action.carac.key, dmgArme)
+    }
+    dmg.total = dmg.dmgSurprise + dmg.dmgTactique + dmg.dmgArme + dmg.dmgActor + dmg.dmgParticuliere
+    return dmg;
+  }
+
   $selectAttaque(rollData, key) {
     this.selectByKey(rollData, key, 0)
   }
 
   async _onRender(rollDialog, context, options) {
     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 current = this.getCurrent(rollDialog.rollData)
 
     selectAttaque.addEventListener("change", e => {
       const selectOptions = e.currentTarget.options
@@ -49,6 +103,18 @@ export class RollPartAttaque extends RollPartSelect {
       rollDialog.setModeTitle()
       rollDialog.render()
     })
+
+    selectTactique.addEventListener("change", e => {
+      const selectOptions = e.currentTarget.options
+      const index = selectOptions.selectedIndex
+      current.tactique = RdDBonus.find(selectOptions[index]?.value)
+      rollDialog.render()
+    })
+
+    checkMortalite?.addEventListener("change", e => {
+      current.dmg.mortalite = (e.currentTarget.checked ? 'mortel' : 'non-mortel')
+      rollDialog.render()
+    })
   }
 
   getExternalPartsFilter(partCode, rollData) {

module/roll/roll-part-checkbox.mjs

@@ -18,8 +18,8 @@ export class RollPartCheckbox extends RollPart {
   }
 
   loadRefs(rollData) {
-    const current = this.getCurrent(rollData)
-    current.label = this.getCheckboxLabel(rollData)
+    const refs = this.getRefs(rollData)
+    refs.label = this.getCheckboxLabel(rollData)
   }
 
   prepareContext(rollData) {
@@ -43,7 +43,7 @@ export class RollPartCheckbox extends RollPart {
   }
 
   getCheckboxLabelAjustement(rollData) {
-    return `${this.getCheckboxIcon(rollData)} ${this.getCurrent(rollData).label}`
+    return `${this.getCheckboxIcon(rollData)} ${this.getRefs(rollData).label}`
   }
 
   async _onRender(rollDialog, context, options) {

module/roll/roll-part-defense.mjs

@@ -14,4 +14,8 @@ export class RollPartDefense extends RollPart {
     refs.defenses =[]
   }
 
+  isForceInsuffisante(rollData) {
+    return true
+  }
+
 }

module/roll/roll-part-oeuvre.mjs

@@ -43,15 +43,15 @@ export class RollPartOeuvre extends RollPartSelect {
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)
     refs.oeuvres = rollData.active.actor.items
-    .filter(it => it.isOeuvre() && RollPartOeuvre.getArt(it))
-    .map(it => RollPartOeuvre.$extractOeuvre(it, rollData.active.actor))
+      .filter(it => it.isOeuvre() && RollPartOeuvre.getArt(it))
+      .map(it => RollPartOeuvre.$extractOeuvre(it, rollData.active.actor))
     if (refs.oeuvres.length > 0) {
       this.$selectOeuvre(rollData)
     }
   }
-  
+
   choices(refs) { return refs.oeuvres }
-  
+
   static $extractOeuvre(oeuvre, actor) {
     const art = RollPartOeuvre.getArt(oeuvre)
     return {
@@ -64,7 +64,7 @@ export class RollPartOeuvre extends RollPartSelect {
       comp: actor.getCompetence(art.competence(oeuvre))
     }
   }
-  
+
   static getArt(oeuvre) {
     return ARTS.find(it => it.type == oeuvre.type)
   }

module/roll/roll-part-select.mjs

@@ -27,7 +27,7 @@ export class RollPartSelect extends RollPart {
     const current = this.getCurrent(rollData)
     const newChoice = (choices.length == 0)
       ? { key: '', value: defValue }
-      : this.$getSelectedChoice(choices, key ?? current?.key ?? refs.key ?? '')
+      : this.$getSelectedChoice(choices, key ?? current?.key ?? refs?.key ?? '')
     this.setCurrent(rollData, newChoice)
     return newChoice
   }

module/roll/roll-part-sign.mjs

@@ -1,6 +1,7 @@
 import { Misc } from "../misc.js"
 import { StatusEffects } from "../settings/status-effects.js"
 import { ROLL_MODE_ATTAQUE, ROLL_MODE_DEFENSE } from "./roll-constants.mjs"
+import { PART_ATTAQUE, RollPartAttaque } from "./roll-part-attaque.mjs"
 import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
 
 export const PART_SIGN = "sign"
@@ -64,8 +65,17 @@ export class RollPartSign extends RollPart {
   }
 
   isForceInsuffisante(rollData) {
-    //this.isCombat(rollData) && ... arme avec force min
-    return this.isCombat(rollData) && true
+    if ([ROLL_MODE_ATTAQUE, ROLL_MODE_DEFENSE].includes(rollData.mode.current)) {
+      const arme = rollData.current[rollData.mode.current]?.arme
+      const actor = rollData.active.actor
+
+      if (actor?.isPersonnage() && arme) {
+        const requise = parseInt(arme?.system.force ?? 0)
+        const force = parseInt(actor.system.carac.force.value)
+        return requise > force
+      }
+    }
+    return false
   }
 
   isAttaqueFinesse(rollData) {

module/rolldata-ajustements.js

@@ -121,7 +121,7 @@ export const referenceAjustements = {
   },
   tactique: {
     isUsed: (rollData, actor) => rollData.tactique,
-    getLabel: (rollData, actor) => RdDBonus.find(rollData.tactique).descr,
+    getLabel: (rollData, actor) => RdDBonus.find(rollData.tactique).label,
     getValue: (rollData, actor) => RdDBonus.find(rollData.tactique).attaque,
   },
   finesse: {
@@ -130,11 +130,11 @@ export const referenceAjustements = {
   },
   surprise: {
     isUsed: (rollData, actor) => actor.getSurprise(rollData.passeArme),
-    getDescr: (rollData, actor) => RdDBonus.find(actor.getSurprise()).descr
+    getDescr: (rollData, actor) => RdDBonus.find(actor.getSurprise()).label
   },
   attaqueDefenseurSurpris: {
     isUsed: (rollData, actor) => rollData.surpriseDefenseur,
-    getLabel: (rollData, actor) => RdDBonus.find(rollData.surpriseDefenseur).descr + (rollData.attackerRoll ? '' : ' défenseur'),
+    getLabel: (rollData, actor) => RdDBonus.find(rollData.surpriseDefenseur).label + (rollData.attackerRoll ? '' : ' défenseur'),
     getValue: (rollData, actor) => RdDBonus.find(rollData.surpriseDefenseur).attaque,
   },
   armeParade: {

module/settings/status-effects.js

@@ -108,7 +108,7 @@ export class StatusEffects extends FormApplication {
   }
 
   static prepareActiveEffect(effectId) {
-    const status = rddStatusEffects.find(it => it.id == effectId)
+    let status = rddStatusEffects.find(it => it.id == effectId)
     if (status) {
       status = foundry.utils.duplicate(status)
       status.statuses = new Set([effectId])

templates/actor/header-effects.hbs

@@ -1,6 +1,6 @@
 <div>
   {{#if effects}}
-    {{#each effects as |effect key|}}
+    {{#each effects as |effect|}}
     <span class="active-effect" data-effect="{{effect.id}}">
       <img class="button-effect-img {{#if @root.options.isGM}}delete-active-effect{{/if}}" src="{{effect.img}}" data-tooltip="{{localize effect.name}}" width="24" height="24" />
     </span>

templates/chat-infojet.hbs

@@ -2,13 +2,13 @@
   <span {{#if ajustements}}class="tooltip-overflow tooltip-dotted" {{/if}}>
     <span>
       <span>{{rolled.caracValue}} à {{plusMoins rolled.finalLevel}}</span>
-      {{#if ajustements}}
-      {{/if}}
-      {{log this}}
-      {{#if rolled.factorHtml}}<span class="rdd-diviseur">&times;{{{rolled.factorHtml}}}</span>{{/if}}
+      {{log rolled}}
+      {{#if (and rolled.factorHtml (gt rolled.factorHtml 1))}}
+        <span class="rdd-diviseur">&times;{{{rolled.factorHtml}}}</span>
+        <span>= {{rolled.score}}%</span>
+        <span class="rdd-diviseur">&times;{{{rolled.factorHtml}}}</span>
+      {{else}}
       <span>= {{rolled.score}}%</span>
-      {{#if rolled.factorHtml}}
-      <span class="rdd-diviseur">&times;{{{rolled.factorHtml}}}</span>
       {{/if}}
     </span>
     <div class="tooltiptext ttt-ajustements">

templates/roll/roll-part-attaque.hbs

@@ -1,14 +1,45 @@
-{{log 'roll-part-attaque.current' current}}
-{{log 'roll-part-attaque.refs' refs}}
+{{!-- {{log 'roll-part-attaque.current' current}}
+{{log 'roll-part-attaque.refs' refs}} --}}
+<subline>
+  <select name="select-attaque" {{#if rollData.mode.retry}}disabled{{/if}}>
+    {{selectOptions refs.attaques selected=current.key valueAttr="key" labelAttr="label"}}
+  </select>
+</subline>
 <roll-part-img>
-  {{#if current.attaque}}
-  <img src="{{current.attaque.arme.img}}" data-tooltip="{{current.attaque.arme.name}}" />
+  {{#if current.arme}}
+  <img src="{{current.arme.img}}" data-tooltip="{{current.arme.name}}" />
   {{/if}}
 </roll-part-img>
 <roll-part-detail>
   <subline>
-    <select name="select-attaque" {{#if rollData.mode.retry}}disabled{{/if}}>
-      {{selectOptions refs.attaques selected=current.key valueAttr="key" labelAttr="label"}}
+    <label for="select-tactique">Tactique:</label>
+    <select name="select-tactique" {{#if rollData.mode.retry}}disabled{{/if}}>
+      {{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}}
+      <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>
+  {{#if current.defenseur.surprise}}
+  <subline>
+      Defenseur en {{lowerFirst current.defenseur.surprise.label}}
+      {{#each current.defenseur.effects as  |effect|}}
+        <img class="button-effect-img" src="{{effect.img}}" data-tooltip="{{localize effect.name}}" data-effect="{{effect.id}}"/>
+        {{localize effect.name}}
+      {{/each}}
+  </subline>
+  {{/if}}
+  <subline>
+
+  </subline>
 </roll-part-detail>

templates/roll/roll-part-checkbox.hbs

@@ -1,3 +1,3 @@
 <input name="{{code}}" type="checkbox" {{#if current.checked}}checked{{/if}}/>
 {{#if current.icon}}{{{current.icon}}}{{/if}}
-<label for="{{code}}">{{current.label}} : {{plusMoins current.value}}</label>
+<label for="{{code}}">{{either current.label refs.label}} : {{plusMoins current.value}}</label>