v2.5.0 : cumul systematique des bonus phys+mag, armure unifiee

Regle (demande Perco) : on lance les des puis on ajoute TOUJOURS les
deux bonus (physique = equipement, magique = potions/parchemins +
equipement magique), comme l'esquive le faisait deja. effTroll :
colonnes phys/mag rendues PURES (potion = magique, comptee une seule
fois) -> xxxFlat = phys + mag = total ajoute au jet. resolveAttack
additionne les deux (pickFlat supprime) ; opts.magic ne sert plus qu'a
choisir l'armure reductrice. Affichage : +total (phy +X . mag +Y)
coherent (fini le faux double comptage). Armure presentee comme
l'attaque : une seule ligne via fmtArmorLine au lieu de phy./mag.
separees. Tests smoke mis a jour vers le nouveau modele.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

README.md

@@ -234,6 +234,18 @@ non affilié au jeu original de Mountyhall SARL.
 
 ## Versions
 
+- **2.5.0** (2026-06-13) — **Cumul systématique des bonus physiques et
+  magiques.** On lance les dés, puis on ajoute **toujours les deux** bonus :
+  le physique (équipement) *et* le magique (potions/parchemins + équipement
+  magique) s'additionnent, comme le faisait déjà l'esquive (avant, l'attaque
+  et les dégâts ne prenaient qu'une seule saveur selon le type d'attaque). Les
+  colonnes phys/mag sont désormais **pures et sans recouvrement** (une potion
+  est un bonus magique, comptée une seule fois), donc l'affichage `+total
+  (phy +X · mag +Y)` est cohérent — fini le faux double comptage. `opts.magic`
+  ne sert plus qu'à choisir l'armure qui réduit (la magique seule pour une
+  attaque magique). **Armure** présentée comme l'attaque et l'esquive : une
+  seule ligne `XD3 +total (phy +P · mag +M)` au lieu des deux lignes « phy. »
+  et « mag. » séparées.
 - **2.4.4** (2026-06-13) — Affichage des bonus fixes clarifié : quand le bonus
   physique et le bonus magique sont **identiques**, on n'affiche plus qu'un
   seul `+X` (avant : `+1 (phy +1 · mag +1)`, qui donnait l'illusion d'un triple

js/game.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-const APP_VERSION = "2.4.4";
+const APP_VERSION = "2.5.0";
 
 /* Alpha : maîtrise initiale haute pour les tests. Remettre 15 % / 15 % à la v1.0 officielle. */
 const START_COMP_PCT = 90;
@@ -35,18 +35,15 @@ function rollDice(n, faces) {
  * Armure façon MH : les dégâts PHYSIQUES sont réduits par l'armure totale
  * (physique + magique) ; les dégâts MAGIQUES (opts.magic) par la seule armure
  * magique ; opts.ignoreArmor ignore tout (Siphon des Âmes).
- * ATT et DEG existent en deux saveurs comme l'armure : les bonus fixes
+ * Bonus fixes : on lance les dés, puis on ajoute TOUJOURS les deux saveurs —
- * physiques (xxxFlatPhys) s'appliquent aux attaques physiques, les magiques
+ * le bonus physique ET le bonus magique se cumulent (xxxFlat = phys + mag,
- * (xxxFlatMag) aux attaques magiques — à défaut on retombe sur xxxFlat. */
+ * cf. effTroll). opts.magic ne sert plus qu'à choisir l'armure qui réduit les
-function pickFlat(src, key, magic) {
+ * dégâts (magique seule pour une attaque magique). Les monstres n'ont pas de
-  const v = magic ? src[`${key}FlatMag`] : src[`${key}FlatPhys`];
+ * flats (que des dés) → xxxFlat absent → 0. */
-  return (v != null ? v : src[`${key}Flat`]) || 0;
-}
-
 function resolveAttack(attacker, defender, opts = {}) {
   const att = rollDice(attacker.att, 6);
   const esq = rollDice(defender.esq, 6);
-  const attFlat = pickFlat(attacker, "att", opts.magic);
+  const attFlat = attacker.attFlat || 0;
   const esqFlat = defender.esqFlat || 0;
   const attTotal = att.total + attFlat;
   const esqTotal = esq.total + esqFlat;
@@ -59,7 +56,7 @@ function resolveAttack(attacker, defender, opts = {}) {
   };
   if (result.hit) {
     const deg = rollDice(attacker.deg, 3);
-    const degFlat = pickFlat(attacker, "deg", opts.magic);
+    const degFlat = attacker.degFlat || 0;
     result.rawDamage = (deg.total + (attacker.degBonus || 0) + degFlat) * (result.critical ? 2 : 1);
     // armure physique : fixe (base + équipement) + naturelle en D3 (achetée en PI)
     // armure magique : effets de potions/parchemins (armorMag, peut être négative)
@@ -1380,8 +1377,7 @@ function renderPanels() {
     <div><span>Esquive</span><span class="stat-val">${fmtStatLine(t.esq, te.esq, 6, te.esqFlat, 0, { phys: te.esqFlatPhys, mag: te.esqFlatMag })}</span></div>
     <div><span>Dégâts</span><span class="stat-val">${fmtStatLine(t.deg, te.deg, 3, te.degFlat, te.degBonus, { phys: te.degFlatPhys, mag: te.degFlatMag })}</span></div>
     <div><span>Régénération</span><span class="stat-val">${fmtStatLine(t.reg, te.reg, 3, te.regFlat, 0, { phys: te.regFlatPhys, mag: te.regFlatMag })}</span></div>
-    <div><span>Armure phy.</span><span class="stat-val">${te.armorPhys}${t.armorDice ? "+" + t.armorDice + "D3" : ""}</span></div>
+    <div><span>Armure</span><span class="stat-val">${fmtArmorLine(t.armorDice, te.armorPhys, te.armorMag)}</span></div>
-    <div><span>Armure mag.</span><span class="stat-val">${te.armorMag > 0 ? "+" : ""}${te.armorMag}</span></div>
     <div><span>Vue</span><span class="stat-val">${te.vue}</span></div>
     <div><span>${RACES[t.race].comp.name}</span><span class="stat-val">${t.comp.pct} %</span></div>
     <div><span>${RACES[t.race].sort.name}</span><span class="stat-val">${t.sort.pct} %</span></div>

js/mp-client.js

@@ -269,8 +269,7 @@ function mpRenderPanels(st) {
     <div><span>Esquive</span><span class="stat-val">${fmtStatLine(you.esq, e.esq, 6, e.esqFlat, 0, { phys: e.esqFlatPhys, mag: e.esqFlatMag })}</span></div>
     <div><span>Dégâts</span><span class="stat-val">${fmtStatLine(you.deg, e.deg, 3, e.degFlat, e.degBonus, { phys: e.degFlatPhys, mag: e.degFlatMag })}</span></div>
     <div><span>Régénération</span><span class="stat-val">${fmtStatLine(you.reg, e.reg, 3, e.regFlat, 0, { phys: e.regFlatPhys, mag: e.regFlatMag })}</span></div>
-    <div><span>Armure phy.</span><span class="stat-val">${e.armorPhys}${you.armorDice ? "+" + you.armorDice + "D3" : ""}</span></div>
+    <div><span>Armure</span><span class="stat-val">${fmtArmorLine(you.armorDice, e.armorPhys, e.armorMag)}</span></div>
-    <div><span>Armure mag.</span><span class="stat-val">${e.armorMag > 0 ? "+" : ""}${e.armorMag}</span></div>
     <div><span>Vue</span><span class="stat-val">${e.vue}</span></div>
     <div><span>${RACES[you.race].comp.name}</span><span class="stat-val">${you.comp.pct} %</span></div>
     <div><span>${RACES[you.race].sort.name}</span><span class="stat-val">${you.sort.pct} %</span></div>

js/potions.js

@@ -408,49 +408,66 @@ function fmtStatLine(base, eff, faces, flat = 0, extra = 0, split = null) {
   const f = v => `${v > 0 ? "+" : ""}${v}`;
   let main = `${eff}D${faces}`;
   const hints = [];
-  // `extra` (degBonus) s'applique quel que soit le type d'attaque ; il s'ajoute
+  // Bonus fixe total ajouté au jet = bonus physique + bonus magique (les deux se
-  // donc aux deux saveurs. On ne détaille « phy/mag » QUE si les deux diffèrent
+  // cumulent toujours), + `extra` (degBonus, neutre). On affiche ce total puis,
-  // réellement — sinon un seul « +X » suffit (un bonus identique des deux côtés
+  // dès qu'il y a un bonus, le détail « phy/mag ». Les colonnes étant pures
-  // affiché en double laisse croire à tort à un cumul).
+  // (cf. effTroll), phys + mag = flat : le total et le détail sont cohérents.
-  if (split && split.phys !== split.mag) {
+  const fb = v => `${v >= 0 ? "+" : ""}${v}`; // détail phys/mag : toujours signé (+0 inclus)
-    // bonus fixe différent selon le type d'attaque → on détaille les deux
+  const phys = split ? (split.phys || 0) : 0;
-    hints.push(`phy ${f((split.phys || 0) + (extra || 0))} · mag ${f((split.mag || 0) + (extra || 0))}`);
+  const mag = split ? (split.mag || 0) : 0;
-  } else {
+  const total = (flat || 0) + (extra || 0);
-    // bonus identique quelle que soit la saveur → une seule valeur
+  if (total) main += ` ${f(total)}`;
-    const jetBonus = (flat || 0) + (extra || 0);
+  if (phys || mag) hints.push(`phy ${fb(phys)} · mag ${fb(mag)}`);
-    if (jetBonus) main += ` ${f(jetBonus)}`;
-  }
   if (diceDelta !== 0) hints.push(`${base}D${faces} ${diceDelta > 0 ? "+" : ""}${diceDelta}`);
   if (hints.length) return `${main} <small class="stat-hint">(${hints.join(" · ")})</small>`;
   return main;
 }
 
+/* Ligne d'armure présentée comme l'attaque/l'esquive (demande Perco) : les dés
+ * d'armure naturelle (XD3 achetés en PI) puis le bonus fixe total (physique +
+ * magique) et son détail « phy/mag ». */
+function fmtArmorLine(armorDice, phys = 0, mag = 0) {
+  const f = v => `${v > 0 ? "+" : ""}${v}`;
+  const fb = v => `${v >= 0 ? "+" : ""}${v}`;
+  const flat = (phys || 0) + (mag || 0);
+  const parts = [];
+  if (armorDice) parts.push(`${armorDice}D3`);
+  if (flat || !parts.length) parts.push(parts.length ? f(flat) : `${flat}`);
+  let main = parts.join(" ");
+  if (phys || mag) main += ` <small class="stat-hint">(phy ${fb(phys)} · mag ${fb(mag)})</small>`;
+  return main;
+}
+
 /* Caractéristiques effectives : base + effets magiques (potions, parchemins)
  * + équipement (troll.gearMods, recalculé par game.js à chaque équipement).
  * Les bonus ATT/ESQ/DEG/REG de l'équipement sont des bonus FIXES sur les jets,
  * jamais des dés supplémentaires.
- * Comme l'armure, ATT et DEG existent en deux saveurs : xxxFlatPhys s'applique
+ * RÈGLE (demande Perco) : on lance les dés, puis on ajoute TOUJOURS les deux
- * aux attaques PHYSIQUES, xxxFlatMag aux attaques MAGIQUES (sortilèges). Les
+ * bonus — le physique ET le magique se cumulent. Les colonnes sont donc
- * potions/parchemins modifient le troll lui-même : leurs bonus comptent dans
+ * PURES et sans recouvrement : xxxFlatPhys = uniquement l'équipement physique
- * les deux ; l'équipement compte selon la saveur de chaque bonus (att/deg/arm
+ * (att/esq/deg/reg/arm), xxxFlatMag = uniquement le magique (potions/parchemins
- * physiques, attMag/degMag/armMag magiques). Armure :
+ * + équipement magique attMag/degMag/armMag). xxxFlat = phys + mag = le bonus
- * armorPhys = base + naturelle + équipement phys, armorMag = effets magiques
+ * total réellement ajouté au jet. (Avant, la potion était comptée dans les deux
- * + équipement mag. Les dégâts physiques sont réduits par l'armure totale,
+ * colonnes → faux double comptage à l'affichage.) Armure : armorPhys = base
- * les dégâts magiques par la seule armure magique. */
+ * naturelle + équipement phys, armorMag = effets magiques + équipement mag. Les
+ * dégâts physiques sont réduits par l'armure totale, les dégâts magiques par la
+ * seule armure magique. */
 function effTroll(troll) {
   const m = sumPotionMods(troll.potionEffects); // magique (modifie le troll)
   const g = troll.gearMods || {};               // équipement (phys + mag)
   return {
     att: Math.max(1, troll.att + m.att),
-    attFlat: m.attFlat + (g.att || 0),
+    attFlatPhys: g.att || 0, attFlatMag: m.attFlat + (g.attMag || 0),
-    attFlatPhys: m.attFlat + (g.att || 0), attFlatMag: m.attFlat + (g.attMag || 0),
+    attFlat: (g.att || 0) + m.attFlat + (g.attMag || 0),
     esq: Math.max(1, troll.esq + m.esq),
-    esqFlat: m.esqFlat + (g.esq || 0), esqFlatPhys: g.esq || 0, esqFlatMag: m.esqFlat,
+    esqFlatPhys: g.esq || 0, esqFlatMag: m.esqFlat,
+    esqFlat: (g.esq || 0) + m.esqFlat,
     deg: Math.max(1, troll.deg + m.deg),
-    degFlat: m.degFlat + (g.deg || 0),
+    degFlatPhys: g.deg || 0, degFlatMag: m.degFlat + (g.degMag || 0),
-    degFlatPhys: m.degFlat + (g.deg || 0), degFlatMag: m.degFlat + (g.degMag || 0),
+    degFlat: (g.deg || 0) + m.degFlat + (g.degMag || 0),
     reg: Math.max(1, troll.reg + m.reg),
-    regFlat: m.regFlat + (g.reg || 0), regFlatPhys: g.reg || 0, regFlatMag: m.regFlat,
+    regFlatPhys: g.reg || 0, regFlatMag: m.regFlat,
+    regFlat: (g.reg || 0) + m.regFlat,
     vue: Math.max(1, troll.vue + m.vue + (g.vue || 0)),
     armor: Math.max(0, troll.armor + m.armor + (g.arm || 0) + (g.armMag || 0)),
     armorPhys: Math.max(0, troll.armor + (g.arm || 0)),
@@ -675,6 +692,6 @@ if (typeof module !== "undefined" && module.exports) {
     POTION_IDS, POTION_DEFS, sumPotionMods, effTroll, formatPotionItem,
     makeRandomPotion, makePotionItem, drinkPotion, goinfreItem, tickPotionTurns,
     describeActiveEffects, renderEffectsPanel, countActiveEffects, formatEffectMods,
-    sharedMod, makeEffect, fmtStatLine, talentPctWithPotions, corruptionYZ,
+    sharedMod, makeEffect, fmtStatLine, fmtArmorLine, talentPctWithPotions, corruptionYZ,
   };
 }

test/smoke.js

@@ -115,13 +115,15 @@ assert.strictEqual(g.improveCost("esq", 1, "Tomawak"), 32, "2e dé d'ESQ = 32 PI
   // décomposition par type d'attaque : l'équipement compte selon sa saveur,
   // les potions modifient le troll et comptent dans les deux
   g.equipGear(t, gearLib.gearItemByName("arme", "Gourdin")); // att +2, deg +5 (physiques)
-  p.drinkPotion(t, p.makePotionItem("bonneBouffe", 5), g.rollDice, () => {}); // DEG +5 (potion)
+  p.drinkPotion(t, p.makePotionItem("bonneBouffe", 5), g.rollDice, () => {}); // DEG +5 (potion, magique)
   const e2 = p.effTroll(t);
-  assert.strictEqual(e2.attFlatPhys, 2, "attaque physique : ATT +2 du Gourdin");
+  // colonnes PURES : physique = équipement seul, magique = potions/parchemins
-  assert.strictEqual(e2.attFlatMag, 0, "attaque magique : pas de bonus d'ATT");
+  // + équipement magique. Le total (xxxFlat) = phys + mag (les deux se cumulent).
-  assert.strictEqual(e2.degFlatPhys, 10, "attaque physique : DEG +5 Gourdin +5 Bonne Bouffe");
+  assert.strictEqual(e2.attFlatPhys, 2, "bonus physique d'ATT : +2 du Gourdin");
-  assert.strictEqual(e2.degFlatMag, 5, "attaque magique : seule la Bonne Bouffe compte");
+  assert.strictEqual(e2.attFlatMag, 0, "bonus magique d'ATT : aucun");
-  assert.strictEqual(e2.degFlat, 10, "degFlat = bonus des attaques physiques");
+  assert.strictEqual(e2.degFlatPhys, 5, "bonus physique de DEG : +5 du Gourdin (équipement)");
+  assert.strictEqual(e2.degFlatMag, 5, "bonus magique de DEG : +5 de la Bonne Bouffe (potion)");
+  assert.strictEqual(e2.degFlat, 10, "degFlat = total ajouté au jet = phys + mag");
 }
 
 // ATT/DEG/ARM phys et mag partout : équipement magique et choix du bonus selon l'attaque
@@ -140,12 +142,13 @@ assert.strictEqual(g.improveCost("esq", 1, "Tomawak"), 32, "2e dé d'ESQ = 32 PI
   assert.strictEqual(e.degFlatMag, 6, "DEG mag +6 sur les sortilèges");
   assert.strictEqual(e.armorMag, 2, "Armure mag +2 d'équipement");
   assert.strictEqual(e.armorPhys, 0, "pas d'armure physique");
-  // resolveAttack choisit le bon bonus selon le type d'attaque
+  // resolveAttack ajoute TOUJOURS les deux bonus (phys + mag), quel que soit le
+  // type d'attaque ; opts.magic ne change plus que l'armure qui réduit.
   const dummy = { esq: 1, armor: 0, armorMag: 0 };
   const rPhys = g.resolveAttack(e, dummy, { autoHit: true });
   const rMag = g.resolveAttack(e, dummy, { autoHit: true, magic: true });
-  assert.strictEqual(rPhys.attFlat, 0, "jet physique : ATT sans bonus");
+  assert.strictEqual(rPhys.attFlat, 4, "jet : ATT +4 (phys 0 + mag 4)");
-  assert.strictEqual(rMag.attFlat, 4, "jet magique : ATT +4");
+  assert.strictEqual(rMag.attFlat, 4, "jet magique : ATT +4 (phys 0 + mag 4)");
   assert(rMag.rawDamage >= 1 * 1 + 6 + 0 && rMag.rawDamage <= 3 * 3 * 2 + 12, "dégâts magiques avec DEG mag");
   // le formatage des mods affiche les saveurs magiques
   const label = gearLib.formatGearMods(baton.mods);