Merge pull request '12.0.11' (#712) from VincentVk/foundryvtt-reve-de-dragon:v11 into v11

Reviewed-on: public/foundryvtt-reve-de-dragon#712

changelog.md

@@ -1,4 +1,15 @@
 # 12.0
+## 12.0.11 - Le scriptorium d'Astrobazzarh
+- ajout d'un bouton pour générer les éléments de description d'un personnage
+- ajout du logo en background dans la liste des systèmes Foundry
+- ajout d'un champ pour le métier
+- export scriptarium
+  - encodage de l'export en windows-1252
+  - export de l'esquive avec armure et sans armure
+
+## 12.0.10 - Le scriptorium d'Astrobazzarh
+- corrections de l'export scriptarium
+
 ## 12.0.9 - Le scriptorium d'Astrobazzarh
 - ajout d'une fonction avancée pour exporter les personnages dans un format csv
 

module/actor-sheet.js

@@ -17,6 +17,7 @@ import { RdDItemBlessure } from "./item/blessure.js";
 import { RdDEmpoignade } from "./rdd-empoignade.js";
 import { RdDBaseActorSangSheet } from "./actor/base-actor-sang-sheet.js";
 import { RdDCoeur } from "./coeur/rdd-coeur.js";
+import { AppPersonnageAleatoire } from "./actor/random/app-personnage-aleatoire.js";
 
 /* -------------------------------------------- */
 /**
@@ -198,6 +199,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     this.html.find('.jeu-label a').click(async event => this.actor.rollJeu(RdDSheetUtility.getItemId(event)))
     this.html.find('.recettecuisine-label a').click(async event => this.actor.rollRecetteCuisine(RdDSheetUtility.getItemId(event)))
 
+    this.html.find('.description-aleatoire').click(async event => new AppPersonnageAleatoire(this.actor).render(true))
     if (game.user.isGM) {
       // experience log
       this.html.find('.experiencelog-delete').click(async event => {

module/actor.js

@@ -3067,7 +3067,7 @@ export class RdDActor extends RdDBaseActorSang {
     incarnation.name = 'Réincarnation de ' + incarnation.name
     incarnation.system = {
       carac: foundry.utils.duplicate(this.system.carac),
-      heure: RdDTimestamp.defHeure(await RdDDice.rollTotal("1dh", { rollMode: "selfroll", showDice: SHOW_DICE })).key,
+      heure: RdDTimestamp.defHeure(await RdDDice.rollHeure( { rollMode: "selfroll", showDice: SHOW_DICE })).key,
       age: 18,
       biographie: '',
       notes: '',

module/actor/base-actor.js

@@ -542,7 +542,7 @@ export class RdDBaseActor extends Actor {
     // Calculer le total actuel des contenus
     const encContenu = dest.getEncContenu();
     const newEnc = moved.getEncTotal(); // Calculer le total actuel du nouvel objet
-    const placeDisponible = Math.roundDecimals(dest.system.capacite - encContenu - newEnc, 4)
+    const placeDisponible = Misc.keepDecimals(dest.system.capacite - encContenu - newEnc, 4)
 
     // Teste si le conteneur de destination a suffisament de capacité pour recevoir le nouvel objet
     if (placeDisponible < 0) {

module/actor/export-scriptarium/export-scriptarium.js

@@ -1,4 +1,3 @@
-import { LOG_HEAD } from "../../constants.js"
 import { ACTOR_TYPES } from "../../item.js"
 import { Misc } from "../../misc.js"
 import { EXPORT_CSV_SCRIPTARIUM, OptionsAvancees } from "../../settings/options-avancees.js"
@@ -28,6 +27,7 @@ export class ExportScriptarium {
       callback: target => this.exportActors(this.$getActors(actorDirectory, target), this.$getTargetName(actorDirectory, target))
     })
   }
+
   $getTargetName(actorDirectory, target) {
     const li = target.closest(".directory-item")
     const folderId = li.data("folderId")
@@ -36,6 +36,7 @@ export class ExportScriptarium {
       ? game.actors.get(actorId).name
       : actorDirectory.folders.find(it => it.id == folderId).name
   }
+
   $getActors(actorDirectory, target) {
     const li = target.closest(".directory-item")
     const folderId = li.data("folderId")
@@ -53,8 +54,8 @@ export class ExportScriptarium {
     const header = Misc.join(this.getHeaderLine(), ';')
     const actorLines = actors.map(actor => Misc.join(this.getActorLine(actor), ';'))
     const data = Misc.join([header, ...actorLines], eol)
-    const filename = `scriptatium-${targetName?.slugify()}.csv`;
-    saveDataToFile(data, "text/csv", `${filename}`);
+    const filename = `scriptarium-${targetName?.slugify()}.csv`;
+    saveDataToFile(data, "text/csv;charset=windows-1252", `${filename}`);
   }
 
   getHeaderLine() {

module/actor/export-scriptarium/mapping.js

@@ -5,8 +5,8 @@ import { RdDItemSort } from "../../item-sort.js"
 import { ITEM_TYPES } from "../../item.js"
 import { Misc } from "../../misc.js"
 import { RdDTimestamp } from "../../time/rdd-timestamp.js"
-import { TMRConstants } from "../../tmr-constants.js"
-import { TMRUtility } from "../../tmr-utility.js"
+import { RdDBonus } from "../../rdd-bonus.js"
+
 
 const CATEGORIES_COMPETENCES = [
   "generale",
@@ -53,6 +53,7 @@ const TABLEAU_SORTS = [...Array(NB_SORTS).keys()]
 const MAPPING_BASE = [
   { column: "ID", getter: (actor, context) => actor.id },
   { column: "name", getter: (actor, context) => actor.name },
+  { column: "metier", getter: (actor, context) => actor.system.metier },
   //    { column: "biographie", getter: (actor, context) => actor.system.biographie },
   { column: "taille", getter: (actor, context) => actor.system.carac.taille.value },
   { column: "apparence", getter: (actor, context) => actor.system.carac.apparence.value },
@@ -80,8 +81,8 @@ const MAPPING_BASE = [
   { column: "armure", getter: (actor, context) => Mapping.getArmure(actor, context) },
   { column: "protection", getter: (actor, context) => Mapping.getProtectionArmure(actor, context) },
   { column: "malus-armure", getter: (actor, context) => Mapping.getMalusArmure(actor, context) },
-  { column: "esquive", getter: (actor, context) => Mapping.getEsquive(actor, context) },
-  { column: "esquive-niv", getter: (actor, context) => Mapping.getEsquiveNiveau(context) },
+  { column: "esquive", getter: (actor, context) => Mapping.getEsquive(context) },
+  { column: "esquive-armure", getter: (actor, context) => Mapping.getEsquiveArmure(context) },
   { column: "competences", getter: (actor, context) => Mapping.getCompetences(actor, CATEGORIES_COMPETENCES) },
   { column: "draconic", getter: (actor, context) => Mapping.getCompetences(actor, CATEGORIES_DRACONIC) },
 ]
@@ -89,7 +90,7 @@ const MAPPING_BASE = [
 const MAPPING_ARMES = TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('name', i))
   .concat(TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('niveau', i)))
   .concat(TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('init', i)))
-  .concat(TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('dom', i)))
+  .concat(TABLEAU_ARMES.map(i => ColumnMappingFactory.createMappingArme('dommages', i)))
 const MAPPING_SORTS = TABLEAU_SORTS.map(i => ColumnMappingFactory.createMappingSort('voie', i))
   .concat(TABLEAU_SORTS.map(i => ColumnMappingFactory.createMappingSort('description', i)))
   .concat(TABLEAU_SORTS.map(i => ColumnMappingFactory.createMappingSort('bonus', i)))
@@ -113,29 +114,36 @@ export class Mapping {
   }
 
   static prepareArmes(actor) {
-    return actor.items.filter(it => it.type == ITEM_TYPES.arme)
-      .map(arme => {
-        // TODO: gestion armes 1 ou 2 mains
-        const compToUse = RdDItemArme.getCompetenceArme(arme, 'competence');
-        const comp = actor.getCompetence(compToUse);
-        const bonusDom = Mapping.calculBonusDom(comp, actor)
-        return {
-          name: arme.name,
-          niveau: comp.system.niveau,
-          init: Mapping.calculBaseInit(actor, comp.system.categorie) + comp.system.niveau,
-          dom: Number(arme.system.dommages) + bonusDom
-        };
-      });
+    const armes = actor.items.filter(it => it.type == ITEM_TYPES.arme)
+    return armes.map(arme =>
+      [
+        arme.system.tir != "" ? Mapping.prepareArme(actor, arme, 'tir') : undefined,
+        arme.system.lancer = "" ? Mapping.prepareArme(actor, arme, 'lancer') : undefined,
+        arme.system.unemain ? Mapping.prepareArme(actor, arme, 'unemain') : undefined,
+        arme.system.deuxmains ? Mapping.prepareArme(actor, arme, 'deuxmains') : undefined,
+        !(arme.system.unemain || arme.system.deuxmains) ? Mapping.prepareArme(actor, arme, 'competence') : undefined
+      ]
+        .filter(it => it != undefined)
+    ).reduce((a, b) => a.concat(b), [])
   }
 
-  static calculBonusDom(comp, actor) {
-    // TODO: reuse dmg calc?
-    const appliesBonusDom = ['melee', 'lancer'].includes(comp.system.categorie)
-    return appliesBonusDom ? Number(actor.system.attributs.plusdom.value) : 0
+  static prepareArme(actor, arme, maniement) {
+    const nameCompArme = RdDItemArme.getCompetenceArme(arme, maniement)
+    const competence = actor.getCompetence(nameCompArme)
+    if (RdDItemCompetence.isNiveauBase(competence)) {
+      return undefined
+    }
+    const dmgArme = RdDItemArme.dommagesReels(arme, maniement)
+    const dommages = dmgArme + RdDBonus.bonusDmg(actor, maniement, dmgArme)
+    return {
+      name: arme.name,
+      niveau: Misc.toSignedString(competence.system.niveau),
+      init: Mapping.calculBaseInit(actor, competence.system.categorie) + competence.system.niveau,
+      dommages: Misc.toSignedString(dommages)
+    }
   }
 
   static calculBaseInit(actor, categorie) {
-    // TODO: reuse init calc?
     const mapping = MAPPING_BASE.find(it => it.column == categorie)
     if (mapping) {
       switch (categorie) {
@@ -182,13 +190,15 @@ export class Mapping {
   }
 
   static prepareSorts(actor) {
-    return actor.itemTypes[ITEM_TYPES.sort].map(it => {
-      return {
-        voie: RdDItemSort.getCodeDraconic(it),
-        description: Mapping.descriptionSort(it),
-        bonus: Mapping.bonusCase(it)
-      }
-    })
+    return actor.itemTypes[ITEM_TYPES.sort].map(it => Mapping.prepareSort(it))
+  }
+
+  static prepareSort(sort) {
+    return {
+      voie: RdDItemSort.getCodeDraconic(sort),
+      description: Mapping.descriptionSort(sort),
+      bonus: Mapping.bonusCase(sort)
+    }
   }
 
   static descriptionSort(sort) {
@@ -198,11 +208,12 @@ export class Mapping {
   }
 
   static bonusCase(sort) {
-    const list = RdDItemSort.buildBonusCaseList(sort.system.bonuscase, false).sort(Misc.descending(it => it.bonus))
+    const list = RdDItemSort.bonuscaseStringToList(sort.system.bonuscase).sort(Misc.descending(it => it.bonus))
     if (list.length > 0) {
       const bonus = list[0]
       return `+${bonus.bonus}% en ${bonus.case}`
     }
+    return ''
   }
 
   static getDescription(actor) {
@@ -233,14 +244,16 @@ export class Mapping {
     return context?.armure?.malus ?? 0
   }
 
-  static getEsquive(actor, context) {
-    return context.esquive?.name ?? ''
+  static getEsquive(context) {
+    if (context.esquive) {
+      return Misc.toSignedString(context.esquive.niveau)
+    }
+    return ''
   }
-
-  static getEsquiveNiveau(context) {
+  static getEsquiveArmure(context) {
     if (context.esquive) {
       const niveau = context.esquive.niveau + context.armure.malus
-      return niveau > 0 ? ('+' + niveau) : ('' + niveau)
+      return Misc.toSignedString(niveau)
     }
     return ''
   }
@@ -260,9 +273,8 @@ export class Mapping {
         }
         const txtCategorieByNiveau = niveaux.map(niveau => {
           const names = Misc.join(byNiveau[niveau].map(it => it.name).sort(Misc.ascending()), ', ')
-          return names + ': ' + Misc.toSignedString(niveau)
-        }
-        )
+          return names + ' ' + Misc.toSignedString(niveau)
+        })
         const txtCategorie = Misc.join(txtCategorieByNiveau, ' / ')
         return txtCategorie
       }).filter(it => it != '')

module/actor/random/app-personnage-aleatoire.js

@@ -0,0 +1,183 @@
+import { SHOW_DICE } from "../../constants.js";
+import { Misc } from "../../misc.js";
+import { RdDCarac } from "../../rdd-carac.js";
+import { RdDDice } from "../../rdd-dice.js";
+import { RdDNameGen } from "../../rdd-namegen.js";
+import { RdDTimestamp } from "../../time/rdd-timestamp.js";
+
+const PATHS = [
+  'name',
+  'system.sexe',
+  'system.age',
+  'system.taille',
+  'system.poids',
+  'system.main',
+  'system.heure',
+  'system.cheveux',
+  'system.yeux'
+]
+
+const RANDOM_VALUES = {
+  'system.sexe': { 'masculin': 1, 'féminin': 1 },
+  'system.main': { 'droitier': 51, 'gaucher': 15, 'ambidectre': 6 },
+  'system.cheveux': { 'noirs': 2, 'bruns': 5, 'châtains clair': 5, 'blonds': 4, 'blonds très clair': 1, 'roux carotte': 1, 'roux cuivré': 3 },
+  'system.yeux': { 'noirs': 2, 'noisettes': 3, 'bruns vert': 4, 'verts': 3, 'bleus clair': 3, 'bleus gris': 2, 'gris': 1, 'mauves': 1, 'indigos': 1 },
+}
+
+export class AppPersonnageAleatoire extends FormApplication {
+
+  static get defaultOptions() {
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      template: "systems/foundryvtt-reve-de-dragon/templates/actor/random/app-personnage-aleatoire.hbs",
+      title: "Génération aléatoire",
+      width: 'fit-content',
+      height: 'fit-content',
+      classes: ['app-personnage-aleatoire'],
+      popOut: true,
+      resizable: true
+    }, { inplace: false })
+  }
+
+  constructor(actor) {
+    super({})
+    this.actor = actor
+    this.current = foundry.utils.duplicate(actor)
+    this.checked = {
+      'name': false,
+      'system.sexe': true,
+      'system.age': true,
+      'system.taille': true,
+      'system.poids': true,
+      'system.main': true,
+      'system.heure': true,
+      'system.cheveux': true,
+      'system.yeux': true
+    }
+  }
+
+  async getData(options) {
+    return foundry.utils.mergeObject(await super.getData(options), {
+      actor: this.actor,
+      current: this.current,
+      checked: this.checked,
+      options: { isGM: game.user.isGM }
+    })
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html)
+    this.html = html
+    this.html.find("button.button-cancel").click(async event => await this.close())
+    this.html.find("button.button-apply").click(async event => await this.onApply())
+    this.html.find("input.current-value").change(async event => await this.onChange(event))
+    this.html.find("div.random-field[data-path='system.heure'] select.current-value").change(async event => await this.onChange(event))
+    this.html.find("a.random").click(async event => await this.onRandom(event))
+    this.html.find("a.reset").click(async event => await this.onReset(event))
+    this.html.find("a.randomize-selected").click(async event => await this.onRandomizeSelected())
+    this.html.find("input.check-for-random").click(async event => await this.onCheckForRandom(event))
+  }
+  async _updateObject(event, formData) { }
+
+  async onApply() {
+    const updates = Object.fromEntries(
+      PATHS.filter(path => game.user.isGM || path != 'name')
+        .map(path => [path, this.current[path]])
+    )
+    await this.actor.update(updates)
+    await this.close()
+  }
+
+  getPath(selector) {
+    const fields = this.html.find(selector).parents("div.random-field:first")
+    return fields[0].attributes['data-path'].value
+  }
+
+  async onChange(event) {
+    const path = this.getPath(event.currentTarget)
+    this.current[path] = event.currentTarget.value
+  }
+
+  async onRandom(event) {
+    const path = this.getPath(event.currentTarget)
+    await this.setRandom(path);
+    this.render()
+  }
+
+  async onReset(event) {
+    const path = this.getPath(event.currentTarget)
+    this.current[path] = this.actor[path]
+    await this.render()
+  }
+
+  async onCheckForRandom(event) {
+    const path = this.getPath(event.currentTarget)
+    this.checked[path] = event.currentTarget.checked
+    this.render()
+  }
+
+  async onRandomizeSelected() {
+    const paths = this.html.find("input.check-for-random:checked")
+      .parents("div.random-field")
+      .toArray()
+      .map(it => it.attributes['data-path'].value)
+    await Promise.all(paths.map(path => this.setRandom(path)))
+    this.render()
+  }
+
+  async setRandom(path) {
+    this.current[path] = await this.random(path);
+  }
+
+  async random(path) {
+    switch (path) {
+      case 'name':
+        return await RdDNameGen.generate()
+      case 'system.sexe':
+      case 'system.main':
+      case 'system.cheveux':
+      case 'system.yeux':
+        return await this.randomFromMap(RANDOM_VALUES[path])
+      case 'system.poids':
+        return await this.randomPoids()
+      case 'system.taille':
+        return await this.randomTaille()
+      case 'system.age':
+        return await RdDDice.rollTotal('(2d4kl)*10 + 1d7xo + 2d20kl')
+      case 'system.heure':
+        return RdDTimestamp.defHeure(await RdDDice.rollHeure({ rollMode: "selfroll", showDice: SHOW_DICE })).key
+    }
+    return 'unknown'
+  }
+
+  async randomFromMap(valuesMap) {
+    const max = Object.values(valuesMap).reduce(Misc.sum(), 0)
+    const total = await RdDDice.rollTotal(`1d${max}`)
+    let sum = 0
+    for (let entry of Object.entries(valuesMap)) {
+      sum = sum + entry[1]
+      if (sum >= total) {
+        return entry[0]
+      }
+    }
+    return Object.keys(valuesMap)[0]
+  }
+
+  async randomPoids() {
+    const caracTaille = RdDCarac.getCaracDerivee(this.current.system.carac.taille.value)
+    const range = caracTaille.poidsMax - caracTaille.poidsMin + 1
+    const total = await RdDDice.rollTotal(`1d${range} + ${caracTaille.poidsMin}`)
+    return total + ' kg'
+  }
+
+  async randomTaille() {
+    const caracTaille = RdDCarac.getCaracDerivee(this.current.system.carac.taille.value)
+    const base = this.current.system.carac.taille.value * 2 + 60 + caracTaille.poidsMin
+    const variation = Math.floor((caracTaille.poidsMax - caracTaille.poidsMin + base / 5) / 2)
+    const total = await RdDDice.rollTotal(`2d${variation} + ${base}`)
+    const cm = total % 100
+    const m = (total - cm) / 100
+    return `${m}m${cm}`
+  }
+
+
+}

module/dialog-create-signedraconique.js

@@ -24,7 +24,7 @@ export class DialogCreateSigneDraconique extends Dialog {
   }
 
   constructor(dialogData, html) {
-    let options = { classes: ["DialogCreateSigneDraconiqueActorsActors"], width: 500, height: 650, 'z-index': 99999 };
+    let options = { classes: ["DialogCreateSigneDraconiqueActors"], width: 500, height: 650, 'z-index': 99999 };
     let conf = {
       title: "Créer un signe",
       content: html,

module/item-arme.js

@@ -33,12 +33,12 @@ export class RdDItemArme extends Item {
     return RdDItemArme.mainsNues();
   }
 
-  static getCompetenceArme(arme, competenceName) {
+  static getCompetenceArme(arme, maniement) {
     switch (arme.type) {
       case ITEM_TYPES.competencecreature:
         return arme.name
       case ITEM_TYPES.arme:
-        switch (competenceName) {
+        switch (maniement) {
           case 'competence': return arme.system.competence;
           case 'unemain': return RdDItemArme.competence1Mains(arme);
           case 'deuxmains': return RdDItemArme.competence2Mains(arme);
@@ -148,30 +148,32 @@ export class RdDItemArme extends Item {
     return true;
   }
 
-  /* -------------------------------------------- */
-  static armeUneOuDeuxMains(armeData, aUneMain) {
-    if (armeData && !armeData.system.cac) {
-      armeData.system.unemain = armeData.system.unemain || !armeData.system.deuxmains;
-      const uneOuDeuxMains = armeData.system.unemain && armeData.system.deuxmains;
-      const containsSlash = !Number.isInteger(armeData.system.dommages) && armeData.system.dommages.includes("/");
-      if (containsSlash) { // Sanity check
-        armeData = foundry.utils.duplicate(armeData);
-
-        const tableauDegats = armeData.system.dommages.split("/");
-        if (aUneMain)
-          armeData.system.dommagesReels = Number(tableauDegats[0]);
-        else // 2 mains
-          armeData.system.dommagesReels = Number(tableauDegats[1]);
-      }
-      else {
-        armeData.system.dommagesReels = Number(armeData.system.dommages);
-      }
-
-      if (uneOuDeuxMains != containsSlash) {
-        ui.notifications.info("Les dommages de l'arme à 1/2 mains " + armeData.name + " ne sont pas corrects (ie sous la forme X/Y)");
-      }
+  static dommagesReels(arme, maniement) {
+    switch (maniement) {
+      case 'tir':
+      case 'lancer':
+      case 'competence':
+        return Number(arme.system.dommages)
     }
-    return armeData;
+    if (arme.system.unemain && arme.system.deuxmains) {
+      const containsSlash = !Number.isInteger(arme.system.dommages) && arme.system.dommages.includes("/")
+      if (!containsSlash) {
+        ui.notifications.info("Les dommages de l'arme à 1/2 mains " + arme.name + " ne sont pas corrects (ie sous la forme X/Y)");
+        return Number(arme.system.dommages)
+      }
+      const tableauDegats = arme.system.dommages.split("/");
+      return Number(tableauDegats[maniement == 'unemain' ? 0 : 1])
+    }
+    return Number(arme.system.dommages);
+  }
+
+  /* -------------------------------------------- */
+  static armeUneOuDeuxMains(arme, aUneMain) {
+    if (arme && !arme.system.cac) {
+      arme = foundry.utils.duplicate(arme);
+      arme.system.dommagesReels = RdDItemArme.dommagesReels(arme, aUneMain ? 'unemain' : 'deuxmains')
+    }
+    return arme;
   }
 
   static competence1Mains(arme) {
@@ -197,7 +199,7 @@ export class RdDItemArme extends Item {
 
   static corpsACorps(actor) {
     let competence = actor?.getCompetenceCorpsACorps() ?? { system: { niveau: -6 } };
-    let melee = actor? actor.system.carac['melee'].value : 0
+    let melee = actor ? actor.system.carac['melee'].value : 0
     return {
       _id: competence?.id,
       name: 'Corps à corps',

module/item-competence.js

@@ -1,4 +1,5 @@
 import { Grammar } from "./grammar.js";
+import { RdDItem } from "./item.js";
 import { Misc } from "./misc.js";
 
 const competenceTroncs = [["Esquive", "Dague", "Corps à corps"],
@@ -23,12 +24,12 @@ const limitesArchetypes = [
 ];
 
 /* -------------------------------------------- */
-const categoriesCompetences = {
+export const CATEGORIES_COMPETENCES = {
   "generale": { base: -4, label: "Générales" },
   "particuliere": { base: -8, label: "Particulières" },
   "specialisee": { base: -11, label: "Spécialisées" },
   "connaissance": { base: -11, label: "Connaissances" },
-  "draconic": { base: -11, label: "Draconics" },
+  "draconic": { base: -11, label: "Draconic" },
   "melee": { base: -6, label: "Mêlée" },
   "tir": { base: -8, label: "Tir" },
   "lancer": { base: -8, label: "Lancer" }
@@ -48,16 +49,14 @@ function _buildCumulXP() {
 const competence_xp_cumul = _buildCumulXP();
 
 export class RdDItemCompetence extends Item {
-  /* -------------------------------------------- */
-  static getCategories() {
-    return categoriesCompetences;
-  }
   /* -------------------------------------------- */
   static getLabelCategorie(category) {
-    return categoriesCompetences[category].label;
+    return CATEGORIES_COMPETENCES[category].label;
   }
   /* -------------------------------------------- */
-  static getNiveauBase(category, categories = categoriesCompetences) {
+  /* -------------------------------------------- */
+  static getNiveauBase(category, itemType) {
+    let categories = RdDItem.getCategories(itemType)
     return categories[category]?.base ?? 0;
   }
 
@@ -191,7 +190,7 @@ export class RdDItemCompetence extends Item {
 
   /* -------------------------------------------- */
   static isNiveauBase(item) {
-    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie, item.getCategories());
+    return Number(item.system.niveau) == RdDItemCompetence.getNiveauBase(item.system.categorie, item.type);
   }
 
   /* -------------------------------------------- */

module/item-competencecreature.js

@@ -2,7 +2,7 @@
 import { ITEM_TYPES } from "./item.js";
 import { RdDCombatManager } from "./rdd-combat.js";
 
-const categories = {
+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" },
@@ -15,10 +15,6 @@ const categories = {
 /* -------------------------------------------- */
 export class RdDItemCompetenceCreature extends Item {
 
-  static getCategories() {
-    return categories;
-  }
-
   /* -------------------------------------------- */
   static setRollDataCreature(rollData) {
     rollData.carac = { "carac_creature": { label: rollData.competence.name, value: rollData.competence.system.carac_value } }

module/item-sheet.js

@@ -12,7 +12,7 @@ import { SystemCompendiums } from "./settings/system-compendiums.js";
 import { Misc } from "./misc.js";
 import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
-import { ITEM_TYPES } from "./item.js";
+import { ITEM_TYPES, RdDItem } from "./item.js";
 
 /**
  * Extend the basic ItemSheet for RdD specific items
@@ -107,7 +107,7 @@ export class RdDItemSheet extends ItemSheet {
     }
 
     const competences = await SystemCompendiums.getCompetences('personnage');
-    formData.categories = this.item.getCategories()
+    formData.categories = RdDItem.getCategories(this.item.type)
     if (this.item.type == 'tache' || this.item.type == 'livre' || this.item.type == 'meditation' || this.item.type == 'oeuvre') {
       formData.caracList = foundry.utils.duplicate(game.model.Actor.personnage.carac)
       formData.caracList["reve-actuel"] = foundry.utils.duplicate(game.model.Actor.personnage.reve.reve)
@@ -258,7 +258,7 @@ export class RdDItemSheet extends ItemSheet {
 
     if (this.item.isCompetence()) {
       const categorie = event.currentTarget.value;
-      const level = RdDItemCompetence.getNiveauBase(categorie, this.item.getCategories());
+      const level = RdDItemCompetence.getNiveauBase(categorie, this.item.type);
       this.item.system.base = level;
       this.html.find('[name="system.base"]').val(level);
     }

module/item-sort.js

@@ -5,11 +5,11 @@ import { Misc } from "./misc.js";
 import { TMRUtility } from "./tmr-utility.js";
 
 const VOIES_DRACONIC = [
-  { code: 'O', label: "Voie d'Oniros", short: 'Oniros'},
-  { code: 'H', label: "Voie d'Hypnos" , short:'Hypnos' },
+  { code: 'O', label: "Voie d'Oniros", short: 'Oniros' },
+  { code: 'H', label: "Voie d'Hypnos", short: 'Hypnos' },
   { code: 'N', label: "Voie de Narcos", short: 'Narcos' },
-  { code: 'T', label: "Voie de Thanatos", short:'Thanatos' },
-  { code: 'O/H/N/T', label: "Oniros/Hypnos/Narcos/Thanatos", short:'Oniros/Hypnos/Narcos/Thanatos' },
+  { code: 'T', label: "Voie de Thanatos", short: 'Thanatos' },
+  { code: 'O/H/N/T', label: "Oniros/Hypnos/Narcos/Thanatos", short: 'Oniros/Hypnos/Narcos/Thanatos' },
   { code: 'O/H/N', label: "Oniros/Hypnos/Narcos" }
 ]
 
@@ -65,9 +65,9 @@ export class RdDItemSort extends Item {
 
   /* -------------------------------------------- */
   static buildBonusCaseList(bonuscase, newCase) {
-    const list = RdDItemSort._bonuscaseStringToList(bonuscase)
+    const list = RdDItemSort.bonuscaseStringToList(bonuscase)
     if (newCase) {
-      return list.concat({ case: "Nouvelle", bonus: 0 });
+       list.push({ case: "Nouvelle", bonus: 0 })
     }
     return list;
   }
@@ -138,8 +138,11 @@ export class RdDItemSort extends Item {
       .sort(Misc.ascending())
       .join(',');
   }
-  static _bonuscaseStringToList(bonuscase) {
-    return (bonuscase ?? '').split(',').map(it => {
+  static bonuscaseStringToList(bonuscase) {
+    if (bonuscase == undefined || bonuscase == '') {
+      return []
+    }
+    return bonuscase.split(',').map(it => {
       const b = it.split(':');
       return { case: b[0], bonus: b[1] };
     });

module/item.js

@@ -6,8 +6,8 @@ import { RdDTimestamp } from "./time/rdd-timestamp.js";
 import { RdDUtility } from "./rdd-utility.js";
 import { SystemCompendiums } from "./settings/system-compendiums.js";
 import { RdDRaretes } from "./item/raretes.js";
-import { RdDItemCompetence } from "./item-competence.js";
-import { RdDItemCompetenceCreature } from "./item-competencecreature.js";
+import { CATEGORIES_COMPETENCES } from "./item-competence.js";
+import { CATEGORIES_COMPETENCES_CREATURES } from "./item-competencecreature.js";
 
 export const ACTOR_TYPES = {
   personnage: 'personnage',
@@ -172,9 +172,11 @@ export class RdDItem extends Item {
   static getItemTypesInventaire(mode = 'materiel') {
     return typesInventaire[mode ?? 'materiel']
   }
+
   static getItemTypesDraconiques() {
     return typesObjetsDraconiques;
   }
+
   static getItemTypesEnvironnement() {
     return typesEnvironnement;
   }
@@ -183,6 +185,16 @@ export class RdDItem extends Item {
     return typesObjetsOeuvres
   }
 
+  static getCategories(itemType) {
+    switch (itemType) {
+      case ITEM_TYPES.competence:
+        return CATEGORIES_COMPETENCES
+      case ITEM_TYPES.competencecreature:
+        return CATEGORIES_COMPETENCES_CREATURES
+    }
+    return {}
+  }
+
   constructor(docData, context = {}) {
     if (!context.rdd?.ready) {
       foundry.utils.mergeObject(context, { rdd: { ready: true } });
@@ -262,13 +274,6 @@ export class RdDItem extends Item {
   isPresentDansMilieux(milieux) {
     return this.getEnvironnements(milieux).length > 0
   }
-  getCategories() {
-    switch (this.type) {
-      case ITEM_TYPES.competence: return RdDItemCompetence.getCategories()
-      case ITEM_TYPES.competencecreature: return RdDItemCompetenceCreature.getCategories()
-    }
-    return {}
-  }
 
   getEnvironnements(milieux = undefined) {
     const environnements = this.isInventaire() ? this.system.environnement : undefined;

module/rdd-bonus.js

@@ -31,8 +31,8 @@ export class RdDBonus {
   }
 
   /* -------------------------------------------- */
-  static dmg(rollData, dmgActor, isEntiteIncarnee = false) {
-    const dmgArme = RdDBonus._dmgArme(rollData)
+  static dmg(rollData, actor, isEntiteIncarnee = false) {
+    const dmgArme = RdDBonus.dmgArme(rollData.arme)
     let dmg = {
       total: 0,
       dmgArme: dmgArme,
@@ -41,7 +41,7 @@ export class RdDBonus {
       dmgParticuliere: RdDBonus._dmgParticuliere(rollData),
       dmgSurprise: RdDBonus.dmgBonus(rollData.ajustements?.attaqueDefenseurSurpris.used),
       mortalite: RdDBonus._calculMortalite(rollData, isEntiteIncarnee),
-      dmgActor: RdDBonus._dmgPerso(dmgActor, rollData.selectedCarac?.label, dmgArme)
+      dmgActor: RdDBonus.bonusDmg(actor, rollData.selectedCarac?.label.toLowerCase(), dmgArme)
     }
     dmg.total = dmg.dmgSurprise + dmg.dmgTactique + dmg.dmgArme + dmg.dmgActor + dmg.dmgParticuliere;
     return dmg;
@@ -71,11 +71,11 @@ export class RdDBonus {
   }
 
   /* -------------------------------------------- */
-  static _dmgArme(rollData) {
-    if (rollData.arme) {
-      let dmgBase = rollData.arme.system.dommagesReels ?? Number(rollData.arme.system.dommages ?? 0);
+  static dmgArme(arme) {
+    if (arme) {
+      let dmgBase = arme.system.dommagesReels ?? 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, rollData.arme.system.magique ? rollData.arme.system.ecaille_efficacite : 0);
+      return dmgBase + Math.min(dmgBase, arme.system.magique ? arme.system.ecaille_efficacite : 0);
     }
     return 0;
   }
@@ -86,13 +86,14 @@ export class RdDBonus {
   }
 
   /* -------------------------------------------- */
-  static _dmgPerso(dmgActor, categorie, dmgArme) {
+  static bonusDmg(actor, categorie, dmgArme) {
+    const dmgActor = actor.getBonusDegat()
     if (categorie == undefined) {
       return 0
     }
     switch (categorie) {
-      case "Tir": return 0;
-      case "Lancer": return Math.max(0, Math.min(dmgArme, dmgActor));
+      case "tir": return 0;
+      case "lancer": return Math.max(0, Math.min(dmgArme, dmgActor));
     }
     return dmgActor;
   }

module/rdd-carac.js

@@ -3,38 +3,38 @@ import { Misc } from "./misc.js";
 
 const TABLE_CARACTERISTIQUES_DERIVEES = {
   // xp: coût pour passer du niveau inférieur à ce niveau
-  1: { xp: 3, poids: "moins de 1kg", plusdom: -5, sconst: 0.5, sust: 0.1 },
-  2: { xp: 3, poids: "1-5", plusdom: -4, sconst: 0.5, sust: 0.3 },
-  3: { xp: 4, poids: "6-10", plusdom: -3, sconst: 1, sust: 0.5, beaute: 'hideux' },
-  4: { xp: 4, poids: "11-20", plusdom: -3, sconst: 1, sust: 1, beaute: 'repoussant' },
-  5: { xp: 5, poids: "21-30", plusdom: -2, sconst: 1, sust: 1, beaute: 'franchement très laid' },
-  6: { xp: 5, poids: "31-40", plusdom: -1, sconst: 2, sust: 2, beaute: 'laid' },
-  7: { xp: 6, poids: "41-50", plusdom: -1, sconst: 2, sust: 2, beaute: 'très désavantagé' },
-  8: { xp: 6, poids: "51-60", plusdom: 0, sconst: 2, sust: 2, beaute: 'désavantagé' },
-  9: { xp: 7, poids: "61-65", plusdom: 0, sconst: 3, sust: 2, beaute: 'pas terrible' },
-  10: { xp: 7, poids: "66-70", plusdom: 0, sconst: 3, sust: 3, beaute: 'commun' },
-  11: { xp: 8, poids: "71-75", plusdom: 0, sconst: 3, sust: 3, beaute: 'pas mal' },
-  12: { xp: 8, poids: "76-80", plusdom: +1, sconst: 4, sust: 3, beaute: 'avantagé' },
-  13: { xp: 9, poids: "81-90", plusdom: +1, sconst: 4, sust: 3, beaute: 'mignon' },
-  14: { xp: 9, poids: "91-100", plusdom: +2, sconst: 4, sust: 4, beaute: 'beau' },
-  15: { xp: 10, poids: "101-110", plusdom: +2, sconst: 5, sust: 4, beaute: 'très beau' },
-  16: { xp: 20, poids: "111-120", plusdom: +3, sconst: 5, sust: 4, beaute: 'éblouissant' },
-  17: { xp: 30, poids: "121-131", plusdom: +3, sconst: 5, sust: 5 },
-  18: { xp: 40, poids: "131-141", plusdom: +4, sconst: 6, sust: 5 },
-  19: { xp: 50, poids: "141-150", plusdom: +4, sconst: 6, sust: 5 },
-  20: { xp: 60, poids: "151-160", plusdom: +4, sconst: 6, sust: 6 },
-  21: { xp: 70, poids: "161-180", plusdom: +5, sconst: 7, sust: 6 },
-  22: { xp: 80, poids: "181-200", plusdom: +5, sconst: 7, sust: 7 },
-  23: { xp: 90, poids: "201-300", plusdom: +6, sconst: 7, sust: 8 },
-  24: { xp: 100, poids: "301-400", plusdom: +6, sconst: 8, sust: 9 },
-  25: { xp: 110, poids: "401-500", plusdom: +7, sconst: 8, sust: 10 },
-  26: { xp: 120, poids: "501-600", plusdom: +7, sconst: 8, sust: 11 },
-  27: { xp: 130, poids: "601-700", plusdom: +8, sconst: 9, sust: 12 },
-  28: { xp: 140, poids: "701-800", plusdom: +8, sconst: 9, sust: 13 },
-  29: { xp: 150, poids: "801-900", plusdom: +9, sconst: 9, sust: 14 },
-  30: { xp: 160, poids: "901-1000", plusdom: +9, sconst: 10, sust: 15 },
-  31: { xp: 170, poids: "1001-1500", plusdom: +10, sconst: 10, sust: 16 },
-  32: { xp: 180, poids: "1501-2000", plusdom: +11, sconst: 10, sust: 17 }
+  1: { xp: 3, poids: "moins de 1kg", poidsMin: 0, poidsMax: 1, plusdom: -5, sconst: 0.5, sust: 0.1 },
+  2: { xp: 3, poids: "1-5", poidsMin: 1, poidsMax: 5, plusdom: -4, sconst: 0.5, sust: 0.3 },
+  3: { xp: 4, poids: "6-10", poidsMin: 6, poidsMax: 10, plusdom: -3, sconst: 1, sust: 0.5, beaute: 'hideux' },
+  4: { xp: 4, poids: "11-20", poidsMin: 11, poidsMax: 20, plusdom: -3, sconst: 1, sust: 1, beaute: 'repoussant' },
+  5: { xp: 5, poids: "21-30", poidsMin: 21, poidsMax: 30, plusdom: -2, sconst: 1, sust: 1, beaute: 'franchement très laid' },
+  6: { xp: 5, poids: "31-40", poidsMin: 31, poidsMax: 40, plusdom: -1, sconst: 2, sust: 2, beaute: 'laid' },
+  7: { xp: 6, poids: "41-50", poidsMin: 41, poidsMax: 50, plusdom: -1, sconst: 2, sust: 2, beaute: 'très désavantagé' },
+  8: { xp: 6, poids: "51-60", poidsMin: 51, poidsMax: 60, plusdom: 0, sconst: 2, sust: 2, beaute: 'désavantagé' },
+  9: { xp: 7, poids: "61-65", poidsMin: 61, poidsMax: 65, plusdom: 0, sconst: 3, sust: 2, beaute: 'pas terrible' },
+  10: { xp: 7, poids: "66-70", poidsMin: 66, poidsMax: 70, plusdom: 0, sconst: 3, sust: 3, beaute: 'commun' },
+  11: { xp: 8, poids: "71-75", poidsMin: 71, poidsMax: 75, plusdom: 0, sconst: 3, sust: 3, beaute: 'pas mal' },
+  12: { xp: 8, poids: "76-80", poidsMin: 76, poidsMax: 80, plusdom: +1, sconst: 4, sust: 3, beaute: 'avantagé' },
+  13: { xp: 9, poids: "81-90", poidsMin: 81, poidsMax: 90, plusdom: +1, sconst: 4, sust: 3, beaute: 'mignon' },
+  14: { xp: 9, poids: "91-100", poidsMin: 91, poidsMax: 100, plusdom: +2, sconst: 4, sust: 4, beaute: 'beau' },
+  15: { xp: 10, poids: "101-110", poidsMin: 101, poidsMax: 110, plusdom: +2, sconst: 5, sust: 4, beaute: 'très beau' },
+  16: { xp: 20, poids: "111-120", poidsMin: 111, poidsMax: 120, plusdom: +3, sconst: 5, sust: 4, beaute: 'éblouissant' },
+  17: { xp: 30, poids: "121-131", poidsMin: 121, poidsMax: 131, plusdom: +3, sconst: 5, sust: 5 },
+  18: { xp: 40, poids: "131-141", poidsMin: 131, poidsMax: 141, plusdom: +4, sconst: 6, sust: 5 },
+  19: { xp: 50, poids: "141-150", poidsMin: 141, poidsMax: 150, plusdom: +4, sconst: 6, sust: 5 },
+  20: { xp: 60, poids: "151-160", poidsMin: 151, poidsMax: 160, plusdom: +4, sconst: 6, sust: 6 },
+  21: { xp: 70, poids: "161-180", poidsMin: 161, poidsMax: 180, plusdom: +5, sconst: 7, sust: 6 },
+  22: { xp: 80, poids: "181-200", poidsMin: 181, poidsMax: 200, plusdom: +5, sconst: 7, sust: 7 },
+  23: { xp: 90, poids: "201-300", poidsMin: 201, poidsMax: 300, plusdom: +6, sconst: 7, sust: 8 },
+  24: { xp: 100, poids: "301-400", poidsMin: 301, poidsMax: 400, plusdom: +6, sconst: 8, sust: 9 },
+  25: { xp: 110, poids: "401-500", poidsMin: 401, poidsMax: 500, plusdom: +7, sconst: 8, sust: 10 },
+  26: { xp: 120, poids: "501-600", poidsMin: 501, poidsMax: 600, plusdom: +7, sconst: 8, sust: 11 },
+  27: { xp: 130, poids: "601-700", poidsMin: 601, poidsMax: 700, plusdom: +8, sconst: 9, sust: 12 },
+  28: { xp: 140, poids: "701-800", poidsMin: 701, poidsMax: 800, plusdom: +8, sconst: 9, sust: 13 },
+  29: { xp: 150, poids: "801-900", poidsMin: 801, poidsMax: 900, plusdom: +9, sconst: 9, sust: 14 },
+  30: { xp: 160, poids: "901-1000", poidsMin: 901, poidsMax: 1000, plusdom: +9, sconst: 10, sust: 15 },
+  31: { xp: 170, poids: "1001-1500", poidsMin: 1001, poidsMax: 1500, plusdom: +10, sconst: 10, sust: 16 },
+  32: { xp: 180, poids: "1501-2000", poidsMin: 1501, poidsMax: 2000, plusdom: +11, sconst: 10, sust: 17 }
 };
 
 export class RdDCarac {

module/rdd-combat.js

@@ -864,7 +864,7 @@ export class RdDCombat {
   async _onAttaqueNormale(attackerRoll) {
     console.log("RdDCombat.onAttaqueNormale >>>", attackerRoll);
 
-    attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker.getBonusDegat(), this.defender.isEntite());
+    attackerRoll.dmg = RdDBonus.dmg(attackerRoll, this.attacker, this.defender.isEntite());
     let defenderRoll = { attackerRoll: attackerRoll, passeArme: attackerRoll.passeArme, show: {} }
     attackerRoll.show = {
       cible: this.target ? this.defender.name : 'la cible',

module/rdd-commands.js

@@ -81,7 +81,7 @@ export class RdDCommands {
 
     this.registerCommand({ path: ["/sommeil"], func: (content, msg, params) => this.sommeil(msg, params), descr: "Prépare le passage de journée pour chateau dormant" });
     this.registerCommand({ path: ["/meteo"], func: (content, msg, params) => this.getMeteo(msg, params), descr: "Propose une météo marine" });
-    this.registerCommand({ path: ["/nom"], func: (content, msg, params) => RdDNameGen.getName(msg, params), descr: "Génère un nom aléatoire" });
+    this.registerCommand({ path: ["/nom"], func: (content, msg, params) => RdDNameGen.proposeName(msg, params), descr: "Génère un nom aléatoire" });
 
     this.registerCommand({
       path: ["/tmr"], func: (content, msg, params) => this.findTMR(msg, params),

module/rdd-dice.js

@@ -132,6 +132,10 @@ export class RdDDice {
     }
   }
 
+  static async rollHeure(options = { showDice: HIDE_DICE }) {
+    return await RdDDice.rollTotal("1dh", options) - 1
+  }
+
   static async rollTotal(formula, options = { showDice: HIDE_DICE }) {
     return (await RdDDice.roll(formula, options)).total;
   }

module/rdd-main.js

@@ -64,7 +64,7 @@ import { RdDItemArmure } from "./item/armure.js"
 import { AutoAdjustDarkness as AutoAdjustDarkness } from "./time/auto-adjust-darkness.js"
 import { RdDCreature } from "./actor/creature.js"
 import { RdDTMRDialog } from "./rdd-tmr-dialog.js"
-import { RdDActorExportSheet } from "./actor/actor-export-sheet.js"
+//import { RdDActorExportSheet } from "./actor/actor-export-sheet.js"
 import { OptionsAvancees } from "./settings/options-avancees.js"
 import { ExportScriptarium } from "./actor/export-scriptarium/export-scriptarium.js"
 
@@ -158,7 +158,7 @@ export class SystemReveDeDragon {
     // Register sheet application classes
     Actors.unregisterSheet("core", ActorSheet)
     Actors.registerSheet(SYSTEM_RDD, RdDCommerceSheet, { types: ["commerce"], makeDefault: true })
-    Actors.registerSheet(SYSTEM_RDD, RdDActorExportSheet, { types: ["personnage"], makeDefault: false })
+    //Actors.registerSheet(SYSTEM_RDD, RdDActorExportSheet, { types: ["personnage"], makeDefault: false })
     Actors.registerSheet(SYSTEM_RDD, RdDActorSheet, { types: ["personnage"], makeDefault: true })
     Actors.registerSheet(SYSTEM_RDD, RdDCreatureSheet, { types: ["creature"], makeDefault: true })
     Actors.registerSheet(SYSTEM_RDD, RdDActorVehiculeSheet, { types: ["vehicule"], makeDefault: true })

module/rdd-namegen.js

@@ -11,13 +11,17 @@ const words = ['pore', 'pre', 'flor', 'lane', 'turlu', 'pin', 'a', 'alph', 'i',
 /* -------------------------------------------- */
 export class RdDNameGen {
 
-  static async getName(msg, params) {
+  static async proposeName(msg, params) {
     const html = await renderTemplate(`systems/foundryvtt-reve-de-dragon/templates/chat-command-nom.html`, {
-      nom: Misc.upperFirst(await RdDDice.rollOneOf(words) + await RdDDice.rollOneOf(words))
+      nom: await RdDNameGen.generate()
     });
     ChatMessage.create({ content: html, whisper: ChatMessage.getWhisperRecipients("GM") });
   }
 
+  static async generate() {
+    return Misc.upperFirst(await RdDDice.rollOneOf(words) + await RdDDice.rollOneOf(words));
+  }
+
   static async onCreerActeur(event) {
     const button = event.currentTarget;
     await RdDBaseActor.create({

module/rdd-roll.js

@@ -307,7 +307,7 @@ export class RdDRoll extends Dialog {
   async updateRollResult(html) {
     const rollData = this.rollData;
 
-    rollData.dmg = rollData.attackerRoll?.dmg ?? RdDBonus.dmg(rollData, this.actor.getBonusDegat())
+    rollData.dmg = rollData.attackerRoll?.dmg ?? RdDBonus.dmg(rollData, this.actor)
     rollData.caracValue = parseInt(rollData.selectedCarac.value)
     rollData.dmg.mortalite = rollData.dmg.mortalite ?? 'mortel';
     rollData.use.appelAuMoral = this.actor.isPersonnage() && RdDCarac.isActionPhysique(rollData.selectedCarac);

module/rdd-utility.js

@@ -169,6 +169,7 @@ export class RdDUtility {
       'systems/foundryvtt-reve-de-dragon/templates/actor/liens-vehicules.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire.html',
       'systems/foundryvtt-reve-de-dragon/templates/actor/commerce-inventaire-item.html',
+      'systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs',
       //Items
       'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete-script.hbs',
       'systems/foundryvtt-reve-de-dragon/templates/scripts/autocomplete.hbs',

module/time/rdd-calendrier.js

@@ -227,7 +227,7 @@ export class RdDCalendrier extends Application {
 
   /* -------------------------------------------- */
   async ajouterNombreAstral(indexDate) {
-    const nombreAstral = await RdDDice.rollTotal("1dh", { showDice: HIDE_DICE, rollMode: "selfroll" });
+    const nombreAstral = await RdDDice.rollHeure( { showDice: HIDE_DICE, rollMode: "selfroll" });
     return {
       nombreAstral: nombreAstral,
       lectures: [],

system.json

@@ -1,8 +1,8 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "12.0.9",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-12.0.9.zip",
+  "version": "12.0.11",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-12.0.11.zip",
   "manifest": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/v11/system.json",
   "changelog": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/raw/branch/v11/changelog.md",
   "compatibility": {
@@ -534,6 +534,7 @@
   },
   "primaryTokenAttribute": "sante.vie",
   "secondaryTokenAttribute": "sante.endurance",
+  "background": "systems/foundryvtt-reve-de-dragon/styles/img/reve-de-dragon-cover.webp",
   "media": [
     {
       "type": "icon",

template.json

@@ -15,6 +15,7 @@
         }
       },
       "background": {
+        "metier": "",
         "biographie": "Histoire personnelle...",
         "notes": "Notes",
         "notesmj": "Notes du MJ",

templates/actor-sheet.html

@@ -172,6 +172,10 @@
               <label for="system.poids">Poids :</label>
               <input class="flex-grow" type="text" name="system.poids" value="{{system.poids}}" data-dtype="String"/>
             </li>
+            <li class="item flexrow list-item">
+              <label for="system.metier">Métier :</label>
+              <input class="flex-grow" type="text" name="system.metier" value="{{system.metier}}" data-dtype="String"/>
+            </li>
           </ul>
           <ul class="item-list alterne-list">
             <li class="item flexrow list-item">
@@ -201,6 +205,7 @@
               <label for="system.yeux">Yeux :</label>
               <input class="flex-grow" type="text" name="system.yeux" value="{{system.yeux}}" data-dtype="String"/>
             </li>
+            <a class="chat-card-button description-aleatoire" data-tooltip="Déterminer aléatoirement les détails de description">Description <i class="fa-solid fa-dice-d20"></i></a>
           </ul>
         </article>
 

templates/actor/random/app-personnage-aleatoire.hbs

@@ -0,0 +1,53 @@
+<form class="app-personnage-aleatoire">
+  <h2>Génération aléatoire pour {{actor.name}}</h2>
+  <div class="flex-group-left">
+    {{#if options.isGM}}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Nom" path="name" type="text" value=current.name checked=checked.name
+    }}
+    {{/if}}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Sexe" path="system.sexe" type="text"
+      value=current.system.sexe checked=checked.system.sexe
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Age" path="system.age" type="entier" min=10 max=100
+      value=current.system.age checked=checked.system.age
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Taille" path="system.taille" type="text"
+      value=current.system.taille checked=checked.system.taille
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Poids" path="system.poids" type="text"
+      value=current.system.poids checked=checked.system.poids
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Main directrice" path="system.main" type="text"
+      value=current.system.main checked=checked.system.main
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Heure de naissance" path="system.heure" type="heure"
+      value=current.system.heure checked=checked.system.heure
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Cheveux" path="system.cheveux" type="text"
+      value=current.system.cheveux checked=checked.system.cheveux
+    }}
+    {{>"systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs"
+      label="Yeux" path="system.yeux" type="text"
+      value=current.system.yeux checked=checked.system.yeux
+    }}
+  </div>
+  <hr>
+  <div style="text-align: right;">
+    <a class="chat-card-button randomize-selected">Générer les valeurs sélectionnés</a>
+  </div>
+  <br>
+  <div class="flexrow">
+  <button class="button-cancel">Annuler</button>
+  <button class="button-apply">Appliquer à {{actor.name}}</button>
+  </div>
+  <br>
+</form>
+

templates/actor/random/champ-aleatoire.hbs

@@ -0,0 +1,19 @@
+<div class="flexrow random-field" data-path="{{path}}">
+  <label for="{{path}}">{{label}}:</label>
+  {{#if (eq type 'entier')}}
+  <input class="current-value" name="current.{{path}}" value="{{value}}" placeholder="{{label}}" type="number" data-dtype="Number" min="{{min}}" max="{{max}}"/>
+  {{else if (eq type 'heure')}}
+  <select class="current-value" name="current.{{path}}" value="{{value}}" type="text" data-dtype="String">
+    {{#select value}}
+    {{> "systems/foundryvtt-reve-de-dragon/templates/enum-heures.html"}}
+    {{/select}}
+  </select>
+  {{else}}
+  <input class="current-value" name="current.{{path}}" value="{{value}}" placeholder="{{label}}" type="text" data-dtype="String"/>
+  {{/if}}
+  <div class="item-controls">
+    <a class="random" data-action="random" data-tooltip="Aléatoire"><i class="fa-solid fa-dice-d20"></i></a>
+    <a class="reset" data-action="reset" data-tooltip="Reset"><i class="fa-solid fa-eraser"></i></a>
+    <input class="check-for-random" type="checkbox" data-tooltip="Sélectionné pour génération automatique" {{#if checked}}checked{{/if}}/>
+  </div>
+</div>