feat: gestion de la Fiabilité du matériel (test de Fiabilité + réparations)

- module/system/reliability.mjs : VermineReliability
  - Test de Fiabilité : jet Xd10 (Mineurs 1D / Graves 3D / Critiques 5D),
    chaque dé >= Fiabilité inflige 1 Dommage ; réduit Fiabilité et dommages
    cumulés (panne/état/effet) ; destruction à 0
  - Traits appliqués : Coque (absorbe n puis se perd), Cassant (+1 perte),
    Étanche (Dommages d'immersion ignorés si Fiabilité au max)
  - Réparations : classique (Précision + Artisanat/Mécanique/Technologie/
    Armurerie vs Fiabilité d'origine + Handicap de panne, +1 Fiabilité/Réussite)
    et de fortune (Précision + Bricolage, panne réparée sans gain de Fiabilité)
- ReliabilityDialog (test/réparation) + cartes de chat dédiées
- Boutons Test de Fiabilité / Réparer sur les fiches d'items (weapon/defense/item)
- i18n fr/en + styles des cartes et boutons

module/applications/sheets/base-item-sheet.mjs

@@ -25,7 +25,9 @@ export class VermineBaseItemSheet extends HandlebarsApplicationMixin(foundry.app
       editImage: VermineBaseItemSheet.#onEditImage,
       toggleSheet: VermineBaseItemSheet.#onToggleSheet,
       clickDamage: VermineBaseItemSheet.#onClickDamage,
-      openTraits: VermineBaseItemSheet.#onOpenTraits
+      openTraits: VermineBaseItemSheet.#onOpenTraits,
+      reliabilityTest: VermineBaseItemSheet.#onReliabilityTest,
+      reliabilityRepair: VermineBaseItemSheet.#onReliabilityRepair
     }
   }
 
@@ -120,4 +122,16 @@ export class VermineBaseItemSheet extends HandlebarsApplicationMixin(foundry.app
     const { TraitSelector } = await import("../../system/applications.mjs")
     new TraitSelector(this.document).render(true)
   }
+
+  static async #onReliabilityTest() {
+    const { ReliabilityDialog } = await import("../../system/dialogs/reliabilityDialog.mjs")
+    const dialog = new ReliabilityDialog({ item: this.document, mode: "test" })
+    await dialog.render(true)
+  }
+
+  static async #onReliabilityRepair() {
+    const { ReliabilityDialog } = await import("../../system/dialogs/reliabilityDialog.mjs")
+    const dialog = new ReliabilityDialog({ item: this.document, mode: "repair" })
+    await dialog.render(true)
+  }
 }

module/system/dialogs/reliabilityDialog.mjs

@@ -0,0 +1,114 @@
+import { VermineReliability } from '../reliability.mjs';
+
+const { HandlebarsApplicationMixin } = foundry.applications.api;
+
+/**
+ * Dialogue de Test de Fiabilité / Réparation d'un item.
+ * Mode "test" : choix de la gravité des Dommages matériels (Mineurs/Graves/Critiques)
+ * + case Immersion (Trait Étanche). Mode "repair" : type de réparation
+ * (classique/de fortune) + compétence utilisée.
+ */
+export default class ReliabilityDialog extends HandlebarsApplicationMixin(foundry.applications.api.ApplicationV2) {
+  #item;
+  #mode;
+
+  static DEFAULT_OPTIONS = {
+    classes: ['vermine-roll', 'reliability'],
+    tag: 'form',
+    window: {
+      icon: 'fas fa-tools',
+      resizable: false,
+    },
+    position: {
+      width: 460,
+      height: 'auto',
+    },
+    actions: {
+      run: ReliabilityDialog.#onRun,
+      cancel: ReliabilityDialog.#onCancel,
+    },
+  };
+
+  static PARTS = {
+    main: { template: 'systems/vermine2047/templates/dialogs/reliability-dialog.hbs', scrollable: [''] },
+  };
+
+  static async create({ item, mode = 'test' }) {
+    return new ReliabilityDialog({ item, mode });
+  }
+
+  constructor(options = {}) {
+    super(options);
+    this.#item = options.item;
+    this.#mode = options.mode ?? 'test';
+  }
+
+  get title() {
+    return game.i18n.localize(this.#mode === 'repair' ? 'VERMINE.reliability_repair' : 'VERMINE.reliability_test');
+  }
+
+  async _prepareContext() {
+    const hasEtanche = !!this.#item.system?.traits?.etanche;
+    const hasActor = !!this.#item.actor;
+    const severities = ['mineurs', 'graves', 'critiques'].map((key) => ({
+      key,
+      label: game.i18n.localize(`VERMINE.reliability_severity_${key}`),
+      selected: key === 'graves',
+    }));
+    const skills = VermineReliability.REPAIR_SKILLS.map((key) => ({
+      key,
+      label: game.i18n.localize(`SKILLS.${key}.name`),
+    }));
+    return {
+      mode: this.#mode,
+      isTest: this.#mode === 'test',
+      isRepair: this.#mode === 'repair',
+      hasEtanche,
+      hasActor,
+      severities,
+      skills,
+    };
+  }
+
+  _onRender(context, options) {
+    super._onRender(context, options);
+    if (this.#mode !== 'repair') return;
+    const select = this.element.querySelector('#reliability-skill');
+    const radios = this.element.querySelectorAll('input[name="repairMode"]');
+    if (!select || !radios.length) return;
+    const refresh = () => {
+      const fortune = this.element.querySelector('input[name="repairMode"]:checked')?.value === 'fortune';
+      select.closest('.form-group')?.classList.toggle('hidden', fortune);
+    };
+    radios.forEach((r) => r.addEventListener('change', refresh));
+    refresh();
+  }
+
+  #getOptions() {
+    const el = this.element;
+    if (this.#mode === 'test') {
+      return {
+        severity: el.querySelector('input[name="severity"]:checked')?.value ?? 'graves',
+        immersion: !!el.querySelector('#reliability-immersion')?.checked,
+      };
+    }
+    return {
+      mode: el.querySelector('input[name="repairMode"]:checked')?.value ?? 'classique',
+      skill: el.querySelector('#reliability-skill')?.value ?? 'technology',
+    };
+  }
+
+  static async #onRun() {
+    const options = this.#getOptions();
+    if (this.#mode === 'test') {
+      await VermineReliability.test(this.#item, options);
+    } else {
+      await VermineReliability.repair(this.#item, options);
+    }
+    this.close();
+  }
+
+  static #onCancel() {
+    this.close();
+  }
+}

module/system/reliability.mjs

@@ -0,0 +1,246 @@
+import { VermineUtils } from './roll.mjs';
+
+/**
+ * Gestion de la Fiabilité du matériel (regles/regles_materiel.txt).
+ *
+ * Test de Fiabilité (Dommages matériels) : selon la gravité (Mineurs 1D,
+ * Graves 3D, Critiques 5D), on lance les dés sans Relance ni Réserve ;
+ * chaque dé >= Fiabilité inflige 1 Dommage (réduit la Fiabilité de 1).
+ * À 0, l'équipement est détruit ou inutilisable.
+ *
+ * Réparations : jet de Précision + Compétence contre la Fiabilité d'origine
+ * (classique) ou de Précision + Bricolage contre la Fiabilité actuelle
+ * (de fortune). Chaque Réussite rend 1 point de Fiabilité (classique) ;
+ * la réparation de fortune rend l'objet fonctionnel sans rendre de point.
+ */
+export class VermineReliability {
+  /** Gravités et nombre de dés de Dommages (p. 37). */
+  static SEVERITIES = { mineurs: 1, graves: 3, critiques: 5 };
+
+  /** Handicap de réparation selon les Dommages subis (Mineure I, Grave II, Critique III). */
+  static #PANNE_HANDICAP = { 1: 1, 2: 1, 3: 2, 4: 2, 5: 3 };
+
+  /** Compétences de réparation classique (regles_materiel p. 39). */
+  static REPAIR_SKILLS = ['crafting', 'mecanical', 'technology', 'armory'];
+
+  /**
+   * Handicap de la panne courante (0 si intact).
+   * @param {Item} item
+   * @returns {number}
+   */
+  static panneHandicap(item) {
+    const value = parseInt(item.system?.damages?.value ?? 0, 10) || 0;
+    return this.#PANNE_HANDICAP[value] || 0;
+  }
+
+  /**
+   * État courant dérivé des Dommages subis (tableau `damages.state`).
+   * @param {Item} item
+   * @returns {string}
+   */
+  static panneState(item) {
+    const damages = item.system?.damages;
+    const idx = (parseInt(damages?.value ?? 0, 10) || 0) - 1;
+    return idx >= 0 ? damages.state?.[idx] ?? '' : '';
+  }
+
+  /**
+   * Test de Fiabilité : jet de Dommages matériels.
+   * @param {Item} item
+   * @param {Object} opts
+   * @param {string} opts.severity "mineurs" | "graves" | "critiques"
+   * @param {boolean} opts.immersion si vrai, le Trait Étanche peut annuler les Dommages
+   * @returns {Promise<Object|null>} Résultat (null si impossible)
+   */
+  static async test(item, { severity = 'graves', immersion = false } = {}) {
+    if (!item) return null;
+    const diceCount = this.SEVERITIES[severity] ?? 3;
+    const current = parseInt(item.system?.reliability ?? 0, 10) || 0;
+    const traits = item.system?.traits ?? {};
+    const damagesValue = parseInt(item.system?.damages?.value ?? 0, 10) || 0;
+
+    if (current <= 0) {
+      ui.notifications.warn(game.i18n.localize('VERMINE.reliability_already_destroyed'));
+      return { destroyed: true, dommages: 0 };
+    }
+
+    // Jet des dés de Dommages (sans Relance ni Réserve)
+    const roll = new Roll(`${diceCount}d10`);
+    await roll.evaluate();
+    await VermineUtils.showDiceSoNice(roll);
+
+    const results = (roll.dice ?? []).flatMap((d) => (d.results ?? []).map((r) => r.result ?? 0));
+    const traitsNotes = [];
+
+    // Trait Étanche : ignore les Dommages d'immersion tant que la Fiabilité
+    // est à son maximum (objet sans Dommage cumulé).
+    let dommages = results.filter((r) => r >= current).length;
+    if (immersion && traits.etanche && damagesValue === 0) {
+      dommages = 0;
+      traitsNotes.push(game.i18n.localize('VERMINE.reliability_etanche'));
+    }
+
+    // Trait Coque (n) : ignore les (n) premiers Dommages puis se perd.
+    let coqueValue = parseInt(traits.coque?.value ?? 0, 10) || 0;
+    const updates = {};
+    if (coqueValue > 0 && dommages > 0) {
+      const absorbed = Math.min(coqueValue, dommages);
+      dommages -= absorbed;
+      coqueValue -= absorbed;
+      if (coqueValue > 0) {
+        updates['system.traits.coque.value'] = coqueValue;
+        traitsNotes.push(game.i18n.format('VERMINE.reliability_coque_absorbed', { absorbed, remaining: coqueValue }));
+      } else {
+        updates['system.traits.coque'] = null;
+        traitsNotes.push(game.i18n.localize('VERMINE.reliability_coque_lost'));
+      }
+    }
+
+    // Trait Cassant : toutes les pertes de Fiabilité sont majorées d'1 point.
+    const cassant = !!traits.cassant;
+    if (cassant && dommages > 0) {
+      dommages += 1;
+      traitsNotes.push(game.i18n.localize('VERMINE.reliability_cassant'));
+    }
+
+    const newReliability = Math.max(0, current - dommages);
+    const newDamagesValue = Math.min(5, damagesValue + dommages);
+    const destroyed = newReliability === 0;
+
+    updates['system.reliability'] = newReliability;
+    updates['system.damages.value'] = destroyed ? 5 : newDamagesValue;
+    await item.update(updates);
+
+    // État final affiché sur la carte.
+    let state = '';
+    if (destroyed) {
+      state = game.i18n.localize('VERMINE.reliability_destroyed');
+    } else if (newDamagesValue > 0) {
+      const idx = newDamagesValue - 1;
+      state = item.system.damages.state?.[idx] ?? '';
+    } else {
+      state = '';
+    }
+
+    const content = await foundry.applications.handlebars.renderTemplate(
+      'systems/vermine2047/templates/reliability-test.hbs',
+      {
+        item: { name: item.name, img: item.img },
+        severityLabel: game.i18n.localize(`VERMINE.reliability_severity_${severity}`),
+        diceCount,
+        oldReliability: current,
+        newReliability,
+        dommages,
+        results: results.map((v) => ({ value: v, isDamage: v >= current })),
+        state,
+        destroyed,
+        traitsNotes,
+      },
+    );
+
+    await ChatMessage.create({
+      user: game.user?._id,
+      speaker: this.#getSpeaker(item),
+      content,
+    });
+
+    return { dommages, newReliability, destroyed };
+  }
+
+  /**
+   * Réparation classique ou de fortune.
+   * @param {Item} item
+   * @param {Object} opts
+   * @param {string} opts.mode "classique" | "fortune"
+   * @param {string} opts.skill Compétence de réparation classique (clé de skills)
+   * @returns {Promise<Object|null>}
+   */
+  static async repair(item, { mode = 'classique', skill = 'technology' } = {}) {
+    const actor = item?.actor;
+    if (!item || !actor) {
+      ui.notifications.warn(game.i18n.localize('VERMINE.reliability_need_actor'));
+      return null;
+    }
+
+    const current = parseInt(item.system?.reliability ?? 0, 10) || 0;
+    const damagesValue = parseInt(item.system?.damages?.value ?? 0, 10) || 0;
+    const handicap = this.panneHandicap(item);
+
+    // Difficulté : Fiabilité d'origine (≈ actuelle + Dommages subis) pour la
+    // réparation classique ; Fiabilité actuelle pour la réparation de fortune.
+    const difficulty = mode === 'classique' ? Math.min(10, current + damagesValue) : current;
+
+    const precision = parseInt(actor.system?.abilities?.precision?.value ?? 0, 10) || 0;
+    const skillValue = mode === 'fortune'
+      ? parseInt(actor.system?.skills?.diy?.value ?? 0, 10) || 0
+      : parseInt(actor.system?.skills?.[skill]?.value ?? 0, 10) || 0;
+    const NoD = Math.max(0, precision + skillValue);
+
+    const roll = new Roll(`${NoD}d10cs>=${difficulty}`);
+    await roll.evaluate();
+    await VermineUtils.showDiceSoNice(roll);
+
+    const results = (roll.dice ?? []).flatMap((d) => (d.results ?? []).map((r) => ({
+      value: r.result ?? 0,
+      isSuccess: r.success,
+    })));
+    const successes = roll._total ?? 0;
+    const required = 1 + handicap;
+    const success = successes >= required;
+
+    let gained = 0;
+    let fortuneFixed = false;
+    let resultLabel = '';
+    if (success) {
+      if (mode === 'classique') {
+        gained = successes;
+        resultLabel = game.i18n.format('VERMINE.reliability_gained', { gained });
+      } else {
+        fortuneFixed = true;
+        resultLabel = game.i18n.localize('VERMINE.reliability_fixed');
+      }
+    } else {
+      resultLabel = game.i18n.localize('VERMINE.reliability_failed');
+    }
+
+    const updates = {};
+    if (mode === 'classique' && gained > 0) {
+      updates['system.reliability'] = Math.min(10, current + gained);
+      updates['system.damages.value'] = Math.max(0, damagesValue - gained);
+    } else if (mode === 'fortune' && fortuneFixed) {
+      updates['system.damages.value'] = 0;
+    }
+    if (Object.keys(updates).length) await item.update(updates);
+
+    const skillLabel = mode === 'fortune'
+      ? game.i18n.localize('SKILLS.diy.name')
+      : game.i18n.localize(`SKILLS.${skill}.name`);
+
+    const content = await foundry.applications.handlebars.renderTemplate(
+      'systems/vermine2047/templates/reliability-repair.hbs',
+      {
+        item: { name: item.name, img: item.img },
+        modeLabel: game.i18n.localize(mode === 'classique' ? 'VERMINE.reliability_repair_classic' : 'VERMINE.reliability_repair_fortune'),
+        skillLabel,
+        difficulty,
+        handicap,
+        results,
+        successes,
+        required,
+        resultLabel,
+      },
+    );
+
+    await ChatMessage.create({
+      user: game.user?._id,
+      speaker: this.#getSpeaker(item),
+      content,
+    });
+
+    return { success, gained, successes, required };
+  }
+
+  static #getSpeaker(item) {
+    return ChatMessage.getSpeaker({ actor: item?.actor ?? null });
+  }
+}