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

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

changelog.md

@@ -1,4 +1,32 @@
 # 12.0
+## 12.0.14 - Les légions d'Astrobazzarh
+- Feuille de PNJ:
+  - boutons standard (encaissement, ...)
+  - boutons pour ajuster les compteurs
+  - visualisation des blessures
+  - click sur blessure pour ajouter/enlever
+  - gestion des armes
+
+## 12.0.13 - La Chance d'Astrobazzarh
+- Fix: jets de caractéristiques
+
+## 12.0.12 - L'étalage d'Astrobazzarh
+- Fix: On peut de nouveau vendre des items sans propriétaire, depuis les compendiums ou depuis l'onglet des Objets
+- Début de Feuille PNJ au format des encarts Scriptarium
+  - support des jets de caractéristiques
+  - support des jets de compétences
+
+## 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/achat-vente/dialog-item-vente.js

@@ -9,7 +9,7 @@ export class DialogItemVente extends Dialog {
     const venteData = {
       item: item,
       alias: item.actor?.name ?? game.user.name,
-      vendeurId: item.actor.id,
+      vendeurId: item.actor?.id,
       prixOrigine: item.calculerPrixCommercant(),
       prixUnitaire: item.calculerPrixCommercant(),
       prixLot: item.calculerPrixCommercant(),

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";
 
 /* -------------------------------------------- */
 /**
@@ -127,7 +128,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
       this.render(true);
     });
 
-    this.html.find('.visu-tmr').click(async event => this.actor.displayTMR("visu"))
+    this.html.find('.button-tmr-visu').click(async event => this.actor.displayTMR("visu"))
 
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
@@ -185,7 +186,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     this.html.find('.item-equip').click(async event => this.actor.equiperObjet(RdDSheetUtility.getItemId(event)))
     this.html.find('.chance-actuelle').click(async event => this.actor.rollCarac('chance-actuelle'))
 
-    this.html.find('.chance-appel').click(async event => this.actor.rollAppelChance())
+    this.html.find('.button-appel-chance').click(async event => this.actor.rollAppelChance())
 
     this.html.find('[name="jet-astrologie"]').click(async event => this.actor.astrologieNombresAstraux())
     this.html.find('.tache-label a').click(async event => this.actor.rollTache(RdDSheetUtility.getItemId(event)))
@@ -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 => {
@@ -216,9 +218,9 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     }
 
     // Points de reve actuel
-    this.html.find('.ptreve-actuel a').click(async event => this.actor.rollCarac('reve-actuel', true))
+    this.html.find('.roll-reve-actuel').click(async event => this.actor.rollCarac('reve-actuel', true))
     this.html.find('.empoignade-label a').click(async event => RdDEmpoignade.onAttaqueEmpoignadeFromItem(RdDSheetUtility.getItem(event, this.actor)))
-    this.html.find('.arme-label a').click(async event => this.actor.rollArme(foundry.utils.duplicate(this._getEventArmeCombat(event))))
+    this.html.find('.roll-arme').click(async event => this.actor.rollArme(foundry.utils.duplicate(this._getEventArmeCombat(event))))
 
     // Initiative pour l'arme
     this.html.find('.arme-initiative a').click(async event => {
@@ -232,10 +234,10 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     });
     // Display TMR
 
-    this.html.find('.monte-tmr').click(async event => this.actor.displayTMR("normal"))
-    this.html.find('.monte-tmr-rapide').click(async event => this.actor.displayTMR("rapide"))
+    this.html.find('.button-tmr').click(async event => this.actor.displayTMR("normal"))
+    this.html.find('.button-tmr-rapide').click(async event => this.actor.displayTMR("rapide"))
 
-    this.html.find('.repos').click(async event => await this.actor.repos())
+    this.html.find('.button-repos').click(async event => await this.actor.repos())
 
     this.html.find('.carac-xp-augmenter').click(async event => this.actor.updateCaracXPAuto(event.currentTarget.name.replace("augmenter.", "")))
     this.html.find('.competence-xp-augmenter').click(async event => this.actor.updateCompetenceXPAuto(RdDSheetUtility.getItemId(event)))
@@ -277,7 +279,7 @@ export class RdDActorSheet extends RdDBaseActorSangSheet {
     this.html.find('.moral-malheureux').click(async event => this.actor.jetDeMoral('malheureuse'))
     this.html.find('.moral-neutre').click(async event => this.actor.jetDeMoral('neutre'))
     this.html.find('.moral-heureux').click(async event => this.actor.jetDeMoral('heureuse'))
-    this.html.find('.ethylisme-test').click(async event => this.actor.jetEthylisme())
+    this.html.find('.button-ethylisme').click(async event => this.actor.jetEthylisme())
 
     this.html.find('.ptreve-actuel-plus').click(async event => this.actor.reveActuelIncDec(1))
     this.html.find('.ptreve-actuel-moins').click(async event => this.actor.reveActuelIncDec(-1))

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-reve-sheet.js

@@ -24,14 +24,15 @@ export class RdDBaseActorReveSheet extends RdDBaseActorSheet {
     // Everything below here is only needed if the sheet is editable
     if (!this.options.editable) return;
 
-    this.html.find('.encaisser-direct').click(async event => this.actor.encaisser())
-    this.html.find('.carac-label a').click(async event => this.actor.rollCarac(Grammar.toLowerCaseNoAccent(event.currentTarget.attributes.name.value)));
-    this.html.find('a.competence-label').click(async event => this.actor.rollCompetence(RdDSheetUtility.getItemId(event)));
+    this.html.find('.button-encaissement').click(async event => this.actor.encaisser())
+    this.html.find('.roll-carac').click(async event => {
+      this.actor.rollCarac(Grammar.toLowerCaseNoAccent(event.currentTarget.attributes['data-carac-name'].value))});
+    this.html.find('.roll-competence').click(async event => this.actor.rollCompetence(RdDSheetUtility.getItemId(event)));
     this.html.find('.endurance-plus').click(async event => this.actor.santeIncDec("endurance", 1));
     this.html.find('.endurance-moins').click(async event => this.actor.santeIncDec("endurance", -1));
 
     if (game.user.isGM) {
-      this.html.find('.remise-a-neuf').click(async event => this.actor.remiseANeuf())
+      this.html.find('.button-remise-a-neuf').click(async event => this.actor.remiseANeuf())
       this.html.find('.delete-active-effect').click(async event => this.actor.removeEffect(this.html.find(event.currentTarget).parents(".active-effect").data('effect')));
       this.html.find('.enlever-tous-effets').click(async event => await this.actor.removeEffects());
     }

module/actor/base-actor-reve.js

@@ -296,8 +296,12 @@ export class RdDBaseActorReve extends RdDBaseActor {
 
   /* -------------------------------------------- */
   async rollCarac(caracName, jetResistance = undefined) {
+    if (Grammar.equalsInsensitive(caracName, 'taille')){
+      return
+    }
     RdDEmpoignade.checkEmpoignadeEnCours(this)
     let selectedCarac = this.getCaracByName(caracName)
+    console.log("selectedCarac", selectedCarac)
     await this.openRollDialog({
       name: 'jet-' + caracName,
       label: 'Jet ' + Grammar.apostrophe('de', selectedCarac.label),

module/actor/base-actor-sang.js

@@ -180,7 +180,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
       }
     }
     const endActuelle = this.getEnduranceActuelle();
-    const blessure = await RdDItemBlessure.createBlessure(this, encaissement.gravite, encaissement.dmg.loc.label, attacker);
+    const blessure = await RdDItemBlessure.createBlessure(this, encaissement.gravite, encaissement.dmg?.loc.label ??'', attacker);
     if (blessure.isCritique()) {
       encaissement.endurance = endActuelle;
     }
@@ -196,6 +196,13 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
     return blessure;
   }
 
+  async supprimerBlessure({gravite}) {
+    const toDelete = this.itemTypes[ITEM_TYPES.blessure].find(it => it.system.gravite == gravite)?.id
+    if (toDelete){
+      await this.deleteEmbeddedDocuments('Item', [toDelete]);
+    }
+  }
+
   async supprimerBlessures(filterToDelete) {
     const toDelete = this.filterItems(filterToDelete, ITEM_TYPES.blessure)
       .map(it => it.id);
@@ -203,7 +210,7 @@ export class RdDBaseActorSang extends RdDBaseActorReve {
   }
 
   countBlessures(filter = it => !it.isContusion()) {
-    return this.filterItems(filter, 'blessure').length
+    return this.filterItems(filter, ITEM_TYPES.blessure).length
   }
 
   /* -------------------------------------------- */

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

@@ -0,0 +1,115 @@
+import { RdDActorSheet } from "../../actor-sheet.js"
+import { SYSTEM_RDD } from "../../constants.js";
+import { Misc } from "../../misc.js";
+import { EXPORT_CSV_SCRIPTARIUM, OptionsAvancees } from "../../settings/options-avancees.js";
+import { ExportScriptarium } from "./export-scriptarium.js";
+import { CATEGORIES_COMPETENCES, CATEGORIES_DRACONIC, Mapping } from "./mapping.js";
+
+export class RdDActorExportSheet extends RdDActorSheet {
+  static async init() {
+    await loadTemplates([
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/arme.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessures.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-compteur.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee-compteur.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/competences.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/esquive.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/fatigue.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/protection.hbs",
+      "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs",
+    ])
+    Actors.registerSheet(SYSTEM_RDD, RdDActorExportSheet, { types: ["personnage"], makeDefault: false, label: "Feuille simplifiée" })
+  }
+  static get defaultOptions() {
+    return foundry.utils.mergeObject(RdDActorSheet.defaultOptions, {
+      template: "systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/actor-encart-sheet.hbs",
+      width: 550,
+      showCompNiveauBase: false,
+      vueArchetype: false,
+    }, { inplace: false })
+  }
+
+  constructor(actor, options) {
+    super(actor, options)
+  }
+
+  async getData() {
+    const formData = await super.getData()
+    // Add any structured, precomputed list of data
+    formData.context = Mapping.prepareContext(this.actor)
+    formData.export = this.getMappingValues(formData.context, this.actor)
+    formData.competences = this.getCompetences(CATEGORIES_COMPETENCES)
+    formData.draconic = this.getCompetences(CATEGORIES_DRACONIC)
+    const legeres = this.actor.nbBlessuresLegeres()
+    const graves = this.actor.nbBlessuresGraves()
+    const critiques = this.actor.nbBlessuresCritiques()
+    formData.etat = {
+      surenc: this.actor.computeMalusSurEncombrement(),
+      fatigue: {
+        value: this.actor.getFatigueActuelle(),
+        max: this.actor.getFatigueMax(),
+        malus: this.actor.malusFatigue()
+      },
+      blessures: legeres + graves + critiques,
+      blessure: [legeres > 0, legeres > 1, legeres > 2, legeres > 3, legeres > 4, graves > 0, graves > 1, critiques > 0],
+    }
+    formData.options.exportScriptarium = OptionsAvancees.isUsing(EXPORT_CSV_SCRIPTARIUM)
+    return formData
+  }
+
+  getMappingValues(context, actor) {
+    return Object.fromEntries(Mapping.getMapping().map(it => [it.column, {
+      colName: it.colName ?? it.column,
+      column: it.column,
+      rollClass: it.rollClass,
+      value: String(it.getter(actor, context))
+    }]))
+  }
+
+  getCompetences(categories) {
+    const competences = Mapping.getCompetencesCategorie(this.actor, categories)
+    if (competences.length == 0) {
+      return ''
+    }
+    const byCategories = Mapping.competencesByCategoriesByNiveau(competences, categories)
+    const listByCategories = Object.values(byCategories)
+      .map(it => it.competencesParNiveau)
+      .map(byNiveau => {
+        const niveaux = Object.keys(byNiveau).map(it => Number(it)).sort(Misc.ascending())
+        if (niveaux.length == 0) {
+          return undefined
+        }
+        const listCategorieByNiveau = niveaux.map(niveau => {
+          const list = byNiveau[niveau].sort(Misc.ascending(it => it.name))
+          return { niveau, list }
+        })
+        return Misc.concat(listCategorieByNiveau)
+      }).filter(it => it != undefined)
+
+    return Misc.concat(listByCategories)
+  }
+
+  activateListeners(html) {
+    super.activateListeners(html);
+
+    this.html.find('.click-blessure-remove').click(async event =>
+      await this.actor.supprimerBlessure({
+        gravite: this.html.find(event.currentTarget).data('gravite')
+      })
+    )
+    this.html.find('.click-blessure-add').click(async event =>
+      await this.actor.ajouterBlessure({
+        gravite: this.html.find(event.currentTarget).data('gravite')
+        // event.currentTarget.attributes['data-gravite'].value
+      })
+    )
+    this.html.find('.button-export').click(async event => {
+      ExportScriptarium.INSTANCE.exportActors([this.actor],
+        `${this.actor.uuid}-${this.actor.name}`
+      )
+    })
+  }
+}

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

@@ -12,14 +12,13 @@ export class ExportScriptarium {
   }
 
   constructor() {
-    this.mapping = Mapping.getMapping()
     Hooks.on("getActorDirectoryFolderContext", (actorDirectory, menus) => { ExportScriptarium.INSTANCE.onActorDirectoryMenu(actorDirectory, menus) })
     Hooks.on("getActorDirectoryEntryContext", (actorDirectory, menus) => { ExportScriptarium.INSTANCE.onActorDirectoryMenu(actorDirectory, menus) })
   }
 
   onActorDirectoryMenu(actorDirectory, menus) {
     menus.push({
-      name: 'Export Personnages',
+      name: 'Export Personnages <i class="fa-regular fa-file-csv"></i>',
       icon: IMG_SCRIPTARIUM,
       condition: (target) => game.user.isGM &&
         OptionsAvancees.isUsing(EXPORT_CSV_SCRIPTARIUM) &&
@@ -50,22 +49,21 @@ export class ExportScriptarium {
   }
 
   exportActors(actors, targetName) {
-    const eol = '\n'
+    const eol = '\n\r'
     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() {
-    return this.mapping.map(it => it.column)
+    return Mapping.getColumns()
   }
 
   getActorLine(actor) {
-    const context = Mapping.prepareContext(actor)
-    return this.mapping.map(it => it.getter(actor, context))
-      //.map(it => JSON.stringify(it))
+    const values = Mapping.getValues(actor)
+    return values
       .map(it => this.$escapeQuotes(it))
       .map(it => it.replaceAll("\n", " ").replaceAll("\r", ""))
   }

module/actor/export-scriptarium/mapping.js

@@ -6,15 +6,16 @@ import { ITEM_TYPES } from "../../item.js"
 import { Misc } from "../../misc.js"
 import { RdDTimestamp } from "../../time/rdd-timestamp.js"
 import { RdDBonus } from "../../rdd-bonus.js"
+import { TMRType } from "../../tmr-utility.js"
 
 
-const CATEGORIES_COMPETENCES = [
+export const CATEGORIES_COMPETENCES = [
   "generale",
   "particuliere",
   "specialisee",
   "connaissance",
 ]
-const CATEGORIES_DRACONIC = [
+export const CATEGORIES_DRACONIC = [
   "draconic",
 ]
 
@@ -37,11 +38,11 @@ const NIVEAU_BASE = {
 
 class ColumnMappingFactory {
   static createMappingArme(part, i) {
-    return { column: `arme-${part}-${i}`, getter: (actor, context) => Mapping.getArme(actor, context, part, i) }
+    return { column: `arme_${part}_${i}`, getter: (actor, context) => Mapping.getArme(actor, context, part, i) }
   }
 
   static createMappingSort(part, i) {
-    return { column: `sort-${part}-${i}`, getter: (actor, context) => Mapping.getSort(actor, context, part, i) }
+    return { column: `sort_${part}_${i}`, getter: (actor, context) => Mapping.getSort(actor, context, part, i) }
   }
 }
 
@@ -51,36 +52,41 @@ const TABLEAU_ARMES = [...Array(NB_ARMES).keys()]
 const TABLEAU_SORTS = [...Array(NB_SORTS).keys()]
 
 const MAPPING_BASE = [
-  { column: "ID", getter: (actor, context) => actor.id },
+  { column: "ID", colName: 'ID', getter: (actor, context) => actor.id },
   { column: "name", getter: (actor, context) => actor.name },
-  //    { column: "biographie", getter: (actor, context) => actor.system.biographie },
+  { column: "metier", colName: 'Métier', getter: (actor, context) => actor.system.metier },
+  { column: "biographie", colName: '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 },
-  { column: "constitution", getter: (actor, context) => actor.system.carac.constitution.value },
-  { column: "force", getter: (actor, context) => actor.system.carac.force.value },
-  { column: "agilite", getter: (actor, context) => actor.system.carac.agilite.value },
-  { column: "dexterite", getter: (actor, context) => actor.system.carac.dexterite.value },
-  { column: "vue", getter: (actor, context) => actor.system.carac.vue.value },
-  { column: "ouie", getter: (actor, context) => actor.system.carac.ouie.value },
-  { column: "odoratgout", getter: (actor, context) => actor.system.carac.odoratgout.value },
-  { column: "volonte", getter: (actor, context) => actor.system.carac.volonte.value },
-  { column: "intellect", getter: (actor, context) => actor.system.carac.intellect.value },
-  { column: "empathie", getter: (actor, context) => actor.system.carac.empathie.value },
-  { column: "reve", getter: (actor, context) => actor.system.carac.reve.value },
-  { column: "chance", getter: (actor, context) => actor.system.carac.chance.value },
-  { column: "melee", getter: (actor, context) => actor.system.carac.melee.value },
-  { column: "tir", getter: (actor, context) => actor.system.carac.tir.value },
-  { column: "lancer", getter: (actor, context) => actor.system.carac.lancer.value },
-  { column: "derobee", getter: (actor, context) => actor.system.carac.derobee.value },
+  { column: "apparence", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.apparence.value },
+  { column: "constitution", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.constitution.value },
+  { column: "force", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.force.value },
+  { column: "agilite", rollClass: 'roll-carac', colName: 'Agilité', getter: (actor, context) => actor.system.carac.agilite.value },
+  { column: "dexterite", rollClass: 'roll-carac', colName: 'Dextérité', getter: (actor, context) => actor.system.carac.dexterite.value },
+  { column: "vue", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.vue.value },
+  { column: "ouie", rollClass: 'roll-carac', colName: 'Ouïe', getter: (actor, context) => actor.system.carac.ouie.value },
+  { column: "odoratgout", rollClass: 'roll-carac', colName: 'Odo-goût', getter: (actor, context) => actor.system.carac.odoratgout.value },
+  { column: "volonte", rollClass: 'roll-carac', colName: 'Volonté', getter: (actor, context) => actor.system.carac.volonte.value },
+  { column: "intellect", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.intellect.value },
+  { column: "empathie", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.empathie.value },
+  { column: "reve", rollClass: 'roll-carac', colName: 'Rêve', getter: (actor, context) => actor.system.carac.reve.value },
+  { column: "chance", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.chance.value },
+  { column: "melee", rollClass: 'roll-carac', colName: 'Mêlée', getter: (actor, context) => actor.system.carac.melee.value },
+  { column: "tir", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.tir.value },
+  { column: "lancer", rollClass: 'roll-carac', getter: (actor, context) => actor.system.carac.lancer.value },
+  { column: "derobee", rollClass: 'roll-carac', colName: 'Dérobée', getter: (actor, context) => actor.system.carac.derobee.value },
   { column: "vie", getter: (actor, context) => actor.system.sante.vie.max },
-  { column: "plusdom", getter: (actor, context) => actor.system.attributs.plusdom.value },
-  { column: "protectionnaturelle", getter: (actor, context) => actor.system.attributs.protection.value },
   { column: "endurance", getter: (actor, context) => actor.system.sante.endurance.max },
+  { column: "plusdom", colName: '+dom', getter: (actor, context) => actor.system.attributs.plusdom.value },
+  { column: "protectionnaturelle", colName: 'Protection naturelle', getter: (actor, context) => actor.system.attributs.protection.value > 0 ? actor.system.attributs.protection.value : '' },
   { column: "description", getter: (actor, context) => Mapping.getDescription(actor) },
   { 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.getEsquiveNiveau(context) },
+  { column: "protectionarmure", colName: 'Protection', getter: (actor, context) => Mapping.getProtectionArmure(actor, context) },
+  { column: "malus_armure", getter: (actor, context) => Mapping.getMalusArmure(actor, context) },
+  { column: "reve_actuel", rollClass: 'roll-reve-actuel', colName: 'Rêve actuel', getter: (actor, context) => actor.system.reve.reve.value },
+  { column: "vie_actuel", rollClass: 'jet-vie', getter: (actor, context) => actor.system.sante.vie.value },
+  { column: "endurance_actuel", rollClass: 'jet-vie', getter: (actor, context) => actor.system.sante.endurance.value },
+  { 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) },
 ]
@@ -102,6 +108,27 @@ export class Mapping {
     return MAPPING
   }
 
+  static getColumns() {
+    return MAPPING.map(it => it.column)
+  }
+
+  static getValues(actor) {
+    const context = Mapping.prepareContext(actor)
+    return MAPPING.map(it => it.getter(actor, context))
+  }
+  static getAsObject(actor) {
+    const context = Mapping.prepareContext(actor)
+    return Object.fromEntries(MAPPING.map(it => [it.column, {
+      colName: it.colName ?? it.column,
+      value: it.getter(actor, context)
+    }]))
+  }
+
+  static getValues(actor) {
+    const context = Mapping.prepareContext(actor)
+    return MAPPING.map(it => it.getter(actor, context))
+  }
+
   static prepareContext(actor) {
     return {
       armes: Mapping.prepareArmes(actor),
@@ -115,11 +142,11 @@ export class Mapping {
     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
+        !(arme.system.unemain || arme.system.deuxmains) ? Mapping.prepareArme(actor, arme, 'competence') : undefined,
+        arme.system.lancer != "" ? Mapping.prepareArme(actor, arme, 'lancer') : undefined,
+        arme.system.tir != "" ? Mapping.prepareArme(actor, arme, 'tir') : undefined
       ]
         .filter(it => it != undefined)
     ).reduce((a, b) => a.concat(b), [])
@@ -133,14 +160,27 @@ export class Mapping {
     }
     const dmgArme = RdDItemArme.dommagesReels(arme, maniement)
     const dommages = dmgArme + RdDBonus.bonusDmg(actor, maniement, dmgArme)
+    const categorie = Mapping.complementCategorie(arme, maniement)
     return {
-      name: arme.name,
+      name: arme.name + categorie,
       niveau: Misc.toSignedString(competence.system.niveau),
       init: Mapping.calculBaseInit(actor, competence.system.categorie) + competence.system.niveau,
-      dommages: Misc.toSignedString(dommages)
+      dommages: Misc.toSignedString(dommages),
+      competence: competence,
+      arme: arme
     }
   }
 
+  static complementCategorie(arme, maniement) {
+    switch (maniement) {
+      case 'unemain': return (arme.system.deuxmains) ? ' 1 main' : (arme.system.lancer||arme.system.tir) ? ' mêlée': '' 
+      case 'deuxmains': return (arme.system.unemain) ? ' 2 mains' : (arme.system.lancer||arme.system.tir) ? ' mêlée': '' 
+      case 'lancer': return (arme.system.unemain || arme.system.deuxmains || arme.system.tir) ? ' jet' : ''
+      case 'tir': return (arme.system.unemain || arme.system.deuxmains || arme.system.lancer) ? ' tir' : ''
+    }
+    return '' 
+  }
+
   static calculBaseInit(actor, categorie) {
     const mapping = MAPPING_BASE.find(it => it.column == categorie)
     if (mapping) {
@@ -181,19 +221,24 @@ export class Mapping {
       const esquive = esquives[0]
       return {
         name: esquive.name,
-        niveau: Misc.toSignedString(esquive.system.niveau)
+        niveau: esquive.system.niveau,
+        competence: esquive
       }
     }
     return undefined
   }
 
   static prepareSorts(actor) {
-    return actor.itemTypes[ITEM_TYPES.sort].map(it => Mapping.prepareSort(it))
+    const codeVoies = Mapping.getCompetencesCategorie(actor, CATEGORIES_DRACONIC)
+      .map(it => RdDItemSort.getVoieCode(it))
+
+    return actor.itemTypes[ITEM_TYPES.sort].map(it => Mapping.prepareSort(it, codeVoies))
+      .sort(Misc.ascending(it => `${it.voie} : ${it.description}`))
   }
 
-  static prepareSort(sort) {
+  static prepareSort(sort, voies) {
     return {
-      voie: RdDItemSort.getCodeDraconic(sort),
+      voie: RdDItemSort.getCodeDraconic(sort, voies),
       description: Mapping.descriptionSort(sort),
       bonus: Mapping.bonusCase(sort)
     }
@@ -201,8 +246,18 @@ export class Mapping {
 
   static descriptionSort(sort) {
     const ptSeuil = Array(sort.system.coutseuil).map(it => '*')
-    const caseTMR = sort.system.caseTMRspeciale.length > 0 ? sort.system.caseTMRspeciale : sort.system.caseTMR
-    return `${sort.name}${ptSeuil} (${caseTMR}) R${sort.system.difficulte} r${sort.system.ptreve}`
+    const caseTMR = sort.system.caseTMRspeciale.length > 0 ? Mapping.toVar(sort.system.caseTMRspeciale) : Misc.upperFirst(TMRType[sort.system.caseTMR].name)
+    const ptreve = Mapping.addSpaceToNonNumeric(sort.system.ptreve)
+    const diff = Mapping.addSpaceToNonNumeric(sort.system.difficulte)
+    return `${sort.name}${ptSeuil} (${caseTMR}) R${diff} r${ptreve}`
+  }
+
+  static addSpaceToNonNumeric(value) {
+    return Number.isNumeric(value) ? value : ' ' + Mapping.toVar(value)
+  }
+
+  static toVar(value) {
+    return value.replace('variable', 'var')
   }
 
   static bonusCase(sort) {
@@ -225,7 +280,7 @@ export class Mapping {
     const poids = actor.system.poids
     const cheveux = actor.system.cheveux ? `cheveux ${actor.system.cheveux}` : undefined
     const yeux = actor.system.yeux ? `yeux ${actor.system.yeux}` : undefined
-    const beaute = actor.system.beaute ? `Beauté ${actor.system.beaute}` : undefined
+    const beaute = actor.system.beaute ? `beauté ${actor.system.beaute}` : undefined
     const list = [race, hn, age, taille, poids, cheveux, yeux, beaute]
     return Misc.join(list.filter(it => it), ', ')
   }
@@ -235,17 +290,30 @@ export class Mapping {
   }
 
   static getProtectionArmure(actor, context) {
-    return Number(context?.armure?.protection ?? 0) + Number(actor.system.attributs.protection.value)
+    const naturelle = Number(actor.system.attributs.protection.value)
+    if (context?.armure?.protection == undefined) {
+      return naturelle
+    }
+    if (Number.isNumeric(context?.armure?.protection)) {
+      return Number(context?.armure?.protection ?? 0) + naturelle
+    }
+    return context?.armure.protection + (naturelle > 0 ? `+${naturelle}` : '')
   }
 
   static getMalusArmure(actor, context) {
     return context?.armure?.malus ?? 0
   }
 
-  static getEsquiveNiveau(context) {
+  static getEsquive(context) {
+    if (context.esquive) {
+      return Misc.toSignedString(context.esquive.niveau)
+    }
+    return ''
+  }
+  static getEsquiveArmure(context) {
     if (context.esquive) {
       const niveau = context.esquive.niveau + context.armure.malus
-      return niveau > 0 ? ('+' + niveau) : ('' + niveau)
+      return Misc.toSignedString(niveau)
     }
     return ''
   }
@@ -255,8 +323,8 @@ export class Mapping {
     if (competences.length == 0) {
       return ''
     }
-    const byCartegories = Mapping.competencesByCategoriesByNiveau(competences, categories)
-    const txtByCategories = Object.values(byCartegories)
+    const byCategories = Mapping.competencesByCategoriesByNiveau(competences, categories)
+    const txtByCategories = Object.values(byCategories)
       .map(it => it.competencesParNiveau)
       .map(byNiveau => {
         const niveaux = Object.keys(byNiveau).map(it => Number(it)).sort(Misc.ascending())

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

@@ -0,0 +1,188 @@
+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 preloadHandlebars() {
+    loadTemplates([
+      'systems/foundryvtt-reve-de-dragon/templates/actor/random/champ-aleatoire.hbs',
+    ])
+  }
+
+  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-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,12 +5,12 @@ 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: '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: 'O/H/N', label: "Oniros/Hypnos/Narcos" }
+  { code: 'O', label: "Voie d'Oniros", short: 'Oniros', ordre: 'a' },
+  { code: 'H', label: "Voie d'Hypnos", short: 'Hypnos', ordre: 'b' },
+  { code: 'N', label: "Voie de Narcos", short: 'Narcos', ordre: 'c' },
+  { code: 'T', label: "Voie de Thanatos", short: 'Thanatos', ordre: 'd' },
+  { code: 'O/H/N/T', label: "Oniros/Hypnos/Narcos/Thanatos", short: 'Oniros/Hypnos/Narcos/Thanatos', ordre: 'e' },
+  { code: 'O/H/N', label: "Oniros/Hypnos/Narcos", short: "Oniros/Hypnos/Narcos", ordre: 'f' }
 ]
 
 /* -------------------------------------------- */
@@ -27,17 +27,33 @@ export class RdDItemSort extends Item {
     return [RdDItemCompetence.getVoieDraconic(draconicList, sort.system.draconic)];
   }
 
-  static getCodeDraconic(sort) {
+  static getOrdreCode(code) {
+    return (VOIES_DRACONIC.find(it => it.code == code)?.ordre ?? '?')
+  }
+
+  static getVoieCode(voie) {
+    return VOIES_DRACONIC.find(it => voie.name.includes(it.short))?.code ?? '?'
+  }
+
+  static getCodeDraconic(sort, voies = ['O', 'H', 'N', 'T']) {
     switch (Grammar.toLowerCaseNoAccent(sort.name)) {
       case "lecture d'aura":
       case "detection d'aura":
-        return 'O/H/N/T'
+        return RdDItemSort.$voiesConnues('O/H/N/T', voies)
       case "annulation de magie":
-        return 'O/H/N'
+        return RdDItemSort.$voiesConnues('O/H/N', voies)
     }
     const voie = VOIES_DRACONIC.find(it => it.label.includes(sort.system.draconic))
     return voie?.code ?? sort.system.draconic
   }
+
+
+  static $voiesConnues(voiesSort, voies) {
+    const codes = voies.filter(it => voiesSort.includes(it))
+      .sort(Misc.ascending(it => RdDItemSort.getOrdreCode(it)))
+    return Misc.join(codes ?? [''], '/');
+  }
+
   /* -------------------------------------------- */
   static isDifficulteVariable(sort) {
     return sort && (sort.system.difficulte.toLowerCase() == "variable");
@@ -67,7 +83,7 @@ export class RdDItemSort extends Item {
   static buildBonusCaseList(bonuscase, newCase) {
     const list = RdDItemSort.bonuscaseStringToList(bonuscase)
     if (newCase) {
-       list.push({ case: "Nouvelle", bonus: 0 })
+      list.push({ case: "Nouvelle", bonus: 0 })
     }
     return list;
   }

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-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-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,9 +64,10 @@ 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 { OptionsAvancees } from "./settings/options-avancees.js"
 import { ExportScriptarium } from "./actor/export-scriptarium/export-scriptarium.js"
+import { AppPersonnageAleatoire } from "./actor/random/app-personnage-aleatoire.js"
+import { RdDActorExportSheet } from "./actor/export-scriptarium/actor-encart-sheet.js"
 
 /**
  * RdD system
@@ -119,6 +120,7 @@ export class SystemReveDeDragon {
 
     // preload handlebars templates
     RdDUtility.preloadHandlebarsTemplates()
+    AppPersonnageAleatoire.preloadHandlebars()
 
     /* -------------------------------------------- */
     this.initSystemSettings()
@@ -158,12 +160,12 @@ 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, RdDActorSheet, { types: ["personnage"], makeDefault: true })
     Actors.registerSheet(SYSTEM_RDD, RdDCreatureSheet, { types: ["creature"], makeDefault: true })
     Actors.registerSheet(SYSTEM_RDD, RdDActorVehiculeSheet, { types: ["vehicule"], makeDefault: true })
     Actors.registerSheet(SYSTEM_RDD, RdDActorEntiteSheet, { types: ["entite"], makeDefault: true })
     Items.unregisterSheet("core", ItemSheet)
+    await RdDActorExportSheet.init()
 
     RdDItemSheet.register(RdDSigneDraconiqueItemSheet)
     RdDItemSheet.register(RdDRencontreItemSheet)

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-utility.js

@@ -292,6 +292,7 @@ export class RdDUtility {
 
     Handlebars.registerHelper('array-includes', (array, value) => array.includes(value));
     Handlebars.registerHelper('min', (...args) => Math.min(...args.slice(0, -1)));
+    Handlebars.registerHelper('isLastIndex', (index, list) => index+1 >= list.length);
     Handlebars.registerHelper('regle-optionnelle', (option) => ReglesOptionnelles.isUsing(option));
     Handlebars.registerHelper('trier', list => list.sort((a, b) => a.name.localeCompare(b.name)));
     Handlebars.registerHelper('filtreTriCompetences', competences => RdDItemCompetence.triVisible(competences));

module/settings/options-avancees.js

@@ -4,7 +4,7 @@ import { Misc } from "../misc.js"
 export const EXPORT_CSV_SCRIPTARIUM = 'export-csv-scriptarium'
 
 const OPTIONS_AVANCEES = [
-  { group: 'Menus', name: EXPORT_CSV_SCRIPTARIUM, descr: "Proposer le menu d'export csv Scriptarium (raffraichissement requis)" },
+  { group: 'Menus', name: EXPORT_CSV_SCRIPTARIUM, descr: "Proposer le menu d'export csv Scriptarium" },
 ]
 
 export class OptionsAvancees extends FormApplication {

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: [],

styles/simple.css

@@ -326,7 +326,7 @@ table {border: 1px solid #7a7971;}
   display: grid;
   grid-column: span 2 / span 2;
   grid-template-columns: repeat(2, minmax(0, 1fr));
-  gap: 10px;
+  gap: 30px;
   margin: 10px 0;
   padding: 0;
 }
@@ -411,6 +411,11 @@ table {border: 1px solid #7a7971;}
   text-align: left;
 }
 
+.flex-group-top {
+  vertical-align: top;
+  align-self: start;
+}
+
 .flex-group-right {
   -webkit-box-pack: end;
   -ms-flex-pack: end;
@@ -675,6 +680,7 @@ input:is(.blessure-premiers_soins, .blessure-soins_complets) {
 }
 
 .carac-label {
+  font-weight: bold;
   flex-basis: 40%;
 }
 .rdd.sheet .window-content .sheet-body .carac-list .caracteristique > .utiliser-attribut {
@@ -1183,9 +1189,6 @@ ul.chat-list li:nth-child(odd) {
   padding: 0.5rem;
   cursor: pointer;
 }
-.carac-label {
-  font-weight: bold;
-}
 .list-item {
   margin: 0.1rem;
   box-shadow: inset 0px 0px 1px #00000096;

system.json

@@ -1,8 +1,8 @@
 {
   "id": "foundryvtt-reve-de-dragon",
   "title": "Rêve de Dragon",
-  "version": "12.0.10",
-  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-12.0.10.zip",
+  "version": "12.0.14",
+  "download": "https://www.uberwald.me/gitea/public/foundryvtt-reve-de-dragon/archive/foundryvtt-reve-de-dragon-12.0.14.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-creature-sheet.html

@@ -9,9 +9,9 @@
           <div class="flexrow">
             <h1 class="charname"><input name="name" type="text" value="{{name}}" placeholder="Name" /></h1>
             <div class="header-buttons">
-              <span class="encaisser-direct"><a><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a></span>
+              <span><a class="button-encaissement"><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a></span>
               {{#if @root.options.isGM}}
-              <span class="remise-a-neuf"><a><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a></span>
+              <span><a class="button-remise-a-neuf"><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a></span>
               {{/if}}
             </div>
           </div>

templates/actor-entite-sheet.html

@@ -9,9 +9,9 @@
           <div class="flexrow">
             <h1 class="charname"><input name="name" type="text" value="{{name}}" placeholder="Name" /></h1>
             <div class="header-buttons">
-              <span class="encaisser-direct"><a><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a></span>
+              <span><a class="button-encaissement"><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a></span>
               {{#if @root.options.isGM}}
-              <span class="remise-a-neuf"><a><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a></span>
+              <span><a class="button-remise-a-neuf"><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a></span>
               {{/if}}
             </div>
           </div>

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/carac-main.html

@@ -7,7 +7,7 @@
         <label class="carac-xp"/>
       {{else}}
         {{#if carac.derivee}}
-          <span class="carac-label" name="system.carac.{{key}}.label"><a name={{key}}>{{carac.label}}</a></span>
+          <span class="carac-label" name="system.carac.{{key}}.label"><a class="roll-carac" data-carac-name={{key}}>{{carac.label}}</a></span>
           <label class="competence-value">{{carac.value}}</label>
           <label class="carac-xp"/>
         {{else}}
@@ -22,7 +22,7 @@
               </a>
             </span>
           {{else}}
-            <span class="carac-label tooltip" name="system.carac.{{key}}.label"><a name={{key}}>{{carac.label}}</a></span>
+            <span class="carac-label tooltip" name="system.carac.{{key}}.label"><a class="roll-carac" data-carac-name={{key}}>{{carac.label}}</a></span>
           {{/if}}
           <input class="carac-value" type="text" name="system.carac.{{key}}.value" value="{{carac.value}}" data-dtype="{{carac.type}}" {{#unless @root.options.vueDetaillee}}disabled{{/unless}} />
           <span class="carac-xp tooltip">

templates/actor/combat.html

@@ -13,7 +13,7 @@
       data-competence-name="{{arme.system.competence}}" 
       data-tooltip="{{arme.name}}: niveau {{plusMoins arme.system.niveau}}">
     <span class="arme-label">
-      <a>
+      <a class="roll-arme">
         {{#if arme.img}}
         <img class="sheet-competence-img" src="{{arme.img}}" data-tooltip="{{arme.name}}"/>
         {{/if}}
@@ -32,7 +32,7 @@
   <li class="item flexrow list-item" data-item-id="{{esq._id}}"
     data-tooltip="{{esq.name}}: niveau {{plusMoins esq.system.niveau}}">
     <span class="competence-label">
-      <a class="competence-label" name="{{esq.name}}">
+      <a class="roll-competence" name="{{esq.name}}">
         <img class="sheet-competence-img" src="{{esq.img}}" />
         <span>{{esq.name}}</span>
       </a>

templates/actor/comp-creature.html

@@ -1,7 +1,7 @@
 <ol class="item-list alterne-list">
   {{#each (trier competences) as |comp key|}}
   <li class="item flexrow list-item" data-item-id="{{comp._id}}">
-    <a class="competence-label">
+    <a class="competence-label roll-competence">
       <img class="sheet-competence-img" src="{{comp.img}}" data-tooltip="{{comp.name}}"/>
       <span>{{comp.name}}</span>
     </a>

templates/actor/competence.html

@@ -1,6 +1,6 @@
 {{#unless system.isHidden}}
   <li class="item flexrow list-item {{#if system.isLevelUp}}xp-level-up tooltip{{/if}}" data-item-id="{{_id}}">
-    <a class="competence-label" name="{{name}}" data-tooltip="Niveau {{plusMoins system.niveau}} en {{name}}">
+    <a class="competence-label roll-competence" name="{{name}}" data-tooltip="Niveau {{plusMoins system.niveau}} en {{name}}">
       <img class="sheet-competence-img" src="{{img}}"/>
       <span>{{name}}</span>
     </a>

templates/actor/export-scriptarium/actor-encart-sheet.hbs

@@ -0,0 +1,130 @@
+<form class="{{cssClass}}" autocomplete="off" >
+  <section class="sheet-header">
+    <div class="flexrow">
+      <div class="flex-group-left flex-grow-0-5">
+        <h1 class="charname">{{name}}
+        </h1>
+      </div>
+      <div class="flex-group-right flex-grow-3">
+        {{#if system.attributs.hautrevant.value}}
+        <a class="button-tmr" data-tooltip="Montée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
+          <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-normal.svg"/>
+        </a>
+        <a class="button-tmr-rapide" data-tooltip="Montée accélérée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
+          <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-rapide.svg"/>
+        </a>
+        <a class="button-tmr-visu" data-tooltip="Regarder les Terres M&eacute;dianes">
+          <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-view.svg"/>
+        </a>
+        {{/if}}
+        <a class="button-appel-chance"><img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/appel-chance.svg" data-tooltip="Appel à la chance"/></a>
+        <a class="button-encaissement"><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a>
+        <a class="button-ethylisme"><img class="button-img" src="icons/svg/tankard.svg" data-tooltip="Boire"/></a>
+        <a class="button-repos"><img class="button-img" src="icons/svg/sleep.svg" data-tooltip="Se reposer"/></a>
+        {{#if @root.options.isGM}}
+        <a class="button-remise-a-neuf"><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a>
+        {{/if}}
+        {{#if options.exportScriptarium}}
+        <a class="button-export">
+          <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/scriptarium.svg" data-tooltip="Export format Scriptarium"/>
+        </a>
+        {{/if}}
+      </div>
+    </div>
+  </section>
+  <section class="sheet-body" style=:"margin-bottom: 3rem;">
+    <div>
+      <strong>{{export.name.value}}</strong>{{#if export.description.value}}, {{export.description.value}}{{/if}}
+      </div>
+    <hr>
+    <div class="grid-2col">
+      <div class="flexcol flex-group-top">
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.taille}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.apparence}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.constitution}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.force}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.agilite}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.dexterite}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.vue}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.ouie}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.odoratgout}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.volonte}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.empathie}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.intellect}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-compteur.hbs" carac=export.reve actuel=export.reve_actuel button-name='ptreve-actuel'}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac.hbs" carac=export.chance}}
+      </div>
+      <div class="flexcol flex-group-top">
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=export.melee}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=export.tir}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=export.lancer}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=export.derobee}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee-compteur.hbs" carac=export.vie actuel=export.vie_actuel}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee-compteur.hbs" carac=export.endurance actuel=export.endurance_actuel}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/fatigue.hbs" }}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=export.plusdom}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/protection.hbs" export}}
+        <div class="flexrow">&nbsp;</div>
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessures.hbs" }}
+      </div>
+    </div>
+  <hr>
+    <div>
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/arme.hbs" name='' niveau='Niv' init='Init' dommages='+dom'}}
+      {{#each context.armes as |arme|}}
+        {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/arme.hbs"
+          name=arme.name niveau=arme.niveau init=arme.init dommages=arme.dommages
+          arme=arme.arme competence=arme.competence
+        }}
+      {{/each}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/esquive.hbs" name='Esquive' niveau=context.esquive.value competence=context.esquive.competence}}
+      {{#if (gt export.malue_armure.value 0)}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/esquive.hbs" name='Esquive (avec armure)' niveau=export.esquive_armure.value
+        competence=context.esquive.competence}}
+      {{/if}}
+    </div>
+  <hr>
+    <div>
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/competences.hbs" competences=competences}}
+    </div>
+  <hr>
+    <div>
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/competences.hbs" competences=draconic }}
+    </div>
+    <hr>
+    <div>
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_0.value description=export.sort_description_0.value bonus=export.sort_bonus_0.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_1.value description=export.sort_description_1.value bonus=export.sort_bonus_1.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_2.value description=export.sort_description_2.value bonus=export.sort_bonus_2.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_3.value description=export.sort_description_3.value bonus=export.sort_bonus_3.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_4.value description=export.sort_description_4.value bonus=export.sort_bonus_4.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_5.value description=export.sort_description_5.value bonus=export.sort_bonus_5.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_6.value description=export.sort_description_6.value bonus=export.sort_bonus_6.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_7.value description=export.sort_description_7.value bonus=export.sort_bonus_7.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_8.value description=export.sort_description_8.value bonus=export.sort_bonus_8.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_9.value description=export.sort_description_9.value bonus=export.sort_bonus_9.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_10.value description=export.sort_description_10.value bonus=export.sort_bonus_10.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_11.value description=export.sort_description_11.value bonus=export.sort_bonus_11.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_12.value description=export.sort_description_12.value bonus=export.sort_bonus_12.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_13.value description=export.sort_description_13.value bonus=export.sort_bonus_13.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_14.value description=export.sort_description_14.value bonus=export.sort_bonus_14.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_15.value description=export.sort_description_15.value bonus=export.sort_bonus_15.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_16.value description=export.sort_description_16.value bonus=export.sort_bonus_16.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_17.value description=export.sort_description_17.value bonus=export.sort_bonus_17.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_18.value description=export.sort_description_18.value bonus=export.sort_bonus_18.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_19.value description=export.sort_description_19.value bonus=export.sort_bonus_19.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_20.value description=export.sort_description_20.value bonus=export.sort_bonus_20.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_21.value description=export.sort_description_21.value bonus=export.sort_bonus_21.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_22.value description=export.sort_description_22.value bonus=export.sort_bonus_22.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_23.value description=export.sort_description_23.value bonus=export.sort_bonus_23.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_24.value description=export.sort_description_24.value bonus=export.sort_bonus_24.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_25.value description=export.sort_description_25.value bonus=export.sort_bonus_25.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_26.value description=export.sort_description_26.value bonus=export.sort_bonus_26.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_27.value description=export.sort_description_27.value bonus=export.sort_bonus_27.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_28.value description=export.sort_description_28.value bonus=export.sort_bonus_28.value}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/sort.hbs" voie=export.sort_voie_29.value description=export.sort_description_29.value bonus=export.sort_bonus_29.value}}
+      <div>&nbsp;</div>
+      <div>&nbsp;</div>
+    </div>
+  </section>
+</form>

templates/actor/export-scriptarium/arme.hbs

@@ -0,0 +1,20 @@
+<div class="flexrow item"
+      data-item-id="{{arme._id}}"
+      data-arme-name="{{arme.name}}"
+      data-competence-name="{{competence.name}}">
+      {{#if name}}
+      <a class="roll-arme">{{upperFirst name}}</a>
+      {{else}}
+      <div></div>
+      {{/if}}
+  <div class="flexrow">
+    <div>{{niveau}}</div>
+    {{#if init}}
+    <div>{{init}}</div>
+    <div>{{dommages}}</div>
+    {{else}}
+    <div></div>
+    <div></div>
+    {{/if}}
+  </div>
+</div>

templates/actor/export-scriptarium/blessure.hbs

@@ -0,0 +1,5 @@
+{{#if blessure}}
+<a class="click-blessure-remove" data-gravite="{{gravite}}"><i class="fa-regular fa-face-head-bandage blessure-active-{{gravite}}"></i></a>
+{{else}}
+<a class="click-blessure-add" data-gravite="{{gravite}}"><i class="fa-regular fa-circle"></i></a>
+{{/if}}

templates/actor/export-scriptarium/blessures.hbs

@@ -0,0 +1,26 @@
+
+<div class="flexcol">
+  <div class="flexrow">
+    <div>Légères</div>
+    <div class="flex-group-right">
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[0] gravite=2}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[1] gravite=2}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[2] gravite=2}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[3] gravite=2}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[4] gravite=2}}
+    </div>
+  </div>
+  <div class="flexrow">
+    <div>Graves</div>
+    <div class="flex-group-right">
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[5] gravite=4}}
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[6] gravite=4}}
+    </div>
+  </div>
+  <div class="flexrow">
+    <div>Critiques</div>
+    <div class="flex-group-right">
+      {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/blessure.hbs" blessure=etat.blessure.[7] gravite=6}}
+    </div>
+  </div>
+</div>

templates/actor/export-scriptarium/carac-compteur.hbs

@@ -0,0 +1,18 @@
+<div class="flexrow">
+  <div>
+    {{#if carac.rollClass}}
+    <a class="{{carac.rollClass}}" data-carac-name="{{carac.column}}">
+      {{upper carac.colName}}
+    </a>
+    {{else}}
+    {{upper carac.colName}}
+    {{/if}}
+    <a class="{{button-name}}-moins"><i class="fa-regular fa-square-minus"></i></a>
+    <a class="{{button-name}}-plus"><i class="fa-regular fa-square-plus"></i></a>
+  </div>
+  <div class="flex-group-right">
+    {{log carac.colName carac.value (eq carac.value actuel.value) actuel.value}}
+    {{log carac.colName carac.value (eq 1 1) actuel.value}}
+    <a class="{{actuel.rollClass}}" data-carac-name="{{actuel.column}}">{{carac.value}} {{#unless (eq carac.value actuel.value)}}(Actuel : {{actuel.value}}){{/unless}}</a>
+  </div>
+</div>

templates/actor/export-scriptarium/carac-derivee-compteur.hbs

@@ -0,0 +1,10 @@
+<div class="flexrow">
+  <div>
+    {{upperFirst carac.colName}}
+    <a class="{{carac.column}}-moins"><i class="fa-regular fa-square-minus"></i></a>
+    <a class="{{carac.column}}-plus"><i class="fa-regular fa-square-plus"></i></a>
+  </div>
+  <div class="flex-group-right">
+    <a class="{{actuel.rollClass}}" data-carac-name="{{actuel.column}}">{{carac.value}} {{#unless (eq carac.value actuel.value)}}(Actuel : {{actuel.value}}){{/unless}}</a>
+  </div>
+</div>

templates/actor/export-scriptarium/carac-derivee.hbs

@@ -0,0 +1,12 @@
+<div class="flexrow">
+  <div>
+    {{#if carac.rollClass}}
+    <a class="{{carac.rollClass}}" data-carac-name="{{carac.column}}">
+      {{upperFirst carac.colName}}
+    </a>
+    {{else}}
+    {{upperFirst carac.colName}}
+    {{/if}}
+  </div>
+  <div class="flex-group-right">{{carac.value}}</div>
+</div>

templates/actor/export-scriptarium/carac.hbs

@@ -0,0 +1,10 @@
+<div class="flexrow">
+  <div>
+    {{#if carac.rollClass}}
+    <a class="{{carac.rollClass}}" data-carac-name="{{carac.column}}">{{upper carac.colName}}</a>
+    {{else}}
+    {{upper carac.colName}}
+    {{/if}}
+  </div>
+  <div class="flex-group-right">{{carac.value}}</div>
+</div>

templates/actor/export-scriptarium/competences.hbs

@@ -0,0 +1,9 @@
+{{#each competences as |group|}}
+  {{#if @index}}/{{/if}}
+  {{#with group}}
+    {{#each list as |comp|}}
+      <span class="item" data-item-id="{{comp._id}}"><a class="roll-competence">{{comp.name}}</a></span>{{~#unless (isLastIndex @index ../list)~}},{{/unless~}}
+    {{/each}}
+    {{numberFormat niveau decimals=0 sign=true}}
+  {{/with}}
+{{/each}}

templates/actor/export-scriptarium/esquive.hbs

@@ -0,0 +1,10 @@
+{{#if name}}
+<div class="flexrow item" data-item-id="{{competence._id}}">
+  <a class="roll-competence" name="Esquive">{{upperFirst name}}</a>
+  <div class="flexrow">
+    <div>{{niveau}}</div>
+    <div></div>
+    <div></div>
+  </div>
+</div>
+{{/if}}

templates/actor/export-scriptarium/fatigue.hbs

@@ -0,0 +1,12 @@
+<div class="flexrow">
+  <div>Fatigue 
+    {{#if etat.fatigue.malus}}
+    ({{etat.fatigue.malus}})
+    {{/if}}
+    <a class="fatigue-moins"><i class="fa-regular fa-square-minus"></i></a>
+    <a class="fatigue-plus"><i class="fa-regular fa-square-plus"></i></a>
+  </div>
+  <div class="flex-group-right">
+    {{etat.fatigue.value}}{{#if etat.fatigue.value}} / {{etat.fatigue.max}}{{/if}}
+  </div>
+</div>

templates/actor/export-scriptarium/protection.hbs

@@ -0,0 +1,7 @@
+{{#if protectionnaturelle.value}}
+  {{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=protectionnaturelle}}
+{{/if}}
+{{>"systems/foundryvtt-reve-de-dragon/templates/actor/export-scriptarium/carac-derivee.hbs" carac=protectionarmure}}
+{{#if armure.value}}
+<div class="flexrow flex-group-right"><i>{{armure.value}}</i></div>
+{{/if}}

templates/actor/export-scriptarium/sort.hbs

@@ -0,0 +1,11 @@
+{{#if voie}}
+<div class="flexrow">
+  <div style="flex-grow: 0.4;">{{voie}}</div>
+  <div class="flex-grow-2">{{upperFirst description}}</div>
+  {{#if bonus}}
+  <div>{{bonus}}</div>
+  {{else}}
+  <div></div>
+  {{/if}}
+</div>
+{{/if}}

templates/actor/header-buttons.html

@@ -1,19 +1,19 @@
 <div class="header-buttons">
-  <span class="chance-appel">
-    <a><img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/appel-chance.svg" data-tooltip="Appel à la chance"/></a>
+  <span>
+    <a class="button-appel-chance"><img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/appel-chance.svg" data-tooltip="Appel à la chance"/></a>
   </span>
-  <span class="encaisser-direct">
-    <a><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a>
+  <span>
+    <a class="button-encaissement"><img class="button-img" src="icons/svg/bones.svg" data-tooltip="Encaisser des dommages"/></a>
   </span>
-  <span class="ethylisme-test">
-    <a><img class="button-img" src="icons/svg/tankard.svg" data-tooltip="Boire"/></a>
+  <span>
+    <a class="button-ethylisme"><img class="button-img" src="icons/svg/tankard.svg" data-tooltip="Boire"/></a>
   </span>
-  <span class="repos">
-    <a><img class="button-img" src="icons/svg/sleep.svg" data-tooltip="Se reposer"/></a>
+  <span>
+    <a class="button-repos"><img class="button-img" src="icons/svg/sleep.svg" data-tooltip="Se reposer"/></a>
   </span>
   {{#if @root.options.isGM}}
-  <span class="remise-a-neuf">
-    <a><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a>
+  <span>
+    <a class="button-remise-a-neuf"><img class="button-img" src="icons/svg/regen.svg" data-tooltip="Remise à neuf"/></a>
   </span>
   {{/if}}
 </div>

templates/actor/header-compteurs.html

@@ -30,7 +30,7 @@
     </li>
     <li>
       <label class="compteur">
-        <span class="ptreve-actuel"  data-tooltip="Faire un jet de Rêve actuel (ou jet de résistance)"><a>Rêve</a></span>
+        <span class="roll-reve-actuel" data-tooltip="Faire un jet de Rêve actuel (ou jet de résistance)"><a>Rêve</a></span>
         <a class="ptreve-actuel-moins"><i class="fa-solid fa-square-minus"></i></a>
         <input class="resource-content" class="pointsreve-value" type="text" name="system.reve.reve.value" value="{{system.reve.reve.value}}" data-dtype="Number" />
         <span>/ {{system.reve.seuil.value}}</span>

templates/actor/header-hautreve.html

@@ -1,17 +1,17 @@
 {{#if system.attributs.hautrevant.value}}
   <div class="tmr-buttons">
-    <span class="monte-tmr">
-      <a data-tooltip="Montée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
+    <span>
+      <a class="button-tmr" data-tooltip="Montée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
         <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-normal.svg"/>
       </a>
     </span>
-    <span class="monte-tmr-rapide">
-      <a data-tooltip="Montée accélérée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
+    <span>
+      <a class="button-tmr-rapide" data-tooltip="Montée accélérée dans les Terres M&eacute;dianes !" {{#if hautreve.isDemiReve}}disabled{{/if}}>
         <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-rapide.svg"/>
       </a>
     </span>
-    <span class="visu-tmr">
-      <a data-tooltip="Regarder les Terres M&eacute;dianes">
+    <span>
+      <a class="button-tmr-visu" data-tooltip="Regarder les Terres M&eacute;dianes">
         <img class="button-img" src="systems/foundryvtt-reve-de-dragon/styles/img/ui/icon-tmr-view.svg"/>
       </a>
     </span>

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>