Nouveau roll-dialog: mode attaque

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 dommagesArme = parseInt(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,
-      dommagesArme: dommagesArme,
-      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/roll/roll-part-attaque.mjs

@@ -44,7 +44,7 @@ export class RollPartAttaque extends RollPartSelect {
   prepareContext(rollData) {
     const current = this.getCurrent(rollData)
     const effetsSurprise = rollData.opponent?.actor?.getEffects(it => StatusEffects.niveauSurprise(it, true) > 0) ?? []
-    current.defenseur = effetsSurprise
+    current.defenseur = effetsSurprise.length > 0
       ? {
         surprise: RdDBonus.find(rollData.opponent?.actor?.getSurprise(true)),
         effects: effetsSurprise
@@ -78,7 +78,7 @@ export class RollPartAttaque extends RollPartSelect {
       penetration: current.arme.penetration(),
       dmgTactique: current.tactique?.dmg ?? 0,
       dmgParticuliere: 0, // TODO RdDBonus._dmgParticuliere(rollData),
-      dmgSurprise: current.defenseur?.surprise.dmg,
+      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)
     }

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,5 +1,5 @@
-{{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"}}

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>