Fiche acteur, WIP

2023-01-18 16:16:18 +01:00
parent 3108c346f4
commit 54e397d6f0
15 changed files with 483 additions and 558 deletions
--- a/modules/heritiers-actor-sheet.js
+++ b/modules/heritiers-actor-sheet.js
@@ -38,16 +38,14 @@ export class HeritiersActorSheet extends ActorSheet {
      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
      limited: this.object.limited,
      skills: this.actor.getSkills(),
+      utileSkills :this.actor.organizeUtileSkills(),
+      futileSkills :this.actor.organizeFutileSkills(),
      armes: duplicate(this.actor.getWeapons()),
      monnaies: duplicate(this.actor.getMonnaies()),
      protections: duplicate(this.actor.getArmors()),
-      historiques: duplicate(this.actor.getHistoriques() || []),
-      talents: duplicate(this.actor.getTalents() || []),
-      talentsCell: this.getCelluleTalents(),
      profils: duplicate(this.actor.getProfils()  || []),
      combat: this.actor.getCombatValues(),      
      equipements: duplicate(this.actor.getEquipments()),
-      artefacts: duplicate(this.actor.getArtefacts()),
      monnaies: duplicate(this.actor.getMonnaies()),
      richesse: this.actor.computeRichesse(),
      valeurEquipement: this.actor.computeValeurEquipement(),
@@ -133,9 +131,8 @@ export class HeritiersActorSheet extends ActorSheet {
    })
    html.find('.roll-competence').click((event) => {
      const li = $(event.currentTarget).parents(".item")
-      let attrKey = $(event.currentTarget).data("attr-key")
      let compId  = li.data("item-id")
-      this.actor.rollCompetence(attrKey, compId)
+      this.actor.rollCompetence(compId)
    })
    html.find('.roll-arme-offensif').click((event) => {
      const li = $(event.currentTarget).parents(".item")
--- a/modules/heritiers-actor.js
+++ b/modules/heritiers-actor.js
@@ -38,40 +38,26 @@ export class HeritiersActor extends Actor {
    }

    if (data.type == 'personnage') {
-      const skills = await HeritiersUtility.loadCompendium("fvtt-les-heritiers.skills")
+      const skills = await HeritiersUtility.loadCompendium("fvtt-les-heritiers.competences")
      data.items = skills.map(i => i.toObject())
    }
    if (data.type == 'creature') {
      const skills = await HeritiersUtility.loadCompendium("fvtt-les-heritiers.skills-creatures")
      data.items = skills.map(i => i.toObject())
-      data.items.push( { name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-les-heritiers/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0"} } )
-      data.items.push( { name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-les-heritiers/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0"} } )
+      data.items.push({ name: "Arme naturelle 1", type: 'arme', img: "systems/fvtt-les-heritiers/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
+      data.items.push({ name: "Arme naturelle 2", type: 'arme', img: "systems/fvtt-les-heritiers/assets/icons/melee.webp", system: { typearme: "contact", bonusmaniementoff: 0, seuildefense: 0, degats: "0" } })
    }

    return super.create(data, options);
  }

-  /* -------------------------------------------- */
-  getBonusDefenseFromTalents() {
-    let talents = this.items.filter(item => item.type == "talent" && item.system.isautomated)
-    let bonus = 0
-    for (let talent of talents) {
-      for (let auto of talent.system.automations) {
-        if (auto.eventtype == "bonus-permanent" && auto.bonusname == "bonus-defensif") {
-          bonus += Number(auto.bonus || 0)
-        }
-      }
-    }
-    return bonus
-  }
-
  /* -------------------------------------------- */
  prepareArme(arme) {
    arme = duplicate(arme)
    let combat = this.getCombatValues()
    if (arme.system.typearme == "contact" || arme.system.typearme == "contactjet") {
-      let bonusDefense = this.getBonusDefenseFromTalents()
-      arme.system.competence = duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée") )
+      let bonusDefense = 0
+      arme.system.competence = duplicate(this.items.find(item => item.type == "competence" && item.name.toLowerCase() == "mêlée"))
      arme.system.attrKey = "pui"
      arme.system.totalDegats = arme.system.degats + "+" + combat.bonusDegatsTotal
      arme.system.totalOffensif = this.system.attributs.pui.value + arme.system.competence.system.niveau + arme.system.bonusmaniementoff
@@ -102,18 +88,18 @@ export class HeritiersActor extends Actor {
  }
  /* -------------------------------------------- */
  getMonnaies() {
-    return this.items.filter( it => it.type == "monnaie")
+    return this.items.filter(it => it.type == "monnaie")
  }

  /* -----------------------  --------------------- */
-  addMember( actorId) {
+  addMember(actorId) {
    let members = duplicate(this.system.members)
-    members.push( {id: actorId} )
-    this.update ({'system.members': members})
+    members.push({ id: actorId })
+    this.update({ 'system.members': members })
  }
-  async removeMember(actorId) {    
-    let members = this.system.members.filter(it => it.id != actorId )
-    this.update ({'system.members': members})
+  async removeMember(actorId) {
+    let members = this.system.members.filter(it => it.id != actorId)
+    this.update({ 'system.members': members })
  }

  /* -----------------------  --------------------- */
@@ -153,31 +139,39 @@ export class HeritiersActor extends Actor {
    for (let item of this.items) {
      item = duplicate(item)
      if (item.type == "competence") {
-        item.system.attribut1total = item.system.niveau + (this.system.attributs[item.system.attribut1]?.value || 0)
-        item.system.attribut2total = item.system.niveau + (this.system.attributs[item.system.attribut2]?.value || 0)
-        item.system.attribut3total = item.system.niveau + (this.system.attributs[item.system.attribut3]?.value || 0)
-        if (item.system.niveau == 0) {
-          item.system.attribut1total -= 3
-          item.system.attribut2total -= 3
-          item.system.attribut3total -= 3
-        }
-        item.system.attribut1label = this.system.attributs[item.system.attribut1]?.label || ""
-        item.system.attribut2label = this.system.attributs[item.system.attribut2]?.label || ""
-        item.system.attribut3label = this.system.attributs[item.system.attribut3]?.label || ""
        comp.push(item)
      }
    }
-    return comp.sort(function (a, b) {
-      let fa = a.name.toLowerCase(),
-        fb = b.name.toLowerCase();
-      if (fa < fb) {
-        return -1;
+    return HeritiersUtility.sortByName(comp)
+  }
+
+  /* -------------------------------------------- */
+  organizeUtileSkills() {
+    let comp = {}
+    for (let key in game.system.lesheritiers.config.competenceProfil) {
+      comp[key] = []
+    }
+    for (let item of this.items) {
+      if (item.type == "competence") {
+        if (item.system.categorie == "utile") {
+          comp[item.system.profil].push(item)
+        }
      }
-      if (fa > fb) {
-        return 1;
+    }
+    return comp
+  }
+
+  /* -------------------------------------------- */
+  organizeFutileSkills() {
+    let comp = []
+    for (let item of this.items) {
+      if (item.type == "competence") {
+        if (item.system.categorie == "futile") {
+          comp.push(item)
+        }
      }
-      return 0;
-    })
+    }
+    return HeritiersUtility.sortByName(comp)
  }

  /* -------------------------------------------- */
@@ -192,7 +186,7 @@ export class HeritiersActor extends Actor {
  /* -------------------------------------------- */
  getProtection() {
    let equipProtection = 0
-    for(let armor in this.items) {
+    for (let armor in this.items) {
      if (armor.type == "protection" && armor.system.equipped) {
        equipProtection += Number(armor.system.protection)
      }
@@ -206,15 +200,6 @@ export class HeritiersActor extends Actor {
  /* -------------------------------------------- */
  getCombatValues() {
    let combat = {
-      initBase: this.system.attributs.adr.value,
-      initTotal: this.system.attributs.adr.value + this.system.combat.initbonus,
-      bonusDegats: this.getBonusDegats(),
-      bonusDegatsTotal: this.getBonusDegats() + this.system.combat.bonusdegats,
-      vitesseBase: this.getVitesseBase(),
-      vitesseTotal: this.getVitesseBase() + this.system.combat.vitessebonus,
-      defenseBase: this.getDefenseBase(),
-      protection : this.getProtection(),
-      defenseTotal: this.getDefenseBase() + this.system.combat.defensebonus + this.getProtection() - this.getTotalAdversite()
    }
    return combat
  }
@@ -232,11 +217,6 @@ export class HeritiersActor extends Actor {
  prepareDerivedData() {

    if (this.type == 'personnage') {
-      let talentBonus = this.getVigueurBonus()
-      let vigueur = Math.floor((this.system.attributs.pui.value + this.system.attributs.tre.value) / 2) + talentBonus
-      if (vigueur != this.system.sante.vigueur) {
-        this.update({ 'system.sante.vigueur': vigueur })
-      }
    }

    super.prepareDerivedData()
@@ -380,13 +360,13 @@ export class HeritiersActor extends Actor {
  }

  /* -------------------------------------------- */
-  getAttribute(attrKey) {
-    return this.system.attributes[attrKey]
+  getCarac(attrKey) {
+    return duplicate(this.system.caracteristiques)
  }

  /* -------------------------------------------- */
  getBonusDegats() {
-    return 0; 
+    return 0;
  }

  /* -------------------------------------------- */
@@ -448,27 +428,27 @@ export class HeritiersActor extends Actor {
  /* -------------------------------------------- */
  computeRichesse() {
    let valueSC = 0
-    for(let monnaie of this.items) {
+    for (let monnaie of this.items) {
      if (monnaie.type == "monnaie") {
-        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite) 
+        valueSC += Number(monnaie.system.prixsc) * Number(monnaie.system.quantite)
      }
    }
-    return HeritiersUtility.computeMonnaieDetails( valueSC)
+    return HeritiersUtility.computeMonnaieDetails(valueSC)
  }

  /* -------------------------------------------- */
  computeValeurEquipement() {
    let valueSC = 0
-    for(let equip of this.items) {
+    for (let equip of this.items) {
      if (equip.type == "equipement" || equip.type == "arme" || equip.type == "protection") {
-        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1) 
-        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20 
-        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400 
+        valueSC += Number(equip.system.prixsc) * Number(equip.system.quantite ?? 1)
+        valueSC += (Number(equip.system.prixca) * Number(equip.system.quantite ?? 1)) * 20
+        valueSC += (Number(equip.system.prixpo) * Number(equip.system.quantite ?? 1)) * 400
      }
    }
-    return HeritiersUtility.computeMonnaieDetails( valueSC)
+    return HeritiersUtility.computeMonnaieDetails(valueSC)
  }
-  
+
  /* -------------------------------------------- */
  getCompetence(compId) {
    return this.items.get(compId)
@@ -494,7 +474,7 @@ export class HeritiersActor extends Actor {
    let maxDef = 0
    let bestArme
    for (let arme of defenseList) {
-      if (arme.type == "arme" ) {
+      if (arme.type == "arme") {
        arme = this.prepareArme(arme)
      }
      if (arme.system.totalDefensif > maxDef) {
@@ -532,32 +512,19 @@ export class HeritiersActor extends Actor {
  }

  /* -------------------------------------------- */
-  getCommonRollData(attrKey = undefined, compId = undefined, compName = undefined) {
+  getCommonRollData(compId = undefined, compName = undefined) {
    let rollData = HeritiersUtility.getBasicRollData()
    rollData.alias = this.name
    rollData.actorImg = this.img
    rollData.actorId = this.id
    rollData.tokenId = this.token?.id
    rollData.img = this.img
-    rollData.attributs = HeritiersUtility.getAttributs()
-    rollData.maitriseId = "none"
-    rollData.nbEclat = this.system.eclat.value
-    rollData.nbBA = this.system.bonneaventure.actuelle
-    rollData.nbAdversites = this.getTotalAdversite()
-    rollData.talents = []
+    rollData.caracList = this.getCarac()
+    rollData.caracKey = "agi"

-    if (attrKey) {
-      rollData.attrKey = attrKey
-      if (attrKey != "tochoose") {
-        rollData.actionImg = "systems/fvtt-les-heritiers/assets/icons/" + this.system.attributs[attrKey].labelnorm + ".webp"
-        rollData.attr = duplicate(this.system.attributs[attrKey])
-      }
-    }
    if (compId) {
      rollData.competence = duplicate(this.items.get(compId) || {})
-      rollData.maitrises = rollData.competence.system.predilections.filter(p => p.maitrise)
      rollData.actionImg = rollData.competence?.img
-      rollData.talents = this.searchRelevantTalents(rollData.competence)
    }
    if (compName) {
      rollData.competence = duplicate(this.items.find(item => item.name.toLowerCase() == compName.toLowerCase()) || {})
@@ -568,16 +535,16 @@ export class HeritiersActor extends Actor {

  /* -------------------------------------------- */
  async rollAttribut(attrKey, isInit = false) {
-    let rollData = this.getCommonRollData(attrKey)    
-    rollData.multiplier = (isInit)? 1 : 2
+    let rollData = this.getCommonRollData(attrKey)
+    rollData.multiplier = (isInit) ? 1 : 2
    rollData.isInit = isInit
    let rollDialog = await HeritiersRollDialog.create(this, rollData)
    rollDialog.render(true)
  }

  /* -------------------------------------------- */
-  async rollCompetence(attrKey, compId) {
-    let rollData = this.getCommonRollData(attrKey, compId)
+  async rollCompetence(compId) {
+    let rollData = this.getCommonRollData(compId)
    rollData.multiplier = 1 // Attr multiplier, always 1 in competence mode
    console.log("RollDatra", rollData)
    let rollDialog = await HeritiersRollDialog.create(this, rollData)
@@ -605,9 +572,9 @@ export class HeritiersActor extends Actor {
      arme = this.prepareArme(arme)
    }
    console.log("DEGATS", arme)
-    let roll = new Roll( "1d10+"+arme.system.totalDegats).roll({ async: false })
+    let roll = new Roll("1d10+" + arme.system.totalDegats).roll({ async: false })
    await HeritiersUtility.showDiceSoNice(roll, game.settings.get("core", "rollMode"));
-    let nbEtatPerdus = 0 
+    let nbEtatPerdus = 0
    if (targetVigueur) {
      nbEtatPerdus = Math.floor(roll.total / targetVigueur)
    }
--- a/modules/heritiers-config.js
+++ b/modules/heritiers-config.js
@@ -50,6 +50,23 @@ export const HERITIERS_CONFIG = {
  masquePouvoir: {
    "masque": "Masqué",
    "demasque": "Démasqué"
+  },
+  seuilsDifficulte: {
+    "0": "Aucun/Non applicable",
+    "5": "Enfantine",
+    "6": "Triviale",
+    "8": "Aisée",
+    "10": "Normale",
+    "12": "Compliquée",
+    "14": "Difficile",
+    "16": "Très Difficile",
+    "18": "Critique",
+    "20": "Insurmontable",
+    "22": "Surhumaine",
+    "24": "Epique",
+    "26": "Légendaire",
+    "28": "Mythique",
+    "30": "Divine"
  }
  
 }
--- a/modules/heritiers-item-sheet.js
+++ b/modules/heritiers-item-sheet.js
@@ -127,47 +127,7 @@ export class HeritiersItemSheet extends ItemSheet {
    html.find('.delete-subitem').click(ev => {
      this.deleteSubitem(ev);
    })
-    html.find('.edit-predilection').change(ev => {
-      const li = $(ev.currentTarget).parents(".prediction-item")
-      let index = li.data("prediction-index")
-      let pred = duplicate(this.object.system.predilections)
-      pred[index].name = ev.currentTarget.value
-      pred[index].id = pred[index].id || randomID(16)
-      this.object.update( { 'system.predilections': pred })
-    })
-    html.find('.edit-predilection-description').change(ev => {
-      const li = $(ev.currentTarget).parents(".prediction-item")
-      let index = li.data("prediction-index")
-      let pred = duplicate(this.object.system.predilections)
-      pred[index].description = ev.currentTarget.value
-      pred[index].id = pred[index].id || randomID(16)
-      this.object.update( { 'system.predilections': pred })
-    })    
-    html.find('.predilection-acquise').change(ev => {
-      const li = $(ev.currentTarget).parents(".prediction-item")
-      let index = li.data("prediction-index")
-      let pred = duplicate(this.object.system.predilections)
-      pred[index].acquise = ev.currentTarget.checked
-      pred[index].id = pred[index].id || randomID(16)
-      this.object.update( { 'system.predilections': pred })
-    })          
-    html.find('.predilection-maitrise').change(ev => {
-      const li = $(ev.currentTarget).parents(".prediction-item")
-      let index = li.data("prediction-index")
-      let pred = duplicate(this.object.system.predilections)
-      pred[index].maitrise = ev.currentTarget.checked
-      pred[index].id = pred[index].id || randomID(16)
-      this.object.update( { 'system.predilections': pred })
-    })      
-    html.find('.predilection-used').change(ev => {
-      const li = $(ev.currentTarget).parents(".prediction-item")
-      let index = li.data("prediction-index")
-      let pred = duplicate(this.object.system.predilections)
-      pred[index].used = ev.currentTarget.checked
-      pred[index].id = pred[index].id || randomID(16)
-      this.object.update( { 'system.predilections': pred })
-    })    
-    
+
    html.find('#add-specialite').click(ev => {
      let spec = duplicate(this.object.system.specialites)
      spec.push( { name: "Nouvelle Spécialité", id: randomID(16), used: false }) 
@@ -180,6 +140,22 @@ export class HeritiersItemSheet extends ItemSheet {
      spec.splice(index,1)
      this.object.update( { 'system.specialites': spec })
    })
+    html.find('.edit-specialite').change(ev => {
+      const li = $(ev.currentTarget).parents(".specialite-item")
+      let index = li.data("specialite-index")
+      let spec = duplicate(this.object.system.specialites)
+      spec[index].name = ev.currentTarget.value
+      spec[index].id = spec[index].id || randomID(16)
+      this.object.update( { 'system.specialites': spec })
+    })
+    html.find('.edit-specialite-description').change(ev => {
+      const li = $(ev.currentTarget).parents(".specialite-item")
+      let index = li.data("specialite-index")
+      let spec = duplicate(this.object.system.specialites)
+      spec[index].description = ev.currentTarget.value
+      spec[index].id = spec[index].id || randomID(16)
+      this.object.update( { 'system.specialites': spec })
+    })    

    html.find('#add-automation').click(ev => {
      let autom = duplicate(this.object.system.automations)
--- a/modules/heritiers-roll-dialog.js
+++ b/modules/heritiers-roll-dialog.js
@@ -3,12 +3,12 @@ import { HeritiersUtility } from "./heritiers-utility.js";
 export class HeritiersRollDialog extends Dialog {

  /* -------------------------------------------- */
-  static async create(actor, rollData ) {
+  static async create(actor, rollData) {

    let options = { classes: ["HeritiersDialog"], width: 320, height: 'fit-content', 'z-index': 99999 };
    let html = await renderTemplate('systems/fvtt-les-heritiers/templates/roll-dialog-generic.html', rollData);

-    return new HeritiersRollDialog(actor, rollData, html, options );
+    return new HeritiersRollDialog(actor, rollData, html, options);
  }

  /* -------------------------------------------- */
@@ -16,22 +16,28 @@ export class HeritiersRollDialog extends Dialog {
    let conf = {
      title: "Test de Capacité",
      content: html,
-      buttons: { 
+      buttons: {
+        rolld8: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "Lancer 1d8",
+          callback: () => { this.roll("d8") }
+        },
        rolld10: {
-            icon: '<i class="fas fa-check"></i>',
-            label: "Lancer 1d10",
-            callback: () => { this.roll("d10") } 
-          },
-          rolld20: {
-            icon: '<i class="fas fa-check"></i>',
-            label: "Lancer 1d20",
-            callback: () => { this.roll("d20") } 
-          },
-          cancel: {
-            icon: '<i class="fas fa-times"></i>',
-            label: "Annuler",
-            callback: () => { this.close() }
-        } },
+          icon: '<i class="fas fa-check"></i>',
+          label: "Lancer 1d10",
+          callback: () => { this.roll("d10") }
+        },
+        rolld12: {
+          icon: '<i class="fas fa-check"></i>',
+          label: "Lancer 1d12",
+          callback: () => { this.roll("d12") }
+        },
+        cancel: {
+          icon: '<i class="fas fa-times"></i>',
+          label: "Annuler",
+          callback: () => { this.close() }
+        }
+      },
      close: close
    }

@@ -42,9 +48,9 @@ export class HeritiersRollDialog extends Dialog {
  }

  /* -------------------------------------------- */
-  roll ( dice) {
+  roll(dice) {
    this.rollData.mainDice = dice
-    HeritiersUtility.rollHeritiers( this.rollData )
+    HeritiersUtility.rollHeritiers(this.rollData)
  }


@@ -56,25 +62,16 @@ export class HeritiersRollDialog extends Dialog {
    function onLoad() {
    }
    $(function () { onLoad(); });
-    
-    html.find('#modificateur').change(async (event) =>  {
-      this.rollData.modificateur = Number(event.currentTarget.value)
+
+    html.find('#sdValue').change(async (event) => {
+      this.rollData.sdValue = Number(event.currentTarget.value)
    })
-    html.find('#difficulte').change(async (event) =>  {
-      this.rollData.difficulte = Number(event.currentTarget.value)
-    })
-    html.find('#attrKey').change(async (event) =>  {
-      this.rollData.attrKey = String(event.currentTarget.value)
-    })    
-    html.find('#select-maitrise').change(async (event) =>  {
-      this.rollData.maitriseId = String(event.currentTarget.value)
-    })
-    html.find('#competence-talents').change((event) => {
-      this.rollData.selectedTalents = $('#competence-talents').val()      
+    html.find('#caracKey').change(async (event) => {
+      this.rollData.caracKey = String(event.currentTarget.value)
    })
    html.find('#bonus-malus-context').change((event) => {
-      this.rollData.bonusMalusContext = Number(event.currentTarget.value)      
+      this.rollData.bonusMalusContext = Number(event.currentTarget.value)
    })
-    
+
  }
 }
--- a/modules/heritiers-utility.js
+++ b/modules/heritiers-utility.js
@@ -44,30 +44,20 @@ export class HeritiersUtility {

  }

-  /* -------------------------------------------- */
-  static getModificateurOptions() {
-    let opt = []
-    for (let i = -15; i <= 15; i++) {
-      opt.push(`<option value="${i}">${i}</option>`)
-    }
-    return opt.concat("\n")
-  }

  /* -------------------------------------------- */
-  static getPointAmeOptions() {
-    let opt = []
-    for (let i = 1; i <= 20; i++) {
-      opt.push(`<option value="${i}">${i}</option>`)
-    }
-    return opt.concat("\n")
-  }
-
-  /* -------------------------------------------- */
-  static getAttributs() {
-    return { adr: "Adresse", pui: "Puissance", cla: "Clairvoyance", pre: "Présence", tre: "Trempe" }
-  }
-  /* -------------------------------------------- */
-  static pushInitiativeOptions(html, options) {
+  static sortByName(table) {  
+    return table.sort(function (a, b) {
+      let fa = a.name.toLowerCase(),
+        fb = b.name.toLowerCase();
+      if (fa < fb) {
+        return -1;
+      }
+      if (fa > fb) {
+        return 1;
+      }
+      return 0;
+    })
  }

  /* -------------------------------------------- */
@@ -77,7 +67,7 @@ export class HeritiersUtility {

  /* -------------------------------------------- */
  static async ready() {
-    const skills = await HeritiersUtility.loadCompendium("fvtt-les-heritiers.skills")
+    const skills = await HeritiersUtility.loadCompendium("fvtt-les-heritiers.competences")
    this.skills = skills.map(i => i.toObject())

  }
@@ -129,11 +119,7 @@ export class HeritiersUtility {
      'systems/fvtt-les-heritiers/templates/partial-item-header.html',
      'systems/fvtt-les-heritiers/templates/partial-item-description.html',
      'systems/fvtt-les-heritiers/templates/partial-item-nav.html',
-      'systems/fvtt-les-heritiers/templates/partial-list-niveau.html',
-      'systems/fvtt-les-heritiers/templates/partial-item-prix.html',
-      'systems/fvtt-les-heritiers/templates/partial-sante-etat.html',
-      'systems/fvtt-les-heritiers/templates/partial-automation.html',
-      'systems/fvtt-les-heritiers/templates/hud-adversites.html',
+      'systems/fvtt-les-heritiers/templates/partial-list-niveau.html'
    ]
    return loadTemplates(templatePaths);
  }
@@ -297,77 +283,42 @@ export class HeritiersUtility {
  /* -------------------------------------------- */
  static computeResult(rollData) {
    rollData.diceResult = rollData.roll.terms[0].results[0].result
-    if (rollData.mainDice.includes("d20")) {
-      let diceValue = rollData.roll.terms[0].results[0].result
-      if (diceValue % 2 == 1) {
-        //console.log("PAIR/IMP2", diceValue)
-        rollData.finalResult -= rollData.roll.terms[0].results[0].result // Substract value
-        if (diceValue == 1 || diceValue == 11) {
-          rollData.isDramatique = true
-          rollData.isSuccess = false
-        }
+    if (rollData.mainDice.includes("d10")) {
+      if ( rollData.diceResult == 1) {
+        rollData.finalResult -= 3
      }
    }
-
-    //console.log("Result : ", rollData)
-    if (rollData.difficulte > 0 && !rollData.isDramatique) {
-      rollData.isSuccess = (rollData.finalResult >= rollData.difficulte)
-      rollData.isHeroique = ((rollData.finalResult - rollData.difficulte) >= 10)
-      rollData.isDramatique = ((rollData.finalResult - rollData.difficulte) <= -10)
+    if (rollData.mainDice.includes("d12")) {
+      if ( rollData.diceResult == 1 || rollData.diceResult == 2) {
+        rollData.finalResult -= 5
+      }
+    }
+    //rollData.finalResult = Math.max(rollData.finalResult, 0)
+    //console.log("Result : ", rollData)
+    if (rollData.sdValue > 0 ) {
+      rollData.marge = rollData.finalResult - rollData.sdValue
+      rollData.isSuccess = (rollData.finalResult >= rollData.sdValue)
+      rollData.isCriticalSuccess = ((rollData.finalResult - rollData.sdValue) >= 7)
+      rollData.isCriticalFailure = ((rollData.finalResult - rollData.sdValue) <= -7)
    }
-
  }

  /* -------------------------------------------- */
  static async rollHeritiers(rollData) {

    let actor = this.getActorFromRollData(rollData)
-    if (rollData.attrKey == "tochoose") { // No attr selected, force address
-      rollData.attrKey = "adr"
-    }
-    if (!rollData.attr) {
-      rollData.actionImg = "systems/fvtt-les-heritiers/assets/icons/" + actor.system.attributs[rollData.attrKey].labelnorm + ".webp"
-      rollData.attr = duplicate(actor.system.attributs[rollData.attrKey])
-    }
-
-    if (rollData.maitriseId != "none") {
-      rollData.selectedMaitrise = rollData.maitrises.find(p => p.id == rollData.maitriseId)
-      rollData.diceFormula = "2" + rollData.mainDice + "kh"
-    } else {
-      rollData.diceFormula = "1" + rollData.mainDice
-    }
+    //rollData.actionImg = "systems/fvtt-les-heritiers/assets/icons/" + actor.system.attributs[rollData.attrKey].labelnorm + ".webp"
+    rollData.carac = duplicate(actor.system.caracteristiques[rollData.caracKey])
+    rollData.diceFormula = rollData.mainDice

    //console.log("BEFORE COMP", rollData)
    if (rollData.competence) {
-      rollData.predilections = duplicate(rollData.competence.system.predilections.filter(pred => pred.acquise && !pred.maitrise && !pred.used) || [])
      let compmod = (rollData.competence.system.niveau == 0) ? -3 : 0
-      rollData.diceFormula += `+${rollData.attr.value}+${rollData.competence.system.niveau}+${rollData.modificateur}+${compmod}`
-
-      if (rollData.selectedTalents && rollData.selectedTalents.length > 0) {
-        for (let id of rollData.selectedTalents) {
-          let talent = rollData.talents.find(t => t._id == id)
-          let bonusOK = true
-          if (talent.system.baCost) {
-            bonusOK = actor.checkBonneAventure(talent.system.baCost)
-            if (bonusOK) {
-              actor.changeBonneAventure(-talent.system.baCost)
-            } else {
-              ui.notifications.warn("Vous n'avez pas assez de points de Bonne Aventure !")
-            }
-          }
-          if (bonusOK) {
-            rollData.diceFormula += `+${talent.system.bonus}`
-          }
-        }
-      }
-      rollData.diceFormula += `+${rollData.bonusMalusContext}`
+      rollData.diceFormula += `+${rollData.carac.value}+${rollData.competence.system.niveau}+${rollData.bonusMalusContext}+${compmod}`
    } else {
      rollData.diceFormula += `+${rollData.attr.value}*${rollData.multiplier}+${rollData.modificateur}+${rollData.bonusMalusContext}`
    }

-    // Ajout adversités
-    rollData.diceFormula += `-${rollData.nbAdversites}`
-
    if (rollData.arme && rollData.arme.type == "arme") {
      rollData.diceFormula += `+${rollData.arme.system.bonusmaniementoff}`
    }
@@ -495,10 +446,8 @@ export class HeritiersUtility {
    let rollData = {
      rollId: randomID(16),
      rollMode: game.settings.get("core", "rollMode"),
-      modificateursOptions: this.getModificateurOptions(),
-      pointAmeOptions: this.getPointAmeOptions(),
-      difficulte: 0,
-      modificateur: 0,
+      sdList: game.system.lesheritiers.config.seuilsDifficulte,
+      sdValue: 0,
      bonusMalusContext: 0
    }
    return rollData