Résolution de soucis inter-types de jets V2

- diminution de la dépendance au token cible pour les attaques
- ne pas proposer l'attaque sur les jets "par défaut"
- filtrer les sous-parties inutiles (ie: sorts pour les attaques, etc)

module/combat/distance.mjs

@@ -23,11 +23,10 @@ export class Distance {
   static ajustements(token, defenderToken, attaque) {
     const typeAttaque = Distance.typeAttaqueDistance(attaque)
     if (typeAttaque) {
-
       const distance = Distance.distance(token, defenderToken)
       const isVisible = Distance.isVisible(token, defenderToken)
       const portee = Distance.ajustementPortee(distance, attaque.arme)
-      const taille = Distance.ajustementTaille(defenderToken.actor)
+      const taille = Distance.ajustementTaille(defenderToken?.actor)
       const activite = Distance.ajustementMouvement(defenderToken)
       const total = Distance.diff(portee, taille, activite)
       const diffDefense = Distance.ajustementDefense(attaque)
@@ -37,19 +36,28 @@ export class Distance {
   }
 
   static distance(token, defenderToken) {
-    const ray = new foundry.canvas.geometry.Ray(
+    if (token && defenderToken) {
-      token.getCenterPoint(),
+      const ray = new foundry.canvas.geometry.Ray(
-      defenderToken.getCenterPoint()
+        token.getCenterPoint(),
-    )
+        defenderToken.getCenterPoint()
-    return Number(canvas.grid.measureDistances([{ ray }], { gridSpaces: false }))
+      )
+      return Number(canvas.grid.measureDistances([{ ray }], { gridSpaces: false }))
+    }
+    return -1 /* distance indéterminée */
   }
 
   static isVisible(token, defenderToken) {
     // TODO: regarder les StatusEffect aveuglé?
-    return canvas.effects.visibility.testVisibility(defenderToken.getCenterPoint(), { object: token })
+    if (token && defenderToken) {
+      return canvas.effects.visibility.testVisibility(defenderToken.getCenterPoint(), { object: token })
+    }
+    return true
   }
 
   static ajustementPortee(distance, arme) {
+    if (distance < 0 || !arme) {
+      return { msg: "non déterminée", diff: 0 };
+    }
     if (arme.system.portee_courte && distance <= arme.system.portee_courte) return { msg: "courte", diff: 0 };
     if (arme.system.portee_moyenne && distance <= arme.system.portee_moyenne) return { msg: "moyenne", diff: -3 };
     if (arme.system.portee_extreme && distance <= arme.system.portee_extreme) return { msg: "extrême", diff: -5 };
@@ -57,6 +65,9 @@ export class Distance {
   }
 
   static ajustementTaille(actor) {
+    if (!actor) {
+      return { msg: "non déterminée", diff: 0 };
+    }
     if (actor.isVehicule()) return { msg: "véhicule", diff: 0 }
     const taille = actor.getCaracByName('TAILLE')?.value ?? 1;
     if (taille <= 1) return { msg: "souris", diff: -8 };
@@ -68,8 +79,10 @@ export class Distance {
   }
 
   static ajustementMouvement(defenderToken) {
-    if (defenderToken.actor?.getSurprise(true) != '') return { msg: "immobile (surprise)", diff: 0 };
+    if (defenderToken) {
-    if (defenderToken.inCombat) return { msg: "en mouvement (combat)", diff: -4 };
+      if (defenderToken.actor?.getSurprise(true) != '') return { msg: "immobile (surprise)", diff: 0 };
+      if (defenderToken.inCombat) return { msg: "en mouvement (combat)", diff: -4 };
+    }
     return { msg: "à déterminer (0 immobile, -3 actif, -4 en mouvement, -5 en zig-zag)", diff: -3 };
   }
 

module/roll/roll-constants.mjs

@@ -13,8 +13,7 @@ export const ROLL_TYPE_TACHE = 'tache'
 export const ATTAQUE_ROLL_TYPES = [ROLL_TYPE_ATTAQUE]
 export const COMBAT_ROLL_TYPES = [ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE]
 export const DEMIREVE_ROLL_TYPES = [ROLL_TYPE_SORT]
-export const DEFAULT_ROLL_TYPES = [ROLL_TYPE_COMP, ROLL_TYPE_ATTAQUE, ROLL_TYPE_TACHE, ROLL_TYPE_MEDITATION, ROLL_TYPE_CUISINE, ROLL_TYPE_OEUVRE, ROLL_TYPE_JEU]
+export const DEFAULT_ROLL_TYPES = [ROLL_TYPE_COMP, ROLL_TYPE_TACHE, ROLL_TYPE_MEDITATION, ROLL_TYPE_CUISINE, ROLL_TYPE_OEUVRE, ROLL_TYPE_JEU]
-
 
 export const DIFF = {
   LIBRE: 'libre',

module/roll/roll-dialog-adapter.mjs

@@ -50,7 +50,7 @@ export class RollDialogAdapter {
     rolled.factorHtml = Misc.getFractionOneN(rollData.current.sign.diviseur)
     if (ReglesOptionnelles.isUsing("afficher-colonnes-reussite")) {
       rolled.niveauNecessaire = RdDResolutionTable.findNiveauNecessaire(rolled.caracValue, rolled.roll)
-      rolled.ajustementNecessaire = rolled.niveauNecessaire - diff
+      rolled.ajustementNecessaire = rolled.niveauNecessaire - rolled.finalLevel
     }
     return rolled
   }

module/roll/roll-dialog.mjs

@@ -310,8 +310,10 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
     rollData.refs = foundry.utils.mergeObject(rollData.refs ?? {}, Object.fromEntries(ROLL_PARTS.map(p => [p.code, {}])));
     rollData.options = rollData.options ?? { rollMode: game.settings.get("core", "rollMode") }
 
-    ROLL_PARTS.forEach(p => p.initialize(rollData))
+    ROLL_PARTS.forEach(p => RollDialog.$initializeRollPart(rollData, p.code))
-    ROLL_PARTS.filter(p => p.isValid(rollData))
+    ROLL_PARTS
+      .filter(p => RollDialog.$isIntersecting(allowed, p.rollTypes))
+      .filter(p => p.isValid(rollData))
       .forEach(p => {
         p.restore(rollData)
         p.loadRefs(rollData)
@@ -320,6 +322,14 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
     return rollData
   }
 
+  static $initializeRollPart(rollData, code) {
+    rollData.refs[code] = rollData.refs[code] ?? {}
+    rollData.current[code] = rollData.current[code] ?? {}
+    rollData.selected[code] = rollData.selected[code] ?? {}
+  }
+
+  static $isIntersecting(allowed, included) { return included ? included.find(it => allowed.includes(it)) : true }
+
   static saveParts(rollData, impacts = undefined) {
     if (rollData == undefined) {
       return undefined
@@ -540,7 +550,7 @@ export default class RollDialog extends HandlebarsApplicationMixin(ApplicationV2
 
   static loadRollData(roll) {
     RollDialog.$prepareRollData(roll)
-    if (roll.attackerRoll){
+    if (roll.attackerRoll) {
       RollDialog.$prepareRollData(roll.attackerRoll)
     }
     RollDialog.calculAjustement(roll)

module/roll/roll-part-attaque.mjs

@@ -11,7 +11,7 @@ import { PART_COMP } from "./roll-part-comp.mjs"
 import { PART_DIFF } from "./roll-part-diff.mjs"
 import { RollPartSelect } from "./roll-part-select.mjs"
 import { PART_SIGN } from "./roll-part-sign.mjs"
-import { ROLLDIALOG_SECTION } from "./roll-part.mjs"
+import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
 
 export const PART_ATTAQUE = 'attaque'
 
@@ -26,7 +26,9 @@ export class RollPartAttaque extends RollPartSelect {
   get code() { return PART_ATTAQUE }
   get section() { return ROLLDIALOG_SECTION.CHOIX }
 
-  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_ATTAQUE) }
+  get rollTypes() { return [ROLL_TYPE_ATTAQUE] }
+
+  visible(rollData) { return RollPart.isRollType(rollData, ROLL_TYPE_ATTAQUE) }
 
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)
@@ -69,7 +71,7 @@ export class RollPartAttaque extends RollPartSelect {
     attaque.key = `${attaque.action}::${attaque.label}`
     attaque.tactique = TACTIQUES[0]
     attaque.initialDiff = attaque.comp?.system.default_diffLibre ?? 0
-    attaque.distance = Distance.ajustements(rollData.active.token, rollData.opponent.token, attaque)
+    attaque.distance = Distance.ajustements(rollData.active?.token, rollData.opponent?.token, attaque)
     return attaque
   }
 

module/roll/roll-part-cuisine.mjs

@@ -4,7 +4,7 @@ import { ROLL_TYPE_CUISINE } 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 } from "./roll-part.mjs"
+import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
 
 export const PART_CUISINE = "cuisine"
 
@@ -16,8 +16,10 @@ export class RollPartCuisine extends RollPartSelect {
   get code() { return PART_CUISINE }
   get section() { return ROLLDIALOG_SECTION.CHOIX }
 
+  get rollTypes() { return [ROLL_TYPE_CUISINE] }
+
   isValid(rollData) { return rollData.active.actor.isPersonnage() }
-  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_CUISINE) }
+  visible(rollData) { return RollPart.isRollType(rollData, ROLL_TYPE_CUISINE) }
 
   restore(rollData) {
     super.restore(rollData)

module/roll/roll-part-defense.mjs

@@ -8,7 +8,7 @@ import { PART_COMP } from "./roll-part-comp.mjs"
 import { PART_DIFF } from "./roll-part-diff.mjs"
 import { RollPartSelect } from "./roll-part-select.mjs"
 import { PART_SIGN } from "./roll-part-sign.mjs"
-import { ROLLDIALOG_SECTION } from "./roll-part.mjs"
+import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
 
 export const PART_DEFENSE = 'defense'
 
@@ -17,8 +17,9 @@ export class RollPartDefense extends RollPartSelect {
   get code() { return PART_DEFENSE }
   get section() { return ROLLDIALOG_SECTION.CHOIX }
 
-  isValid(rollData) { return this.isRollType(rollData, ROLL_TYPE_DEFENSE) && rollData.attackerRoll != undefined }
+  get rollTypes() { return [ROLL_TYPE_DEFENSE] }
-  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_DEFENSE) && rollData.attackerRoll != undefined }
+  isValid(rollData) { return RollPart.isRollType(rollData, ROLL_TYPE_DEFENSE) && rollData.attackerRoll != undefined }
+  visible(rollData) { return RollPart.isRollType(rollData, ROLL_TYPE_DEFENSE) && rollData.attackerRoll != undefined }
 
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)

module/roll/roll-part-ecailles.mjs

@@ -3,6 +3,7 @@ import { ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE } from "./roll-constants.mjs"
 import { PART_ATTAQUE } from "./roll-part-attaque.mjs"
 import { RollPartCheckbox } from "./roll-part-checkbox.mjs"
 import { PART_DEFENSE } from "./roll-part-defense.mjs"
+import { RollPart } from "./roll-part.mjs"
 
 const ECAILLES = "ecailles"
 
@@ -10,8 +11,9 @@ export class RollPartEcailles extends RollPartCheckbox {
 
   get code() { return ECAILLES }
 
+  get rollTypes() { return [ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE] }
   isValid(rollData) {
-    return this.isRollType(rollData, ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE)
+    return RollPart.isRollType(rollData, ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE)
   }
 
   visible(rollData) {
@@ -25,9 +27,9 @@ export class RollPartEcailles extends RollPartCheckbox {
   }
 
   getArme(rollData) {
-    return this.isRollType(rollData, ROLL_TYPE_ATTAQUE)
+    return RollPart.isRollType(rollData, ROLL_TYPE_ATTAQUE)
       ? rollData.current[PART_ATTAQUE]?.arme
-      : this.isRollType(rollData, ROLL_TYPE_DEFENSE)
+      : RollPart.isRollType(rollData, ROLL_TYPE_DEFENSE)
         ? rollData.current[PART_DEFENSE]?.arme
         : undefined
   }

module/roll/roll-part-empoignade-taille.mjs

@@ -1,7 +1,8 @@
 import { RDD_CONFIG } from "../constants.js"
 import { RdDEmpoignade } from "../rdd-empoignade.js"
-import { COMBAT_ROLL_TYPES } from "./roll-constants.mjs"
+import { COMBAT_ROLL_TYPES, ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE } from "./roll-constants.mjs"
 import { RollPartCheckbox } from "./roll-part-checkbox.mjs"
+import { RollPart } from "./roll-part.mjs"
 
 const EMPOIGNADE_TAILLE = "empoignade-taille"
 
@@ -9,6 +10,7 @@ export class RollPartEmpoignadeTaille extends RollPartCheckbox {
 
   get code() { return EMPOIGNADE_TAILLE }
 
+  get rollTypes() { return [ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE] }
   isValid(rollData) {
     return RdDEmpoignade.isCombatantEmpoignade(rollData.ids.actorId, rollData.ids.actorTokenId)
   }

module/roll/roll-part-empoignade.mjs

@@ -1,9 +1,10 @@
 import { RDD_CONFIG } from "../constants.js"
 import { ATTAQUE_TYPE_MELEE } from "../item/arme.js"
 import { RdDEmpoignade } from "../rdd-empoignade.js"
-import { ROLL_TYPE_ATTAQUE } from "./roll-constants.mjs"
+import { ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE } from "./roll-constants.mjs"
 import { PART_ATTAQUE } from "./roll-part-attaque.mjs"
 import { RollPartCheckbox } from "./roll-part-checkbox.mjs"
+import { RollPart } from "./roll-part.mjs"
 
 const EMPOIGNADE = "empoignade"
 
@@ -11,6 +12,7 @@ export class RollPartEmpoignade extends RollPartCheckbox {
 
   get code() { return EMPOIGNADE }
 
+  get rollTypes() { return [ROLL_TYPE_ATTAQUE, ROLL_TYPE_DEFENSE] }
   isValid(rollData) {
     return RdDEmpoignade.isCombatantEmpoignade(rollData.ids.opponentId, rollData.ids.opponentTokenId) &&
       !RdDEmpoignade.isCombatantEmpoignade(rollData.ids.actorId, rollData.ids.actorTokenId)

module/roll/roll-part-jeu.mjs

@@ -4,7 +4,7 @@ import { ROLL_TYPE_JEU } from "./roll-constants.mjs"
 import { PART_CARAC } from "./roll-part-carac.mjs"
 import { PART_COMP, RollPartComp } from "./roll-part-comp.mjs"
 import { RollPartSelect } from "./roll-part-select.mjs"
-import { ROLLDIALOG_SECTION } from "./roll-part.mjs"
+import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
 import { RdDItem } from "../item.js"
 import { Misc } from "../misc.js"
 
@@ -17,8 +17,9 @@ export class RollPartJeu extends RollPartSelect {
   get code() { return PART_JEU }
   get section() { return ROLLDIALOG_SECTION.CHOIX }
 
+  get rollTypes() { return [ROLL_TYPE_JEU] }
   isValid(rollData) { return rollData.active.actor.isPersonnage() }
-  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_JEU) }
+  visible(rollData) { return RollPart.isRollType(rollData, ROLL_TYPE_JEU) }
 
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)

module/roll/roll-part-meditation.mjs

@@ -7,7 +7,7 @@ import { ROLL_TYPE_MEDITATION } from "./roll-constants.mjs"
 import { PART_CARAC, RollPartCarac } from "./roll-part-carac.mjs"
 import { PART_COMP } from "./roll-part-comp.mjs"
 import { RollPartSelect } from "./roll-part-select.mjs"
-import { ROLLDIALOG_SECTION } from "./roll-part.mjs"
+import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
 
 export const PART_MEDITATION = "meditation"
 
@@ -18,6 +18,10 @@ export class RollPartMeditation extends RollPartSelect {
   get code() { return PART_MEDITATION }
   get section() { return ROLLDIALOG_SECTION.CHOIX }
 
+  get rollTypes() { return [ROLL_TYPE_MEDITATION] }
+  isValid(rollData) { return rollData.active.actor.isPersonnage() && rollData.active.actor.isHautRevant() }
+  visible(rollData) { return RollPart.isRollType(rollData, ROLL_TYPE_MEDITATION) }
+
   store(rollData, targetData) {
     const current = this.getCurrent(rollData)
     this.setSaved(targetData, {
@@ -29,9 +33,6 @@ export class RollPartMeditation extends RollPartSelect {
     })
   }
 
-  isValid(rollData) { return rollData.active.actor.isPersonnage() && rollData.active.actor.isHautRevant() }
-  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_MEDITATION) }
-
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)
     const actor = rollData.active.actor

module/roll/roll-part-oeuvre.mjs

@@ -5,7 +5,7 @@ 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"
-import { ROLLDIALOG_SECTION } from "./roll-part.mjs"
+import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
 
 export const PART_OEUVRE = "oeuvre"
 
@@ -35,8 +35,9 @@ export class RollPartOeuvre extends RollPartSelect {
   get code() { return PART_OEUVRE }
   get section() { return ROLLDIALOG_SECTION.CHOIX }
 
+  get rollTypes() { return [ROLL_TYPE_OEUVRE] }
   isValid(rollData) { return rollData.active.actor.isPersonnage() }
-  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_OEUVRE) }
+  visible(rollData) { return RollPart.isRollType(rollData, ROLL_TYPE_OEUVRE) }
 
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)
@@ -88,7 +89,7 @@ export class RollPartOeuvre extends RollPartSelect {
       const current = this.getCurrent(rollData)
       switch (part.code) {
         case PART_CARAC: return part.filterCaracs(rollData, current.caracs)
-        case PART_COMP: return part.filterComps(rollData,[current.comp?.name])
+        case PART_COMP: return part.filterComps(rollData, [current.comp?.name])
       }
     }
     return undefined

module/roll/roll-part-possession.mjs

@@ -5,7 +5,7 @@ import { ROLL_TYPE_POSSESSION } 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 } from "./roll-part.mjs"
+import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
 
 export const PART_POSSESSION = "possession"
 
@@ -17,7 +17,8 @@ export class RollPartPossession extends RollPartSelect {
   get name() { return 'Possession' }
   get section() { return ROLLDIALOG_SECTION.CHOIX }
 
-  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_POSSESSION) }
+  get rollTypes() { return [ROLL_TYPE_POSSESSION] }
+  visible(rollData) { return RollPart.isRollType(rollData, ROLL_TYPE_POSSESSION) }
 
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)
@@ -61,10 +62,10 @@ export class RollPartPossession extends RollPartSelect {
       rollDialog.render()
     })
     button?.addEventListener("click", async e => {
-        e.preventDefault()
+      e.preventDefault()
-        await RdDPossessionV2.createPossessionIfMissing(rollData.active, rollData.opponent)
+      await RdDPossessionV2.createPossessionIfMissing(rollData.active, rollData.opponent)
-        rollDialog.render()
+      rollDialog.render()
-      })
+    })
   }
 
   $selectPossession(rollData, key) {

module/roll/roll-part-sort.mjs

@@ -2,7 +2,7 @@ import { ITEM_TYPES } from "../constants.js"
 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"
+import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
 import { TMRUtility } from "../tmr-utility.js"
 import { RdDItemSort } from "../item-sort.js"
 import { RollPartSelect } from "./roll-part-select.mjs"
@@ -19,8 +19,9 @@ export class RollPartSort extends RollPartSelect {
   get code() { return PART_SORT }
   get section() { return ROLLDIALOG_SECTION.CHOIX }
 
+  get rollTypes() { return [ROLL_TYPE_SORT] }
   isValid(rollData) { return rollData.active.actor.isPersonnage() && rollData.active.actor.isHautRevant() }
-  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_SORT) }
+  visible(rollData) { return RollPart.isRollType(rollData, ROLL_TYPE_SORT) }
 
   restore(rollData) {
     const saved = this.getSaved(rollData)

module/roll/roll-part-tache.mjs

@@ -3,7 +3,7 @@ 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"
-import { ROLLDIALOG_SECTION } from "./roll-part.mjs"
+import { ROLLDIALOG_SECTION, RollPart } from "./roll-part.mjs"
 
 export const PART_TACHE = "tache"
 
@@ -12,8 +12,9 @@ export class RollPartTache extends RollPartSelect {
   get code() { return PART_TACHE }
   get section() { return ROLLDIALOG_SECTION.CHOIX }
 
+  get rollTypes() { return [ROLL_TYPE_TACHE] }
   isValid(rollData) { return rollData.active.actor.isPersonnage() }
-  visible(rollData) { return this.isRollType(rollData, ROLL_TYPE_TACHE) }
+  visible(rollData) { return RollPart.isRollType(rollData, ROLL_TYPE_TACHE) }
 
   loadRefs(rollData) {
     const refs = this.getRefs(rollData)

module/roll/roll-part.mjs

@@ -1,3 +1,5 @@
+import { ALL_ROLL_TYPES } from "./roll-dialog.mjs"
+
 export const ROLLDIALOG_SECTION = {
   ACTION: 'action',
   CARAC: 'carac',
@@ -19,17 +21,6 @@ export class RollPart {
   /** le template handlebars pour affichage */
   get template() { return `systems/foundryvtt-reve-de-dragon/templates/roll/roll-part-${this.code}.hbs` }
 
-  initialize(rollData) {
-    if (rollData.refs[this.code] == undefined) {
-      rollData.refs[this.code] = {}
-    }
-    if (rollData.current[this.code] == undefined) {
-      rollData.current[this.code] = {}
-    }
-    if (rollData.selected[this.code] == undefined) {
-      rollData.selected[this.code] = {}
-    }
-  }
   /** l'acteur actif du jet */
   getActor(rollData) { return rollData.active.actor }
   /** le conteneur de données du RollPart */
@@ -78,8 +69,8 @@ export class RollPart {
    * @returns une chaîne vide si rien ne doit être affiché
   */
   title() { return '' }
-  isRollType(rollData, ...type) { return type.includes(rollData.type.current)}
+  static isRollType(rollData, ...type) { return type.includes(rollData.type.current) }
-
+  get rollTypes() { return undefined }
   isActive(rollData) { return this.isValid(rollData) && this.visible(rollData) }
   isValid(rollData) { return true }
   visible(rollData) { return true }