Nouveau roll-dialog: mode attaque / defense

module/item/arme.js

@@ -1,10 +1,9 @@
 import { ITEM_TYPES } from "../constants.js";
 import { RdDItem } from "../item.js";
-
-import { RdDItemCompetenceCreature } from "../item-competencecreature.js"
 import { BASE_CORPS_A_CORPS } from "./base-items.js";
 import { Grammar } from "../grammar.js";
 import { RdDInitiative } from "../initiative.mjs";
+import { MappingCreatureArme } from "./mapping-creature-arme.mjs";
 
 const nomCategorieParade = {
   "sans-armes": "Sans arme",
@@ -19,24 +18,48 @@ const nomCategorieParade = {
   "haches": "Haches",
   "lances": "Lances",
 }
-
+export const ATTAQUE_TYPE = {
+  UNE_MAIN: '(1 main)',
+  DEUX_MAINS: '(2 mains)',
+  COMPETENCE: 'competence',
+  TIR: '(tir)',
+  LANCER: '(lancer)'
+}
 /* -------------------------------------------- */
 export class RdDItemArme extends RdDItem {
 
   static get ITEM_TYPE() { return ITEM_TYPES.arme }
 
-  static get defaultIcon() {
-    return defaultItemImgArme
-    //return "systems/foundryvtt-reve-de-dragon/icons/armes_armure/epee_sord.webp";
-  }
+  static get defaultIcon() { return "systems/foundryvtt-reve-de-dragon/icons/armes_armures/epee_gnome.webp" }
+
+  penetration() { return parseInt(this.system.penetration ?? 0) }
+
+  isParade() { return this.system.resistance > 0 && this.system.categorie_parade }
+  isBouclier() { return RdDItemArme.getCategorieParade(this).includes('bouclier') }
 
   /* -------------------------------------------- */
+  static valeurMain(valeurs, main) {
+    valeurs = valeurs?.toString() ?? ""
+    const table = valeurs.includes("/") ? valeurs.split("/") : [valeurs, valeurs]
+    return parseInt(main == ATTAQUE_TYPE.DEUX_MAINS ? table[1] : table[0])
+  }
+
+  static getMainAttaque(competence) {
+    switch (competence.system.categorie) {
+      case 'tir': return ATTAQUE_TYPE.TIR
+      case 'lancer': return ATTAQUE_TYPE.LANCER
+    }
+    if (competence.name.includes('2 main')) {
+      return ATTAQUE_TYPE.DEUX_MAINS
+    }
+    return ATTAQUE_TYPE.UNE_MAIN
+  }
 
   static getArme(arme) {
     switch (arme ? arme.type : '') {
       case ITEM_TYPES.arme: return arme;
       case ITEM_TYPES.competencecreature:
-        return RdDItemCompetenceCreature.armeCreature(arme);
+        return MappingCreatureArme.armeCreature(arme);
     }
     return RdDItemArme.corpsACorps();
   }
@@ -47,11 +70,11 @@ export class RdDItemArme extends RdDItem {
         return arme.name
       case ITEM_TYPES.arme:
         switch (maniement) {
-          case 'competence': return arme.system.competence;
-          case '(1 main)': return arme.competence1Mains()
-          case '(2 mains)': return arme.competence2Mains()
-          case '(tir)': case 'tir': return arme.system.tir
-          case '(lancer)': case 'lancer': return arme.system.lancer;
+          case ATTAQUE_TYPE.COMPETENCE: return arme.system.competence;
+          case ATTAQUE_TYPE.UNE_MAIN: return arme.competence1Mains()
+          case ATTAQUE_TYPE.DEUX_MAINS: return arme.competence2Mains()
+          case ATTAQUE_TYPE.TIR: case 'tir': return arme.system.tir
+          case ATTAQUE_TYPE.LANCER: case 'lancer': return arme.system.lancer;
         }
     }
     return undefined
@@ -88,16 +111,13 @@ export class RdDItemArme extends RdDItem {
 
   /* -------------------------------------------- */
   static getCategorieParade(armeData) {
+    if (![ITEM_TYPES.arme, ITEM_TYPES.competencecreature].includes(armeData.type)) {
+      return ''
+    }
     if (armeData.system.categorie_parade) {
       return armeData.system.categorie_parade
     }
     // pour compatibilité avec des personnages existants
-    if (armeData.type == ITEM_TYPES.competencecreature || armeData.system.categorie == 'creature') {
-      return armeData.system.categorie_parade || (armeData.system.isparade ? 'armes-naturelles' : '')
-    }
-    if (!armeData.type.match(/arme|competencecreature/)) {
-      return ''
-    }
     if (armeData.system.competence == undefined) {
       return ITEM_TYPES.competencecreature;
     }
@@ -192,7 +212,7 @@ export class RdDItemArme extends RdDItem {
         return Number(arme.system.dommages)
       }
       const tableauDegats = arme.system.dommages.split("/");
-      return Number(tableauDegats[maniement == '(1 main)' ? 0 : 1])
+      return Number(tableauDegats[maniement == ATTAQUE_TYPE.UNE_MAIN ? 0 : 1])
     }
     return Number(arme.system.dommages);
   }
@@ -201,7 +221,7 @@ export class RdDItemArme extends RdDItem {
   static armeUneOuDeuxMains(arme, aUneMain) {
     if (arme && !arme.system.cac) {
       arme = foundry.utils.duplicate(arme);
-      arme.system.dommagesReels = RdDItemArme.dommagesReels(arme, aUneMain ? '(1 main)' : '(2 mains)')
+      arme.system.dommagesReels = RdDItemArme.dommagesReels(arme, aUneMain ? ATTAQUE_TYPE.UNE_MAIN : ATTAQUE_TYPE.DEUX_MAINS)
     }
     return arme;
   }
@@ -222,25 +242,10 @@ export class RdDItemArme extends RdDItem {
     return false
   }
 
-  static isAttaque(arme) {
-    switch (arme.type) {
-      case ITEM_TYPES.arme: return arme.system.equipe && (arme.system.resistance > 0 || arme.system.portee_courte > 0)
-      case ITEM_TYPES.competencecreature: return arme.system.iscombat && RdDItemCompetenceCreature.isAttaque(item)
-    }
-    return false
+  isAttaque() {
+    return this.system.resistance > 0 || this.system.portee_courte > 0
   }
 
-  static isParade(arme) {
-    switch (arme.type) {
-      case ITEM_TYPES.arme:
-        return arme.system.resistance > 0 && true/* TODO: regarder la categorie d'arme?*/
-      case ITEM_TYPES.competencecreature:
-        return arme.system.iscombat && RdDItemCompetenceCreature.isParade(arme)
-    }
-    return false
-  }
-
-
   static corpsACorps(actor) {
     let competence = actor?.getCompetenceCorpsACorps() ?? BASE_CORPS_A_CORPS
     let melee = actor ? actor.system.carac['melee'].value : 0

module/item/base-items.js

@@ -18,3 +18,12 @@ export const SANS_COMPETENCE = {
   img: "systems/foundryvtt-reve-de-dragon/icons/templates/icone_parchement_vierge.webp"
 }  
 
+export const CATEGORIES_COMPETENCES_CREATURES = {
+  "generale": { base: 0, label: "Générale" },
+  "naturelle": { base: 0, label: "Arme naturelle" },
+  "melee": { base: 0, label: "Mêlée" },
+  "parade": { base: 0, label: "Parade" },
+  "tir": { base: 0, label: "Tir" },
+  "lancer": { base: 0, label: "Lancer" },
+  "possession": { base: 0, label: "Possession" },
+}

module/item/mapping-creature-arme.mjs

@@ -0,0 +1,42 @@
+import { Grammar } from "../grammar.js";
+import { RdDInitiative } from "../initiative.mjs";
+
+export class MappingCreatureArme {
+
+
+  /* -------------------------------------------- */
+  static setRollDataCreature(rollData) {
+    const code = Grammar.toLowerCaseNoAccentNoSpace(rollData.competence.name);
+    const selectedCarac = { code: code, label: rollData.competence.name, value: rollData.competence.system.carac_value };
+    rollData.carac = { [code]: selectedCarac }
+    rollData.competence.system.defaut_carac = code
+    rollData.selectedCarac = selectedCarac
+    rollData.arme = MappingCreatureArme.armeCreature(rollData.competence);
+  }
+
+
+  /* -------------------------------------------- */
+  static armeCreature(item) {
+    const categorieAttaque = item.getCategorieAttaque()
+    if (categorieAttaque != undefined) {
+      // cloner pour ne pas modifier la compétence
+      return foundry.utils.mergeObject(item, {
+        action: item.isCompetencePossession() ? 'possession' : 'attaque',
+        system: {
+          competence: item.name,
+          cac: categorieAttaque == "naturelle" ? "naturelle" : "",
+          niveau: item.system.niveau,
+          initiative: RdDInitiative.calculInitiative(item.system.niveau, item.system.carac_value),
+          equipe: true,
+          resistance: 100,
+          dommagesReels: item.system.dommages,
+          penetration: 0,
+          force: 0,
+          rapide: true,
+        }
+      }, { inplace: false, });
+    }
+    return undefined;
+  }
+
+}