Fix stun hindrances

MDL/ADRL fixes + MR fixes
2024-04-11 16:37:42 +02:00 · 2023-09-19 15:46:02 +02:00 · 2023-09-19 13:52:09 +02:00 · 2023-09-19 12:47:55 +02:00 · 2023-09-19 11:41:58 +02:00 · 2023-09-18 18:03:00 +02:00
25 changed files with 1029 additions and 279 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,14 @@
+.vscode/settings.json
+.idea
+.history
+todo.md
+/.vscode
+/ignored/
+/node_modules/
+/jsconfig.json
+/package.json
+/package-lock.json
+/packs/*/
+/packs/*/CURRENT
+/packs/*/LOG
+/packs/*/LOCK
--- a/images/dice/hindrance-dice-empty.png
+++ b/images/dice/hindrance-dice-empty.png
--- a/images/dice/hindrance-dice.png
+++ b/images/dice/hindrance-dice.png
--- a/lang/en.json
+++ b/lang/en.json
@ -1,25 +1,33 @@
 {
-  "ITEM": {
-    "TypeRace": "Race",
-    "TypeRole": "Role",
-    "TypeAbility": "Ability",
-    "TypeSpecialisation": "Specialisation",
-    "TypePerk": "Perk",
-    "TypePower": "Power",
-    "TypeArmor": "Armor",
-    "TypeShield": "Shield",
-    "TypeEquipment": "Equipment",
-    "TypeWeapon": "Weapon",
-    "TypeEffect": "Effect",
-    "TypeMoney": "Money",
-    "TypeVirtue": "Virtue",
-    "TypeVice": "Vice",
-    "TypeVehiclehull": "Vehicule Hull",
-    "TypePowercoremodule": "Power Core Module",
-    "TypeMobilitymodule": "Mobility Module",
-    "TypeCombatmodule": "Combat Module",
-    "TypeVehiclemodule": "Vehicle Module",
-    "TypeVehicleweaponmodule" : "Vehicle Weapon Module",
-    "TypePropulsionmodule": "Propulsion module"
- }
+  "TYPES": {
+    "Actor": {
+      "character": "Character",
+      "npc": "NPC",
+      "vehicle": "Vehicle"
+    },
+    "Item": {
+      "race": "Race",
+      "role": "Role",
+      "ability": "Ability",
+      "specialisation": "Specialisation",
+      "perk": "Perk",
+      "power": "Power",
+      "armor": "Armor",
+      "shield": "Shield",
+      "equipment": "Equipment",
+      "weapon": "Weapon",
+      "effect": "Effect",
+      "money": "Money",
+      "virtue": "Virtue",
+      "vice": "Vice",
+      "vehiclehull": "Vehicule Hull",
+      "powercoremodule": "Power Core Module",
+      "mobilitymodule": "Mobility Module",
+      "combatmodule": "Combat Module",
+      "vehiclemodule": "Vehicle Module",
+      "vehicleweaponmodule" : "Vehicle Weapon Module",
+      "propulsionmodule": "Propulsion module"
+  
+    }
+  }
 }
--- a/modules/pegasus-actor-sheet.js
+++ b/modules/pegasus-actor-sheet.js
@ -38,9 +38,9 @@ export class PegasusActorSheet extends ActorSheet {
      cssClass: this.isEditable ? "editable" : "locked",
      data: actorData.system,
      traumaState: this.actor.getTraumaState(),
-      effects: this.object.effects.map(e => foundry.utils.deepClone(e.data)),
      limited: this.object.limited,
      specs: this.actor.getSpecs( ),
+      config: game.system.pegasus.config,
      optionsDiceList: PegasusUtility.getOptionsDiceList(),
      optionsLevel: PegasusUtility.getOptionsLevel(),
      weapons: this.actor.checkAndPrepareEquipments( duplicate(this.actor.getWeapons()) ),
--- a/modules/pegasus-actor.js
+++ b/modules/pegasus-actor.js
@ -92,9 +92,7 @@ export class PegasusActor extends Actor {
      return actor;
    }

-    if (data.type == 'character') {
-    }
-    if (data.type == 'npc') {
+    if (data.type == 'character' || this.type == 'npc') {
    }


@ -112,11 +110,19 @@ export class PegasusActor extends Actor {

  /* -------------------------------------------- */
  prepareDerivedData() {
+
+    if (this.system.secondary.stealthhealth) {
+      this.update({ "system.secondary": { "-=stealthhealth": null } })
+    }
+    if (this.system.secondary.socialhealth) {
+      this.update({ "system.secondary": { "-=socialhealth": null } })
+    }
+
    if (!this.traumaState) {
      this.traumaState = "none"
    }

-    if (this.type == 'character') {
+    if (this.type == 'character' || this.type == 'npc') {
      this.computeNRGHealth();
      this.system.encCapacity = this.getEncumbranceCapacity()
      this.buildContainerTree()
@ -489,7 +495,7 @@ export class PegasusActor extends Actor {
  /* -------------------------------------------- */
  async activateViceOrVirtue(itemId) {
    let item = this.items.find(item => item.id == itemId)
-    if (item && item.system) {
+    if (item?.system) {
      let nrg = duplicate(this.system.nrg)
      if (!item.system.activated) { // Current value

@ -575,7 +581,7 @@ export class PegasusActor extends Actor {
  /* -------------------------------------------- */
  async activatePower(itemId) {
    let item = this.items.find(item => item.id == itemId)
-    if (item && item.system) {
+    if (item?.system) {

      let nrg = duplicate(this.system.nrg)
      if (!item.system.activated) { // Current value
@ -668,7 +674,7 @@ export class PegasusActor extends Actor {
    for (let spec of specThreat) {
      tl += PegasusUtility.getDiceValue(spec.system.level)
    }
-    tl += this.system.nrg.absolutemax + this.system.secondary.health.max + this.system.secondary.delirium.max
+    tl += this.system.nrg.absolutemax /* NO MORE USED + this.system.secondary.health.max + this.system.secondary.delirium.max*/
    tl += this.getPerks().length * 5

    let weapons = this.getWeapons()
@ -758,16 +764,30 @@ export class PegasusActor extends Actor {

  /* -------------------------------------------- */
  modifyStun(incDec) {
+    if (incDec < 0 && (this.system.secondary.confidence.status == "anxious" || this.system.secondary.confidence.status == "lostface")) {
+      ui.notifications.warn("Unable to recover STUN because of Confidence status : " + this.system.secondary.confidence.status)
+      return
+    }
    let myself = this
    let combat = duplicate(myself.system.combat)
    combat.stunlevel += incDec
+    let daze = this.effects.find(e => e.label == "Daze")
+
+    if (daze && combat.stunlevel == 0) {
+      this.deleteEmbeddedDocuments("ActiveEffect", [daze.id])
+    }
    if (combat.stunlevel >= 0) {
-      myself.update({ 'system.combat': combat } )
+      myself.update({ 'system.combat': combat })
      let chatData = {
        user: game.user.id,
        rollMode: game.settings.get("core", "rollMode"),
        whisper: [game.user.id].concat(ChatMessage.getWhisperRecipients('GM'))
      }
+      if (!daze) {
+        this.createEmbeddedDocuments("ActiveEffect", [
+          { label: 'Daze', icon: 'icons/svg/daze.svg', flags: { core: { statusId: 'daze' } } }
+        ])
+      }
      if (incDec > 0) {
        chatData.content = `<div>${this.name} suffered a Stun level.</div`
      } else {
@ -781,15 +801,21 @@ export class PegasusActor extends Actor {
    if (stunAbove > 0) {
      ChatMessage.create({ content: `${this.name} Stun threshold has been exceeded.` })
    }
+    /* NO MORE AUTOMATION HERE
    if (incDec > 0 && stunAbove > 0) {
      let delirium = duplicate(myself.system.secondary.delirium)
      delirium.value -= incDec
      myself.update({ 'system.secondary.delirium': delirium })
-    }
+    }*/
  }

  /* -------------------------------------------- */
  modifyMomentum(incDec) {
+    if (this.system.combat.stunlevel > 0) {
+      ui.notifications.warn("Unable to gain/use Momentum while stunned")
+      return
+    }
+
    let momentum = duplicate(this.system.momentum)
    momentum.value += incDec
    this.update({ 'system.momentum': momentum })
@ -950,13 +976,13 @@ export class PegasusActor extends Actor {
  async equipGear(equipmentId) {
    let item = this.items.find(item => item.id == equipmentId);
    if (item && item.system) {
-      let update = { _id: item.id, "data.equipped": !item.system.equipped };
+      let update = { _id: item.id, "system.equipped": !item.system.equipped };
      await this.updateEmbeddedDocuments('Item', [update]); // Updates one EmbeddedEntity
    }
  }
  /* -------------------------------------------- */
  getInitiativeScore(combatId, combatantId) {
-    if (this.type == 'character') {
+    if (this.type == 'character' || this.type == 'npc') {
      this.rollMR(true, combatId, combatantId)
    }
    if (this.type == 'vehicle') {
@ -1007,7 +1033,7 @@ export class PegasusActor extends Actor {
  /* -------------------------------------------- */
  getStat(statKey) {
    let stat
-    if (this.type == "character" && statKey == 'mr') {
+    if ((this.type == "character" || this.type == 'npc') && statKey == 'mr') {
      stat = duplicate(this.system.mr)
    } else {
      stat = duplicate(this.system.statistics[statKey])
@ -1145,7 +1171,7 @@ export class PegasusActor extends Actor {
  async updatePerkUsed(itemId, index, checked) {
    let item = this.items.get(itemId)
    if (item && index) {
-      let key = "data.used" + index
+      let key = "system.used" + index
      await this.updateEmbeddedDocuments('Item', [{ _id: itemId, [`${key}`]: checked }])
      item = this.items.get(itemId) // Refresh
      if (item.system.nbuse == "next1action" && item.system.used1) {
@ -1184,7 +1210,7 @@ export class PegasusActor extends Actor {

  /* -------------------------------------------- */
  incDecNRG(value) {
-    if (this.type == "character") {
+    if (this.type == "character" || this.type == 'npc') {
      let nrg = duplicate(this.system.nrg)
      nrg.value += value
      if (nrg.value >= 0 && nrg.value <= nrg.max) {
@ -1237,24 +1263,6 @@ export class PegasusActor extends Actor {
          nrg.max += item.system.features.nrgcost.value
          await this.update({ 'system.nrg': nrg })
        }
-        if (item.system.features.bonushealth.flag) {
-          let health = duplicate(this.system.secondary.health)
-          health.value -= Number(item.system.features.bonushealth.value) || 0
-          health.max -= Number(item.system.features.bonushealth.value) || 0
-          await this.update({ 'system.secondary.health': health })
-        }
-        if (item.system.features.bonusdelirium.flag) {
-          let delirium = duplicate(this.system.secondary.delirium)
-          delirium.value -= Number(item.system.features.bonusdelirium.value) || 0
-          delirium.max -= Number(item.system.features.bonusdelirium.value) || 0
-          await this.update({ 'system.secondary.delirium': delirium })
-        }
-        if (item.system.features.bonusnrg.flag) {
-          let nrg = duplicate(this.system.nrg)
-          nrg.value -= Number(item.system.features.bonusnrg.value) || 0
-          nrg.max -= Number(item.system.features.bonusnrg.value) || 0
-          await this.update({ 'system.nrg': nrg })
-        }
        this.disableWeaverPerk(item)
        PegasusUtility.createChatWithRollMode(item.name, {
          content: await renderTemplate(`systems/fvtt-pegasus-rpg/templates/chat-perk-ready.html`, { name: this.name, perk: duplicate(item) })
@ -1287,6 +1295,7 @@ export class PegasusActor extends Actor {
            ui.notifications.warn("Not enough NRG to activate the Perk " + item.name)
          }
        }
+        /* NO MORE USED
        if (item.system.features.bonushealth.flag) {
          let health = duplicate(this.system.secondary.health)
          health.value += Number(item.system.features.bonushealth.value) || 0
@ -1298,7 +1307,7 @@ export class PegasusActor extends Actor {
          delirium.value += Number(item.system.features.bonusdelirium.value) || 0
          delirium.max += Number(item.system.features.bonusdelirium.value) || 0
          await this.update({ 'system.secondary.delirium': delirium })
-        }
+        }*/
        if (item.system.features.bonusnrg.flag) {
          let nrg = duplicate(this.system.nrg)
          nrg.value += Number(item.system.features.bonusnrg.value) || 0
@ -1334,15 +1343,12 @@ export class PegasusActor extends Actor {
  /* -------------------------------------------- */
  getTraumaState() {
    this.traumaState = "none"
-    if (this.type == "character") {
-      let negDelirium = -Math.floor((this.system.secondary.delirium.max + 1) / 2)
-      if (this.type == "character") {
-        if (this.system.secondary.delirium.value <= 0 && this.system.secondary.delirium.value >= negDelirium) {
-          this.traumaState = "trauma"
-        }
-        if (this.system.secondary.delirium.value < negDelirium) {
-          this.traumaState = "severetrauma"
-        }
+    if (this.type == "character" || this.type == 'npc') {
+      if (this.system.secondary.delirium.status == "trauma") {
+        this.traumaState = "trauma"
+      }
+      if (this.system.secondary.delirium.status == "severetrauma" || this.system.secondary.delirium.status == "defeated") {
+        this.traumaState = "severetrauma"
      }
    }
    return this.traumaState
@ -1439,35 +1445,6 @@ export class PegasusActor extends Actor {

    if (this.isOwner || game.user.isGM) {
      let updates = {}
-      let phyDiceValue = PegasusUtility.getDiceValue(this.system.statistics.phy.value) + this.system.secondary.health.bonus + this.system.statistics.phy.mod + PegasusUtility.getDiceValue(this.system.statistics.phy.bonuseffect);
-      if (phyDiceValue != this.system.secondary.health.max) {
-        updates['system.secondary.health.max'] = phyDiceValue
-      }
-      if (this.computeValue) {
-        updates['system.secondary.health.value'] = phyDiceValue
-      }
-      let mndDiceValue = PegasusUtility.getDiceValue(this.system.statistics.mnd.value) + this.system.secondary.delirium.bonus + this.system.statistics.mnd.mod + PegasusUtility.getDiceValue(this.system.statistics.mnd.bonuseffect);
-      if (mndDiceValue != this.system.secondary.delirium.max) {
-        updates['system.secondary.delirium.max'] = mndDiceValue
-      }
-      if (this.computeValue) {
-        updates['system.secondary.delirium.value'] = mndDiceValue
-      }
-      let stlDiceValue = PegasusUtility.getDiceValue(this.system.statistics.stl.value) + this.system.secondary.stealthhealth.bonus + this.system.statistics.stl.mod + PegasusUtility.getDiceValue(this.system.statistics.stl.bonuseffect);
-      if (stlDiceValue != this.system.secondary.stealthhealth.max) {
-        updates['system.secondary.stealthhealth.max'] = stlDiceValue
-      }
-      if (this.computeValue) {
-        updates['system.secondary.stealthhealth.value'] = stlDiceValue
-      }
-
-      let socDiceValue = PegasusUtility.getDiceValue(this.system.statistics.soc.value) + this.system.secondary.socialhealth.bonus + this.system.statistics.soc.mod + PegasusUtility.getDiceValue(this.system.statistics.soc.bonuseffect);
-      if (socDiceValue != this.system.secondary.socialhealth.max) {
-        updates['system.secondary.socialhealth.max'] = socDiceValue
-      }
-      if (this.computeValue) {
-        updates['system.secondary.socialhealth.value'] = socDiceValue
-      }

      let nrgValue = PegasusUtility.getDiceValue(this.system.statistics.foc.value) + this.system.nrg.mod + this.system.statistics.foc.mod + PegasusUtility.getDiceValue(this.system.statistics.foc.bonuseffect)
      if (nrgValue != this.system.nrg.absolutemax) {
@ -1490,7 +1467,7 @@ export class PegasusActor extends Actor {
        updates['system.momentum.max'] = momentum
      }

-      let mrLevel = (this.system.statistics.agi.value + this.system.statistics.str.value) - this.system.statistics.phy.value
+      let mrLevel = (this.system.statistics.agi.value + this.system.statistics.agi.mod + this.system.statistics.str.value + this.system.statistics.str.mod) - (this.system.statistics.phy.value + this.system.statistics.phy.mod)
      mrLevel = (mrLevel < 1) ? 1 : mrLevel;
      if (mrLevel != this.system.mr.value) {
        updates['system.mr.value'] = mrLevel
@ -1511,11 +1488,11 @@ export class PegasusActor extends Actor {
      }

      let race = this.getRace()
-      if (race && race.name && (race.name != this.system.biodata.racename)) {
+      if (race?.name && (race.name != this.system.biodata.racename)) {
        updates['system.biodata.racename'] = race.name
      }
      let role = this.getRole()
-      if (role && role.name && (role.name != this.system.biodata.rolename)) {
+      if (role?.name && (role.name != this.system.biodata.rolename)) {
        updates['system.biodata.rolename'] = role.name
      }
      if (Object.entries(updates).length > 0) {
@ -1523,27 +1500,138 @@ export class PegasusActor extends Actor {
      }
      this.computeThreatLevel()
    }
-
    if (this.isOwner || game.user.isGM) {
      // Update current hindrance level
-      let hindrance = this.system.combat.hindrancedice
+      let hindrance = 0; //this.system.combat.hindrancedice
      if (!this.checkIgnoreHealth()) {
-        if (this.system.secondary.health.value < 0) {
-          if (this.system.secondary.health.value < -Math.floor((this.system.secondary.health.max + 1) / 2)) { // Severe wounded
-            hindrance += 3
-          } else {
-            hindrance += 1
+        if (this.system.secondary.health.status == "wounded") {
+          hindrance += 1
+        }
+        if (this.system.secondary.health.status == "severlywounded" || this.system.secondary.health.status == "defeated") {
+          hindrance += 3
+        }
+        /* Manage confidence */
+        if (this.system.secondary.confidence.status == "shaken" || this.system.secondary.confidence.status == "anxious" ||
+          this.system.secondary.confidence.status == "lostface") {
+          if (!this.items.find(it => it.name.toLowerCase() == "fear" && it.type == "effect")) {
+            let effect = await PegasusUtility.getEffectFromCompendium("Fear")
+            this.createEmbeddedDocuments('Item', [effect])
          }
+        } else { // Remove fear if healed
+          let fear = this.items.find(it => it.name.toLowerCase() == "fear" && it.type == "effect")
+          if (fear) {
+            this.deleteEmbeddedDocuments('Item', [fear.id])
+          }
+        }
+        /* Manage flag state for status */
+        this.defeatedDisplayed = this.defeatedDisplayed && this.system.secondary.health.status != "defeated"
+        this.deliriumDisplayed = this.deliriumDisplayed && this.system.secondary.delirium.status != "defeated"
+        this.concealmentDisplayed = this.concealmentDisplayed && this.system.secondary.concealment.status != "defeated"
+        this.confidenceDisplayed = this.confidenceDisplayed && this.system.secondary.confidence.status != "defeated"
+        /* Then display relevant messages */
+        if (!this.defeatedDisplayed && this.system.secondary.health.status == "defeated") {
+          ChatMessage.create({ content: `DEFEATED : ${this.name} must make a Death Save!` })
+          this.defeatedDisplayed = true
+        }
+        if (!this.deliriumDisplayed && this.system.secondary.delirium.status == "defeated") {
+          ChatMessage.create({ content: `DEFEATED : ${this.name} must make a Madness Check!` })
+          this.deliriumDisplayed = true
+        }
+        if (!this.concealmentDisplayed && this.system.secondary.concealment.status == "located") {
+          ChatMessage.create({ content: `${this.name} has been discovered! You can not longer hide and either must fight/surrender or make a run for it` })
+          this.concealmentDisplayed = true
+        }
+        if (!this.confidenceDisplayed && this.system.secondary.confidence.status == "lostface") {
+          ChatMessage.create({ content: `${this.name} have Lost Face! You can not longer make any Social Rolls, all social rolls against your character is considered an automatic success until healed!` })
+          this.confidenceDisplayed = true
        }
      }
      this.system.combat.hindrancedice = hindrance
      this.getTraumaState()
      this.cleanupPerksIfTrauma()
-      await this.parseStatEffects()
+      this.parseStatEffects()
+      this.parseDamageValues()
      await this.parseStatusEffects()
    }
  }

+  /* -------------------------------------------- */
+  getArmorResistanceBonus() {
+    let bonus = 0
+    for (let a of armors) {
+      bonus += Number(a.system.resistance)
+    }
+    return bonus
+  }
+  /* -------------------------------------------- */
+  parseDamageValues() {
+    if (this.system.biodata.noautobonus) { // If we are in "no-bonus mode
+      return
+    }
+    let updates = []
+    let role = this.getRole() // Get the role for optionnal bonuses
+    let roleBonus = 0
+
+    /* Get MDL bonus */
+    let meleeBonus = 0
+    let effects = this.items.filter(effect => effect.type == "effect" && effect.system.affectstatus && effect.system.affectstatus == "mdl" && (Number(effect.system.effectlevel) > 0))
+    for (let e of effects) {
+      meleeBonus += Number(e.system.effectlevel)
+    }
+    this.baseMDL = this.system.biodata.sizenum + this.system.biodata.sizebonus + this.system.statistics.str.value +
+      this.system.statistics.str.mod + this.system.statistics.str.bonuseffect + meleeBonus
+    let weaponsMelee = this.items.filter(it => it.type == "weapon" && it.system.damagestatistic.toLowerCase() == "str")
+    for (let w of weaponsMelee) {
+      let damage = this.baseMDL + Number(w.system.damage)
+      if (damage != w.system.mdl) {
+        updates.push({ _id: w.id, "system.mdl": damage })
+      }
+    }
+
+    let rangedBonus = 0
+    effects = this.items.filter(effect => effect.type == "effect" && effect.system.affectstatus && effect.system.affectstatus == "rdl" && (Number(effect.system.effectlevel) > 0))
+    for (let e of effects) {
+      rangedBonus += Number(e.system.effectlevel)
+    }
+    if (role?.name?.toLowerCase() == "ranged") { // Add ranged bonus to ADRL
+      roleBonus = this.getRoleLevel()
+    }
+    this.baseRDL = roleBonus + rangedBonus
+    let weaponsRanged = this.items.filter(it => it.type == "weapon" && it.system.damagestatistic.toLowerCase() == "pre")
+    for (let w of weaponsRanged) {
+      let damage = this.baseRDL + Number(w.system.damage)
+      if (damage != w.system.rdl) {
+        updates.push({ _id: w.id, "system.rdl": damage })
+      }
+    }
+
+    let armorBonus = 0
+    effects = this.items.filter(effect => effect.type == "effect" && effect.system.affectstatus && effect.system.affectstatus == " adrl" && (Number(effect.system.effectlevel) > 0))
+    for (let e of effects) {
+      armorBonus += Number(e.system.effectlevel)
+    }
+    roleBonus = 0
+    if (role?.name?.toLowerCase() == "defender") { // Add defender bonus to ADRL
+      roleBonus = this.getRoleLevel()
+    }
+    this.baseADRL = roleBonus + armorBonus + this.system.statistics.phy.value + this.system.statistics.phy.mod +
+      this.system.statistics.phy.bonuseffect + this.system.biodata.sizenum + this.system.biodata.sizebonus
+    let armors = this.items.filter(it => it.type == "armor")
+    for (let a of armors) {
+      let adrl = this.baseADRL + a.system.resistance
+      if (adrl != a.system.adrl) {
+        updates.push({ _id: a.id, "system.adrl": adrl })
+      }
+    }
+
+    if (updates.length > 0) {
+      this.updateEmbeddedDocuments('Item', updates)
+    }
+  }
+  /* -------------------------------------------- */
+  getBaseADRL() {
+
+  }
  /* -------------------------------------------- */
  parseStatEffects() {
    if (this.system.biodata.noautobonus) { // If we are in "no-bonus mode
@ -1624,7 +1712,7 @@ export class PegasusActor extends Actor {
  async modStat(key, inc = 1) {
    let stat = duplicate(this.system.statistics[key])
    stat.mod += parseInt(inc)
-    await this.update({ [`data.statistics.${key}`]: stat })
+    await this.update({ [`system.statistics.${key}`]: stat })
  }

  /* -------------------------------------------- */
@ -1632,7 +1720,7 @@ export class PegasusActor extends Actor {
    key = key.toLowerCase()
    let stat = duplicate(this.system.statistics[key])
    stat.value += parseInt(inc)
-    await this.update({ [`data.statistics.${key}`]: stat })
+    await this.update({ [`system.statistics.${key}`]: stat })
  }

  /* -------------------------------------------- */
@ -1640,11 +1728,11 @@ export class PegasusActor extends Actor {
    if (key == "nrg") {
      let nrg = duplicate(this.system.nrg)
      nrg.mod += parseInt(inc)
-      await this.update({ [`data.nrg`]: nrg })
+      await this.update({ [`system.nrg`]: nrg })
    } else {
      let status = duplicate(this.system.secondary[key])
      status.bonus += parseInt(inc)
-      await this.update({ [`data.secondary.${key}`]: status })
+      await this.update({ [`system.secondary.${key}`]: status })
    }
  }

@ -1683,7 +1771,7 @@ export class PegasusActor extends Actor {
    if (objetQ) {
      let newQ = objetQ.system.quantity + incDec
      if (newQ >= 0) {
-        const updated = await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantity': newQ }]) // pdates one EmbeddedEntity
+        await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.quantity': newQ }]) // pdates one EmbeddedEntity
      }
    }
  }
@ -1693,26 +1781,26 @@ export class PegasusActor extends Actor {
    if (objetQ) {
      let newQ = objetQ.system.ammocurrent + incDec;
      if (newQ >= 0 && newQ <= objetQ.system.ammomax) {
-        const updated = await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.ammocurrent': newQ }]); // pdates one EmbeddedEntity
+        await this.updateEmbeddedDocuments('Item', [{ _id: objetQ.id, 'system.ammocurrent': newQ }]); // pdates one EmbeddedEntity
      }
    }
  }

  /* -------------------------------------------- */
-  async applyAbility(ability, updates = [], directUpdate = false) {
+  async applyAbility(ability, updates = {}, directUpdate = false) {
    // manage stat bonus
    if (!ability.system) {
      ability.system = ability.data
    }
    if (ability.system.affectedstat != "notapplicable") {
-      if ( ability.system.affectedstat == "mr") {
+      if (ability.system.affectedstat == "mr") {
        let stat = duplicate(this.system.mr)
        stat.mod += Number(ability.system.statmodifier)
-        updates[`system.mr`] = stat  
+        updates[`system.mr`] = stat
      } else {
        let stat = duplicate(this.system.statistics[ability.system.affectedstat])
        stat.mod += Number(ability.system.statmodifier)
-        updates[`system.statistics.${ability.system.affectedstat}`] = stat  
+        updates[`system.statistics.${ability.system.affectedstat}`] = stat
      }
    }
    // manage status bonus
@ -1722,6 +1810,7 @@ export class PegasusActor extends Actor {
        nrg.mod += Number(ability.system.statusmodifier)
        updates[`system.nrg`] = nrg
      }
+      /* NO MORE USED
      if (ability.system.statusaffected == 'health') {
        let health = duplicate(this.system.secondary.health)
        health.bonus += Number(ability.system.statusmodifier)
@ -1741,7 +1830,7 @@ export class PegasusActor extends Actor {
        let stealthhealth = duplicate(this.system.secondary.stealthhealth)
        stealthhealth.bonus += Number(ability.system.statusmodifier)
        updates[`system.secondary.stealthhealth`] = delirium
-      }
+      }*/
    }
    if (directUpdate) {
      await this.update(updates)
@ -1811,7 +1900,7 @@ export class PegasusActor extends Actor {
  getIncreaseStatValue(updates, statKey) {
    let stat = duplicate(this.system.statistics[statKey])
    stat.value += 1;
-    updates[`data.statistics.${statKey}`] = stat
+    updates[`system.statistics.${statKey}`] = stat
  }

  /* -------------------------------------------- */
@ -1835,11 +1924,63 @@ export class PegasusActor extends Actor {
    await this.createEmbeddedDocuments('Item', newItems)

  }
+  /* -------------------------------------------- */
+  checkEFfectsHindranceDeletion(statKey) {
+    let toRem = []
+    let effects = this.items.filter(effect => effect.type == 'effect' && effect.system.oneuse &&
+      effect.system.hindrance && (effect.system.stataffected == statKey || effect.system.stataffected == "all"))
+    for (let effect of effects) {
+      toRem.push(effect.id)
+    }
+    if (toRem.length > 0) {
+      this.deleteEmbeddedDocuments('Item', toRem)
+    }
+  }

+  /* -------------------------------------------- */
+  computeCurrentHindrances(statKey) {
+    let hindrancesDices = 0
+    if (this.type == "character" || this.type == 'npc') {
+
+      hindrancesDices += this.system.combat.hindrancedice
+      let overCapacity = Math.floor(this.encCurrent / this.getEncumbranceCapacity())
+      if (overCapacity > 0) {
+        hindrancesDices += overCapacity
+      }
+      let effects = this.items.filter(effect => effect.type == 'effect' && effect.system.hindrance && (effect.system.stataffected == statKey || effect.system.stataffected == "all"))
+      for (let effect of effects) {
+        hindrancesDices += effect.system.effectlevel
+      }
+      if (statKey.toLowerCase() == "stl" && this.system.secondary.concealment.status == "exposed") {
+        hindrancesDices += 1
+      }
+      if (statKey.toLowerCase() == "stl" && (this.system.secondary.concealment.status == "detected" || this.system.secondary.concealment.status == "located")) {
+        hindrancesDices += 3
+      }
+    }
+    if (this.type == "vehicle") {
+      if (this.isVehicleCrawling()) {
+        hindrancesDices += 3
+      }
+      if (this.isVehicleSlow()) {
+        hindrancesDices += 1
+      }
+      if (this.isVehicleAverage()) {
+        hindrancesDices += 1
+      }
+      if (this.isVehicleFast()) {
+        hindrancesDices += 3
+      }
+      if (this.isVehicleExFast()) {
+        hindrancesDices += 5
+      }
+    }
+    return hindrancesDices
+  }

  /* -------------------------------------------- */
  addHindrancesList(effectsList) {
-    if (this.type == "character") {
+    if (this.type == "character" || this.type == 'npc') {
      if (this.system.combat.stunlevel > 0) {
        effectsList.push({ label: "Stun Hindrance", type: "hindrance", foreign: true, actorId: this.id, applied: false, value: 2 })
      }
@ -1887,12 +2028,8 @@ export class PegasusActor extends Actor {
  /* ROLL SECTION
  /* -------------------------------------------- */
  pushEffect(rollData, effect) {
-    if (this.getTraumaState() == "none" && !this.checkNoBonusDice()) {
+    if ((this.getTraumaState() == "none" && !this.checkNoBonusDice()) || !effect.system.bonusdice) {
      rollData.effectsList.push({ label: effect.name, type: "effect", applied: false, effect: effect, value: effect.system.effectlevel })
-    } else {
-      if (!effect.system.bonusdice) { // Do not push bonus dice effect when TraumaState is activated
-        rollData.effectsList.push({ label: effect.name, type: "effect", applied: false, effect: effect, value: effect.system.effectlevel })
-      }
    }
  }

@ -1927,7 +2064,7 @@ export class PegasusActor extends Actor {
      rollData.effectsList.push({ label: "Ranged Role Bonus", type: "effect", applied: true, isdynamic: true, value: this.getRoleLevel() })
      rollData.dicePool = rollData.dicePool.concat(PegasusUtility.buildDicePool("effect-bonus-dice", this.getRoleLevel(), 0, "Ranged Role Bonus"))
    }
-    if (role && role.name.toLowerCase() == "defender" && subKey == "defence") {
+    if (role && role.name.toLowerCase() == "defender" && (subKey == "defence" || subKey == "dmg-res")) {
      rollData.effectsList.push({ label: "Defender Role Bonus", type: "effect", applied: true, isdynamic: true, value: this.getRoleLevel() })
      rollData.dicePool = rollData.dicePool.concat(PegasusUtility.buildDicePool("effect-bonus-dice", this.getRoleLevel(), 0, "Defender Role Bonus"))
    }
@ -1942,7 +2079,7 @@ export class PegasusActor extends Actor {
    if (statKey == 'phy' && subKey == "dmg-res") {
      let armors = this.getArmors()
      for (let armor of armors) {
-        rollData.armorsList.push({ label: `Armor ${armor.name}`, type: "armor", applied: false, value: armor.system.resistance })
+        rollData.armorsList.push({ label: `Armor ${armor.name}`, type: "armor", applied: false, value: armor.system.resistance, adrl: armor.system.adrl })
      }
    }
    if (useShield) {
@ -2020,6 +2157,7 @@ export class PegasusActor extends Actor {
    let rollData = PegasusUtility.getBasicRollData(isInit)
    rollData.alias = this.name
    rollData.actorImg = this.img
+    rollData.actorType = this.type
    rollData.tokenId = this.token?.id
    rollData.actorId = (this.token) ? this.token.actor.id : this.id
    rollData.img = this.img
@ -2030,6 +2168,8 @@ export class PegasusActor extends Actor {
    rollData.noBonusDice = this.checkNoBonusDice()
    rollData.dicePool = []
    rollData.subKey = subKey
+    rollData.MDL = this.baseMDL
+    rollData.ADRL = this.baseADRL

    if (subKey == "melee-dmg" || subKey == "ranged-dmg" || subKey == "power-dmg") {
      rollData.isDamage = true
@ -2092,7 +2232,7 @@ export class PegasusActor extends Actor {
    }

    if (statKey == "mr") {
-      if (this.type == "character") {
+      if (this.type == "character" || this.type == 'npc') {
        rollData.mrVehicle = PegasusUtility.checkIsVehicleCrew(this.id)
        if (rollData.mrVehicle) {
          rollData.effectsList.push({
@ -2113,6 +2253,9 @@ export class PegasusActor extends Actor {
      }
    }

+    rollData.hindranceDices = this.computeCurrentHindrances(statKey)
+    rollData.minHindranceDices = rollData.hindranceDices
+
    this.processSizeBonus(rollData)
    this.addEffects(rollData, isInit, isPower, subKey == "power-dmg")
    this.addArmorsShields(rollData, statKey, useShield, subKey)
@ -2130,7 +2273,7 @@ export class PegasusActor extends Actor {
  processSizeBonus(rollData) {
    if (rollData.defenderTokenId) {
      let diffSize = 0
-      if (this.type == "character") {
+      if (this.type == "character" || this.type == 'npc') {
        this.system.biodata.sizenum = this.system.biodata?.sizenum ?? 0
        this.system.biodata.sizebonus = this.system.biodata?.sizebonus ?? 0
        diffSize = rollData.defenderSize - this.system.biodata.sizenum + this.system.biodata.sizebonus
@ -2160,6 +2303,15 @@ export class PegasusActor extends Actor {
      }
    }
  }
+  /* -------------------------------------------- */
+  getExtraTICsFromEffect() {
+    let effects = this.items.filter(it => it.type == "effect" && Number(it.system.extratics) > 0)
+    let nbTics = 0
+    for (let e of effects) {
+      nbTics += Number(e.system.extratics)
+    }
+    return nbTics
+  }

  /* -------------------------------------------- */
  getLevelRemainingList() {
@ -2280,6 +2432,11 @@ export class PegasusActor extends Actor {
      console.log("MR ROLL", rollData)
      if (isInit) {
        rollData.title = "MR / Initiative"
+        rollData.nbTIC = ((this.type == "character") ? 2 : 1) + this.getExtraTICsFromEffect()
+        rollData.TICs = []
+        for (let i = 0; i < rollData.nbTIC; i++) {
+          rollData.TICs.push({ text: "NONE", revealed: false, displayed: false })
+        }
      }
      this.startRoll(rollData);
    } else {
--- a/modules/pegasus-combat.js
+++ b/modules/pegasus-combat.js
@ -1,21 +1,200 @@
 import { PegasusUtility } from "./pegasus-utility.js";

 /* -------------------------------------------- */
-export class PegasusCombat extends Combat {
-  
+export class PegasusCombatTracker extends CombatTracker {
+
  /* -------------------------------------------- */
-  async rollInitiative(ids, formula = undefined, messageOptions = {} ) {
+  static get defaultOptions() {
+    let path = "systems/fvtt-pegasus-rpg/templates/pegasus-combat-tracker.html";
+    return foundry.utils.mergeObject(super.defaultOptions, {
+      template: path,
+    });
+  }
+
+  /* -------------------------------------------- */
+  async getData() {
+    let combatData = await super.getData()
+    for (let t of combatData.turns) {
+      let c = game.combat.combatants.get(t.id)
+      t.displayTIC = (c.actor.isOwner && c.actor.hasPlayerOwner && !game.user.isGM) || (c.actor.type == "npc" && !c.actor.hasPlayerOwner && game.user.isGM) 
+      let TICs = c.getFlag("world", "TICs")
+      if (TICs) {
+        t.TICs = TICs
+      } else {
+        t.TICs = []
+      }
+    }
+    //console.log("CBT", combatData)
+    return combatData
+  }
+
+  /* -------------------------------------------- */
+  activateListeners(html) {
+    super.activateListeners(html)
+
+    html.find('.combat-tracker-tic').click(ev => {
+      let ticNum = $(ev.currentTarget).data("tic-num")
+      let combatantId = $(ev.currentTarget).data("combatant-id")
+      game.combat.revealTIC(ticNum, combatantId)
+    })
+
+    html.find('.reset-npc-initiative').click(ev => {
+      game.combat.resetNPCInitiative()
+    })
+    html.find('.select-combat-actor').click(ev => {
+      let combatantId = $(ev.currentTarget).data("combatant-id")
+      game.combat.selectActor(combatantId)
+    })
+
+
+  }
+
+}
+
+/* -------------------------------------------- */
+export class PegasusCombat extends Combat {
+
+  /* -------------------------------------------- */
+  async rollInitiative(ids, formula = undefined, messageOptions = {}) {
    ids = typeof ids === "string" ? [ids] : ids;
    for (let cId = 0; cId < ids.length; cId++) {
      const c = this.combatants.get(ids[cId]);
      let id = c._id || c.id;
-      let initBonus = c.actor ? c.actor.getInitiativeScore( this.id, id ) : -1;
-      await this.updateEmbeddedDocuments("Combatant", [ { _id: id, initiative: initBonus } ]);
+      let initBonus = c.actor ? c.actor.getInitiativeScore(this.id, id) : -1;
+      await this.updateEmbeddedDocuments("Combatant", [{ _id: id, initiative: initBonus }]);
    }

    return this;
  }

+  /* -------------------------------------------- */
+  async resetNPCInitiative() {
+    for (let c of this.combatants) {
+      if (c.actor && c.actor.type == "npc") {
+        await this.updateEmbeddedDocuments("Combatant", [{ _id: c.id, initiative: -1 }]);
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  isCharacter(combatantId) {
+    const combatant = game.combat.combatants.get(combatantId)
+    if (combatant) {
+      return combatant.actor.type == "character"
+    }
+    return false
+  }
+
+  /* -------------------------------------------- */
+  selectActor(combatantId) {
+    const combatant = game.combat.combatants.get(combatantId)
+    if (combatant) {
+      let TICs = combatant.getFlag("world", "TICs") || []
+      let allRevealed = true
+      for(let tic of TICs) {
+        if (!tic.revealed ) {
+          allRevealed = false
+        }
+      }
+      let msg = `<div>${combatant.actor.name} has been nominated to act, ${combatant.actor.name} choose which TIC you wish to activate!</div`
+      if ( allRevealed) {
+        msg = `<div>${combatant.actor.name} has used all its TIC's please choose a different character.</div`
+      }
+      let chatData = {
+        user: game.user.id,
+        alias: combatant.actor.name,
+        rollMode: game.settings.get("core", "rollMode"),
+        content: msg
+        }
+      ChatMessage.create(chatData);
+    }
+  }
+
+  /* -------------------------------------------- */
+  async setTic(combatantId, rollData) {
+    if (!combatantId) {
+      return
+    }
+    const combatant = game.combat.combatants.get(combatantId)
+    if (combatant) {
+      await combatant.setFlag("world", "TICs", rollData.TICs)
+    }
+  }
+
+  /* -------------------------------------------- */
+  async revealTIC(num, combatantId) {
+    console.log('revealTIC', num, combatantId)
+    if (num == undefined || combatantId == undefined) {
+      return
+    }
+    const combatant = game.combat.combatants.get(combatantId)
+    if (combatant) {
+      console.log('revealTIC', num, combatantId, combatant)
+      let ticData = combatant.getFlag("world", "TICs")
+      if (ticData) {
+        console.log('revealTIC', num, combatantId, ticData)
+        num = Number(num)
+        if ( ticData[num].revealed && ticData[num].displayed ) {
+          let chatData = {
+            user: game.user.id,
+            alias: combatant.actor.name,
+            rollMode: game.settings.get("core", "rollMode"),
+            whisper: [game.user.id].concat(ChatMessage.getWhisperRecipients('GM')),
+            content: `<div>${combatant.actor.name} : This Action has already been performed please choose a different TIC</div`
+          };
+          ChatMessage.create(chatData);
+          return
+        }
+        ticData[num].revealed = true
+        ticData[num].displayed = true
+        combatant.setFlag("world", "TICs", ticData).then(() => {
+          let chatData = {
+            user: game.user.id,
+            alias: combatant.actor.name,
+            rollMode: game.settings.get("core", "rollMode"),
+            content: `<div>${combatant.actor.name} is performing ${ticData[num].text}</div`
+          };
+          ChatMessage.create(chatData);
+          // Manage if all TIC has been ACTED
+          let allRevealed = true
+          for (let c of this.combatants) {
+            let TICs = c.getFlag("world", "TICs")
+            if (TICs) {
+              for (let t of TICs) {
+                if (!t.revealed) {
+                  allRevealed = false
+                }
+              }
+            }
+          }
+          // If all TIC has been ACTED, display a message
+          if (allRevealed) {
+            let chatData = {
+              user: game.user.id,
+              rollMode: game.settings.get("core", "rollMode"),
+              content: `<div>All Characters have acted, All Characters who do not have Stun gain 1 Momentum!</div`
+            }
+            ChatMessage.create(chatData);
+          }
+        })
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  nextRound() {
+    for (let c of this.combatants) {
+      let TICs = duplicate(c.getFlag("world", "TICs"))
+      for (let t of TICs) {
+        t.displayed = false
+        t.revealed = false
+        t.text = ""
+      }
+      c.setFlag("world", "TICs", TICs)
+    }
+    super.nextRound()
+  }
+
  /* -------------------------------------------- */
  _onUpdate(changed, options, userId) {
  }
@ -28,11 +207,11 @@ export class PegasusCombat extends Combat {
  }

  /* -------------------------------------------- */
-  static async decInitBy10( combatantId, value) {
+  static async decInitBy10(combatantId, value) {
    const combatant = game.combat.combatants.get(combatantId)
    let initValue = combatant.initiative + value
    await game.combat.setInitiative(combatantId, initValue)
-    setTimeout( this.checkTurnPosition, 400) // The setInitiative is no more blocking for unknown reason
+    setTimeout(this.checkTurnPosition, 400) // The setInitiative is no more blocking for unknown reason
  }

 }
--- a/modules/pegasus-config.js
+++ b/modules/pegasus-config.js
@ -0,0 +1,37 @@
+export const PEGASUS_CONFIG = {
+  healthStatus: {
+    healthy: { key: "healthy", name: 'Healthy', hindrance: 0 },
+    injured: { key: "injured",name: 'Injured',hindrance: 0 },
+    wounded: { key: "wounded",name: 'Wounded',hindrance: 1, rolls: 'ALL' },
+    severlywounded: { key: "severlywounded",name: 'Severly Wounded',hindrance: 3, rolls: 'ALL' },
+    defeated: { key: "defeated",name:'Defeated',hindrance: 3, defeated: true}
+  },
+  deliriumStatus: {
+    stable: { key:'stable', name: 'Stable', hindrance: 0 },
+    unstable: { key:'unstable',name: 'Unstable', hindrance: 0 },
+    trauma: { key:'trauma',name: 'Trauma', hindrance: 0, nobonusdice: true },
+    severetrauma: { key:'severetrauma',name: 'Severe Trauma', hindrance: 0, nobonusdice: true, noperks: true },
+    defeated: { key:'defeated',name:'Defeated',hindrance: 0, defeated: true}
+  },
+  concealmentStatus: {
+    hidden: { key:'hidden',name: 'Hidden', hindrance: 0 },
+    covered: { key:'covered',name: 'Covered', hindrance: 0 },
+    exposed: { key:'exposed',name: 'Exposed', hindrance: 1, rolls: 'STL' },
+    detected: { key:'detected',name: 'Detected', hindrance: 3, rolls: 'STL'},
+    located: { key:'located',name: 'Located', hindrance: 0 }
+  },
+  confidenceStatus: {
+    confident: { key:'confident',name: 'Confident', hindrance: 0 },
+    uncertain: { key:'uncertain',name: 'Uncertain', hindrance: 0 },
+    shaken: { key:'shaken',name: 'Shaken', hindrance: 0, hasfear: true },
+    anxious: { key:'anxious',name: 'Anxious', hindrance: 0, nostunrecover: true },
+    lostface: { key:'lostface',name: 'Lost Face', hindrance: 0 }
+  },
+  extraTIC: {
+    "0": {key: "0", name: "None", value: 0},
+    "1": {key: "1", name: "+1 TIC", value: 1},
+    "2": {key: "2", name: "+2 TIC", value: 2},
+    "3": {key: "3", name: "+3 TIC", value: 3},
+    "4": {key: "4", name: "+4 TIC", value: 4},
+  }
+}
--- a/modules/pegasus-create-char.js
+++ b/modules/pegasus-create-char.js
@ -92,9 +92,11 @@ export class PegasusActorCreate {

    if (step == 'select-race-optionnal') {
      let ability = this.raceOptionnalAbilities.optionnalabilities.find(item => item._id == itemId);
-      let update = []
+      let update = {}
      await this.actor.applyAbility(ability, update);
-      this.actor.update(update)
+      if (!jQuery.isEmptyObject(update)) {
+        this.actor.update(update)
+      }
      this.actor.createEmbeddedDocuments('Item', [ability]);
      PegasusUtility.removeChatMessageId(PegasusUtility.findChatMessageId(event.currentTarget));
      this.raceOptionnalAbilities.optionnalabilities = this.raceOptionnalAbilities.optionnalabilities.filter(item => item._id != itemId);
--- a/modules/pegasus-hindrance-die.js
+++ b/modules/pegasus-hindrance-die.js
@ -0,0 +1,25 @@
+export class PegasusHindranceDie extends Die {
+  constructor(termData ) {
+      termData.faces=6;
+      super(termData);
+  }
+
+  /* -------------------------------------------- */
+
+  /** @override */
+  static DENOMINATION = "h";
+
+  /* -------------------------------------------- */
+
+  /** @override */
+  getResultLabel(result) {
+      return {
+          "1": '<img src="systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png" />',
+          "2": '<img src="systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png" />',
+          "3": '<img src="systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png" />',
+          "4": '<img src="systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png" />',
+          "5": '<img src="systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png" />',
+          "6": '<img src="systems/fvtt-pegasus-rpg/images/dice/hindrance-dice.png" />'
+      }[result.result];
+  }
+}
--- a/modules/pegasus-item-sheet.js
+++ b/modules/pegasus-item-sheet.js
@ -57,6 +57,7 @@ export class PegasusItemSheet extends ItemSheet {
      type: objectData.type,
      img: objectData.img,
      name: objectData.name,
+      config: game.system.pegasus.config,
      editable: this.isEditable,
      cssClass: this.isEditable ? "editable" : "locked",
      optionsDiceList: PegasusUtility.getOptionsDiceList(),
@ -423,7 +424,6 @@ export class PegasusItemSheet extends ItemSheet {
    }
  }

-  
  /* -------------------------------------------- */
  async _onDrop(event) {

--- a/modules/pegasus-main.js
+++ b/modules/pegasus-main.js
@ -12,11 +12,11 @@ import { PegasusActor } from "./pegasus-actor.js";
 import { PegasusItemSheet } from "./pegasus-item-sheet.js";
 import { PegasusActorSheet } from "./pegasus-actor-sheet.js";
 import { PegasusVehicleSheet } from "./pegasus-vehicle-sheet.js";
-import { PegasusNPCSheet } from "./pegasus-npc-sheet.js";
 import { PegasusUtility } from "./pegasus-utility.js";
-import { PegasusCombat } from "./pegasus-combat.js";
+import { PegasusCombatTracker,PegasusCombat } from "./pegasus-combat.js";
 import { PegasusItem } from "./pegasus-item.js";
-import { PegasusToken } from "./pegasus-token.js";
+import { PegasusHindranceDie } from "./pegasus-hindrance-die.js";
+import { PEGASUS_CONFIG } from "./pegasus-config.js"

 /* -------------------------------------------- */
 /*  Foundry VTT Initialization                  */
@ -57,14 +57,18 @@ Hooks.once("init", async function () {
  CONFIG.Combat.documentClass = PegasusCombat
  CONFIG.Actor.documentClass = PegasusActor
  CONFIG.Item.documentClass = PegasusItem
+  CONFIG.ui.combat = PegasusCombatTracker
+  CONFIG.Dice.terms["h"] = PegasusHindranceDie
  game.system.pegasus = { 
-    utility: PegasusUtility
+    utility: PegasusUtility,
+    config: PEGASUS_CONFIG
  }

  /* -------------------------------------------- */
  // Register sheet application classes
  Actors.unregisterSheet("core", ActorSheet);
  Actors.registerSheet("fvtt-pegasus", PegasusActorSheet, { types: ["character"], makeDefault: true })
+  Actors.registerSheet("fvtt-pegasus", PegasusActorSheet, { types: ["npc"], makeDefault: true })
  Actors.registerSheet("fvtt-pegasus", PegasusVehicleSheet, { types: ["vehicle"], makeDefault: false })

  Items.unregisterSheet("core", ItemSheet);
@ -72,7 +76,6 @@ Hooks.once("init", async function () {

  PegasusUtility.init()

-
 });

 /* -------------------------------------------- */
--- a/modules/pegasus-roll-dialog.js
+++ b/modules/pegasus-roll-dialog.js
@ -39,6 +39,9 @@ export class PegasusRollDialog extends Dialog {

  /* -------------------------------------------- */
  roll() {
+    for(let i=0; i<this.rollData.nbTIC; i++) {
+      this.rollData.TICs[i].text = $('#roll-input-tic'+i).val()   
+    }
    PegasusUtility.rollPegasus(this.rollData)
  }

@ -101,6 +104,12 @@ export class PegasusRollDialog extends Dialog {
    if (armor) {
      armor.applied = toggled
    }
+    this.rollData.armorUsed = false
+    for(let a of this.rollData.armorsList) {
+      if (a.applied) {
+        this.rollData.armorUsed = true
+      }
+    }
    console.log("Armor", armorIdx, toggled)
    PegasusUtility.updateArmorDicePool(this.rollData)
  }
@ -117,6 +126,12 @@ export class PegasusRollDialog extends Dialog {
      }
      weapon.applied = toggled
    }
+    this.rollData.weaponUsed = false
+    for(let a of this.rollData.weaponsList) {
+      if (a.applied) {
+        this.rollData.weaponUsed = true
+      }
+    }
    console.log("Weapon", weaponIdx, toggled, weapon)
    PegasusUtility.updateDamageDicePool(this.rollData)
  }
@ -281,6 +296,13 @@ export class PegasusRollDialog extends Dialog {
      PegasusUtility.removeFromDicePool(this.rollData, idx)
      this.refreshDialog()
    })
+    html.find('.pool-remove-hindrance-dice').click(async (event) => {
+      if (this.rollData.hindranceDices > this.rollData.minHindranceDices) { 
+        this.rollData.hindranceDices--;
+      }
+      this.refreshDialog()
+    })
+    


  }
--- a/modules/pegasus-utility.js
+++ b/modules/pegasus-utility.js
@ -23,9 +23,32 @@ export class PegasusUtility {
    Hooks.on('renderChatLog', (log, html, data) => PegasusUtility.chatListeners(html))
    Hooks.on('targetToken', (user, token, flag) => PegasusUtility.targetToken(user, token, flag))
    Hooks.on('renderSidebarTab', (app, html, data) => PegasusUtility.addDiceRollButton(app, html, data))
-    Hooks.on("getCombatTrackerEntryContext", (html, options) => {
+    /* Deprecated, no more used in rules Hooks.on("getCombatTrackerEntryContext", (html, options) => {
      PegasusUtility.pushInitiativeOptions(html, options);
-    });
+    });*/
+    Hooks.once('diceSoNiceReady', (dice3d) => {
+      dice3d.addSystem({ id: "pegasus-hindrance", name: "Hindrance Die" }, "preferred");
+      dice3d.addDicePreset({
+        type: "dh",
+        labels: [
+          'systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png',
+          'systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png',
+          'systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png',
+          'systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png',
+          'systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png',
+          'systems/fvtt-pegasus-rpg/images/dice/hindrance-dice.png'
+        ],
+        bumpMaps: [
+          'systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png',
+          'systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png',
+          'systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png',
+          'systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png',
+          'systems/fvtt-pegasus-rpg/images/dice/hindrance-dice-empty.png',
+          'systems/fvtt-pegasus-rpg/images/dice/hindrance-dice.png'
+        ],
+        system: "pegasus-hindrance"
+      }, "d6")
+    })
    Hooks.on("dropCanvasData", (canvas, data) => {
      PegasusUtility.dropItemOnToken(canvas, data)
    });
@ -70,6 +93,26 @@ export class PegasusUtility {
    Handlebars.registerHelper('getDice', function (a) {
      return PegasusUtility.getDiceFromLevel(a)
    })
+    Handlebars.registerHelper('getStatusConfig', function (a) {
+      let key = a + "Status"
+      //console.log("TABE", key, game.system.pegasus.config[key] )
+      return game.system.pegasus.config[key]
+    })
+    Handlebars.registerHelper('valueAtIndex', function (arr, idx) {
+      return arr[idx];
+    })
+    Handlebars.registerHelper('for', function (from, to, incr, block) {
+      let accum = '';
+      for (let i = from; i <= to; i += incr)
+        accum += block.fn(i);
+      return accum;
+    })
+    Handlebars.registerHelper('isGM', function () {
+      return game.user.isGM
+    })
+    Handlebars.registerHelper('isCharacter', function (id) {
+      return game.combat.isCharacter(id)
+    })

  }

@ -122,7 +165,8 @@ export class PegasusUtility {
  static getDiceList() {
    return [{ key: "d4", level: 1, img: "systems/fvtt-pegasus-rpg/images/dice/d4.webp" }, { key: "d6", level: 2, img: "systems/fvtt-pegasus-rpg/images/dice/d6.webp" },
    { key: "d8", level: 3, img: "systems/fvtt-pegasus-rpg/images/dice/d8.webp" }, { key: "d10", level: 4, img: "systems/fvtt-pegasus-rpg/images/dice/d10.webp" },
-    { key: "d12", level: 5, img: "systems/fvtt-pegasus-rpg/images/dice/d12.webp" }]
+    { key: "d12", level: 5, img: "systems/fvtt-pegasus-rpg/images/dice/d12.webp" }, 
+    { key: "hindrance", level: 0, img: "systems/fvtt-pegasus-rpg/images/dice/hindrance-dice.png"}]
  }

  /* -------------------------------------------- */
@ -131,10 +175,10 @@ export class PegasusUtility {
    let diceKey = PegasusUtility.getDiceFromLevel(level)
    let diceList = diceKey.split(" ")
    for (let myDice of diceList) {
-      myDice = myDice.trim()
+      let myDiceTrim = myDice.trim()
      let newDice = {
-        name: name, key: myDice, level: PegasusUtility.getLevelFromDice(myDice), mod: mod, effect: effectName,
-        img: `systems/fvtt-pegasus-rpg/images/dice/${myDice}.webp`
+        name: name, key: myDiceTrim, level: PegasusUtility.getLevelFromDice(myDiceTrim), mod: mod, effect: effectName,
+        img: `systems/fvtt-pegasus-rpg/images/dice/${myDiceTrim}.webp`
      }
      dicePool.push(newDice)
      mod = 0 // Only first dice has modifier
@ -146,10 +190,10 @@ export class PegasusUtility {
  static updateEffectsBonusDice(rollData) {
    let newDicePool = rollData.dicePool.filter(dice => dice.name != "effect-bonus-dice")
    for (let effect of rollData.effectsList) {
-      if (effect && effect.applied && effect.type == "effect" && !effect.effect?.system?.hindrance && effect.effect && effect.effect.system.bonusdice) {
+      if (effect?.applied && effect.type == "effect" && !effect.effect?.system?.hindrance && effect.effect && effect.effect.system.bonusdice) {
        newDicePool = newDicePool.concat(this.buildDicePool("effect-bonus-dice", effect.effect.system.effectlevel, 0, effect.effect.name))
      }
-      if (effect && effect.applied && effect.type == "effect" && effect.value && effect.isdynamic && !effect.effect?.system?.hindrance) {
+      if (effect?.applied && effect.type == "effect" && effect.value && effect.isdynamic && !effect.effect?.system?.hindrance) {
        newDicePool = newDicePool.concat(this.buildDicePool("effect-bonus-dice", effect.value, 0, effect.name))
      }
    }
@ -160,7 +204,7 @@ export class PegasusUtility {
  static updateHindranceBonusDice(rollData) {
    let newDicePool = rollData.dicePool.filter(dice => dice.name != "effect-hindrance")
    for (let hindrance of rollData.effectsList) {
-      if (hindrance && hindrance.applied && (hindrance.type == "hindrance" || (hindrance.type == "effect" && hindrance.effect?.system?.hindrance))) {
+      if (hindrance?.applied && (hindrance.type == "hindrance" || (hindrance.type == "effect" && hindrance.effect?.system?.hindrance))) {
        console.log("Adding Hindrance 1", hindrance, newDicePool)
        newDicePool = newDicePool.concat(this.buildDicePool("effect-hindrance", (hindrance.value) ? hindrance.value : hindrance.effect.system.effectlevel, 0, hindrance.name))
        console.log("Adding Hindrance 2", newDicePool)
@ -201,9 +245,9 @@ export class PegasusUtility {
      for (let weapon of rollData.vehicleWeapons) {
        if (weapon.applied) {
          newDicePool = newDicePool.concat(this.buildDicePool("damage", weapon.value, 0))
-          if( weapon.weapon.system.extradamage) {
-            for(let i=0; i < weapon.weapon.system.extradamagevalue; i++) {
-              newDicePool = newDicePool.concat(this.buildDicePool("damage", 5, 0) )
+          if (weapon.weapon.system.extradamage) {
+            for (let i = 0; i < weapon.weapon.system.extradamagevalue; i++) {
+              newDicePool = newDicePool.concat(this.buildDicePool("damage", 5, 0))
            }
          }
        }
@ -240,11 +284,15 @@ export class PegasusUtility {

  /* -------------------------------------------- */
  static addDicePool(rollData, diceKey, level) {
-    let newDice = {
-      name: "dice-click", key: diceKey, level: level,
-      img: `systems/fvtt-pegasus-rpg/images/dice/${diceKey}.webp`
+    if (diceKey == "hindrance") {
+      rollData.hindranceDices +=1  
+    } else {
+      let newDice = {
+        name: "dice-click", key: diceKey, level: level,
+        img: `systems/fvtt-pegasus-rpg/images/dice/${diceKey}.webp`
+      }
+      rollData.dicePool.push(newDice)
    }
-    rollData.dicePool.push(newDice)
  }

  /*-------------------------------------------- */
@ -544,7 +592,7 @@ export class PegasusUtility {

  /* -------------------------------------------- */
  static getDiceFromLevel(level = 0) {
-    level = Math.max( Number(level), 0)
+    level = Math.max(Number(level), 0)
    return this.diceList[level];
  }
  /* -------------------------------------------- */
@ -744,7 +792,7 @@ export class PegasusUtility {
    // De-actived used effects from perks
    let toRem = []
    for (let effect of rollData.effectsList) {
-      if (effect.effect && effect.effect.system.isUsed && effect.effect.system.oneuse) {
+      if (effect?.effect?.system.isUsed && effect.effect.system.oneuse) {
        effect.defenderTokenId = rollData.defenderTokenId
        if (effect.foreign) {
          if (game.user.isGM) {
@ -758,11 +806,11 @@ export class PegasusUtility {
        }
      }
    }
+    let actor = game.actors.get(rollData.actorId)
    if (toRem.length > 0) {
-      //console.log("Going to remove one use effects", toRem)
-      let actor = game.actors.get(rollData.actorId)
      actor.deleteEmbeddedDocuments('Item', toRem)
    }
+    actor.checkEFfectsHindranceDeletion(rollData.statKey)
  }

  /* -------------------------------------------- */
@ -821,11 +869,22 @@ export class PegasusUtility {
    let myRoll = rollData.roll
    if (!myRoll || rollData.rerollHero || rollData.rerollMomentum) { // New rolls only of no rerolls
      myRoll = new Roll(diceFormula).roll({ async: false })
-      await this.showDiceSoNice(myRoll, game.settings.get("core", "rollMode"))
      rollData.roll = myRoll
    }
+    if (rollData.hindranceDices > 0) {
+      rollData.hindranceRoll = new Roll(rollData.hindranceDices + "dh").roll({ async: false })
+      this.showDiceSoNice(rollData.hindranceRoll, game.settings.get("core", "rollMode"))
+      for (let res of rollData.hindranceRoll.terms[0].results) {
+        if (res.result == 6) {
+          rollData.hindranceFailure = true
+          rollData.img = `systems/fvtt-pegasus-rpg/images/dice/hindrance-dice.png`
+        }
+      }
+    }
+    await this.showDiceSoNice(myRoll, game.settings.get("core", "rollMode"))
+
    // Final score and keep data
-    rollData.finalScore = myRoll.total
+    rollData.finalScore = (rollData.hindranceFailure) ? 0 : myRoll.total

    if (rollData.damages) {
      let dmgFormula = this.getFoundryDiceFromLevel(rollData.damages.value)
@ -841,6 +900,7 @@ export class PegasusUtility {
    // Init stuf
    if (rollData.isInit) {
      let combat = game.combats.get(rollData.combatId)
+      await combat.setTic(rollData.combatantId, rollData)
      combat.updateEmbeddedDocuments("Combatant", [{ _id: rollData.combatantId, initiative: rollData.finalScore }])
    }

@ -1036,14 +1096,14 @@ export class PegasusUtility {
      let defenderActor = target.actor
      rollData.defenderTokenId = target.id
      rollData.defenderSize = 0
-      if ( defenderActor.type == "character") {
+      if (defenderActor.type == "character") {
        rollData.defenderSize = Number(defenderActor.system.biodata.sizenum) + Number(defenderActor.system.biodata.sizebonus)
-      } else if ( defenderActor.type == "vehicle" ){
+      } else if (defenderActor.type == "vehicle") {
        rollData.defenderSize = Number(defenderActor.system.statistics.hr.size)
      }
      //rollData.attackerId = this.id
      console.log("Target/DEFENDER", defenderActor)
-      defenderActor.addHindrancesList(rollData.effectsList)
+      //defenderActor.addHindrancesList(rollData.effectsList) /* No more used */
    }
  }

@ -1082,10 +1142,10 @@ export class PegasusUtility {

  /* -------------------------------------------- */
  static checkIsVehicleCrew(actorId) {
-    let vehicles = game.actors.filter( actor=> actor.type == "vehicle") || []
-    for(let vehicle of vehicles)  {
+    let vehicles = game.actors.filter(actor => actor.type == "vehicle") || []
+    for (let vehicle of vehicles) {
      console.log("Checking", vehicle.name)
-      if ( vehicle.inCrew(actorId) ) {
+      if (vehicle.inCrew(actorId)) {
        return vehicle
      }
    }
@ -1118,7 +1178,7 @@ export class PegasusUtility {
    let tacticianTokens = canvas.tokens.placeables.filter(token => token.actor.isTactician() && !token.document.hidden)
    for (let token of tacticianTokens) {
      token.refresh()
-      let friends = canvas.tokens.placeables.filter(newToken => newToken.actor.type == "character" && !newToken.document.hidden && newToken.document.disposition == token.document.disposition)  
+      let friends = canvas.tokens.placeables.filter(newToken => newToken.actor.type == "character" && !newToken.document.hidden && newToken.document.disposition == token.document.disposition)
      for (let friend of friends) {
        if (friend.actor.id != token.actor.id) {
          let existing = toApply[friend.id] || { token: friend, add: false, level: 0, names: [] }
@ -1166,7 +1226,7 @@ export class PegasusUtility {
    let enhancerTokens = canvas.tokens.placeables.filter(token => token.actor.isEnhancer() && !token.document.hidden)
    for (let token of enhancerTokens) {
      token.refresh()
-      let friends = canvas.tokens.placeables.filter(newToken => newToken.actor.type == "character" && !newToken.document.hidden && newToken.document.disposition == token.document.disposition)  
+      let friends = canvas.tokens.placeables.filter(newToken => newToken.actor.type == "character" && !newToken.document.hidden && newToken.document.disposition == token.document.disposition)
      for (let friend of friends) {
        if (friend.actor.id != token.actor.id) {
          let existing = toApply[friend.id] || { token: friend, add: false, level: 0, names: [] }
@ -1218,13 +1278,13 @@ export class PegasusUtility {
      token.refresh()
      let ennemies = []
      if (token.document.disposition == -1) {
-        ennemies = canvas.tokens.placeables.filter(newToken => newToken.actor.type == "character" && !newToken.document.hidden && (newToken.document.disposition == 1 || newToken.document.disposition == 0 ))
+        ennemies = canvas.tokens.placeables.filter(newToken => newToken.actor.type == "character" && !newToken.document.hidden && (newToken.document.disposition == 1 || newToken.document.disposition == 0))
      }
      if (token.document.disposition == 1) {
-        ennemies = canvas.tokens.placeables.filter(newToken => newToken.actor.type == "character" && !newToken.document.hidden && (newToken.document.disposition == -1 || newToken.document.disposition == 0 ))
+        ennemies = canvas.tokens.placeables.filter(newToken => newToken.actor.type == "character" && !newToken.document.hidden && (newToken.document.disposition == -1 || newToken.document.disposition == 0))
      }
      if (token.document.disposition == 0) {
-        ennemies = canvas.tokens.placeables.filter(newToken => newToken.actor.type == "character" && !newToken.document.hidden && (newToken.document.disposition == -1 || newToken.document.disposition == 1 ))
+        ennemies = canvas.tokens.placeables.filter(newToken => newToken.actor.type == "character" && !newToken.document.hidden && (newToken.document.disposition == -1 || newToken.document.disposition == 1))
      }
      console.log("Ennemies for token", token.actor.name, ennemies)
      for (let ennemy of ennemies) {
@ -1282,9 +1342,9 @@ export class PegasusUtility {
    this.lastRoleEffectProcess = now
    console.log("=========================+> Searching/Processing roles effects")

-    await this.processTactician()
+    /*NO MORE USED : await this.processTactician()*/
    await this.processEnhancer()
-    await this.processAgitator()
+    /*NO MORE USED : await this.processAgitator()*/

  }

--- a/styles/simple.css
+++ b/styles/simple.css
@ -1142,7 +1142,6 @@ ul, li {
  position: relative;
  margin:4px;
 }
-
 .chat-card-button {
  box-shadow: inset 0px 1px 0px 0px #a6827e;
  background: linear-gradient(to bottom, #21374afc 5%, #152833ab 100%);
@ -1352,6 +1351,26 @@ Focus FOC: #ff0084
  max-height: 26px;
  margin-top: 4px;
 }
+.combat-tracker-tic-section {
+  max-width: 5rem;
+  min-width: 5rem;
+  align-content: center;
+}
+.combat-tracker-tic {
+  text-align: center;
+  background: linear-gradient(to bottom, #21374afc 5%, #152833ab 100%);
+  border-radius: 3px;
+  border: 2px ridge #846109;
+  color: #ffffff;
+  font-size: 0.8rem;
+  margin:2px;
+}
+.combat-tracker-tic-button {
+  max-height: 1.8rem;
+  margin-bottom: 4px;
+  background: linear-gradient(to bottom, #21374afc 5%, #152833ab 100%);
+  border-radius: 3px;
+}
 .no-grow {
  flex-grow: 1;
  max-width: 32px;
@ -1517,4 +1536,13 @@ Focus FOC: #ff0084
  max-width: 48px;
  max-height: 48px;
  flex-grow: 0;
+}
+.dice-pool-image-add {
+  border: 0;
+  margin-left: 4px;
+  min-width: 32px;
+  min-height: 32px;
+  max-width: 32px;
+  max-height: 32px;
+  flex-grow: 0;
 }
--- a/system.json
+++ b/system.json
@ -23,8 +23,7 @@
  "manifest": "https://www.uberwald.me/gitea/uberwald/fvtt-pegasus-rpg/raw/branch/master/system.json",
  "compatibility": {
    "minimum": "10",
-    "verified": "10",
-    "maximum": "10"
+    "verified": "11"
  },
  "id": "fvtt-pegasus-rpg",
  "packs": [
@ -245,15 +244,15 @@
      "flags": {}
    }
  ],
-  "primaryTokenAttribute": "secondary.health",
-  "secondaryTokenAttribute": "secondary.delirium",
+  "primaryTokenAttribute": "",
+  "secondaryTokenAttribute": "",
  "socket": true,
  "styles": [
    "styles/simple.css"
  ],
  "title": "Pegasus RPG",
  "url": "https://www.uberwald.me/data/files/fvtt-pegasus-rpg",
-  "version": "10.2.7",
-  "download": "https://www.uberwald.me/gitea/uberwald/fvtt-pegasus-rpg/archive/fvtt-pegasus-rpg-v10.2.7.zip",
+  "version": "11.0.23",
+  "download": "https://www.uberwald.me/gitea/uberwald/fvtt-pegasus-rpg/archive/fvtt-pegasus-rpg-v11.0.23.zip",
  "background": "systems/fvtt-pegasus-rpg/images/ui/pegasus_welcome_page.webp"
 }
--- a/template.json
+++ b/template.json
@ -2,6 +2,7 @@
  "Actor": {
    "types": [
      "character",
+      "npc",
      "vehicle"
    ],
    "templates": {
@ -171,6 +172,7 @@
            "type": "value",
            "ismax": true,
            "iscombat": true,
+            "status": "healthy",            
            "bonus": 0,
            "max": 0
          },
@ -180,22 +182,25 @@
            "type": "value",
            "ismax": true,
            "iscombat": true,
+            "status": "stable",
            "bonus": 0,
            "max": 0
          },
-          "stealthhealth": {
-            "label": "STL Health",
+          "concealment": {
+            "label": "Concealment",
            "type": "value",
            "value": 0,
            "ismax": true,
+            "status": "hidden",
            "bonus": 0,
            "max": 0
          },
-          "socialhealth": {
-            "label": "SOC Health",
+          "confidence": {
+            "label": "Confidence",
            "type": "value",
            "value": 0,
            "ismax": true,
+            "status": "confident",
            "bonus": 0,
            "max": 0
          }
@ -368,6 +373,12 @@
        "core"
      ]
    },
+    "npc": {
+      "templates": [
+        "biodata",
+        "core"
+      ]
+    },
    "vehicle": {
      "templates": [
        "vehicle"
@ -428,6 +439,7 @@
      "noperksallowed": false,
      "affectstatus": false,
      "affectedstatus": "",
+      "extratics": "none",
      "locked": false,
      "droptext": "",
      "description": ""
@ -595,6 +607,7 @@
    "armor": {
      "statistic": "",
      "resistance": "",
+      "adrl": 0,
      "weight": 0,
      "cost": 0,
      "idr": "",
@ -645,6 +658,8 @@
    "weapon": {
      "statistic": "",
      "damagestatistic": "",
+      "mdl": 0,
+      "rdl": 0,
      "damage": "",
      "canbethrown": false,
      "cost": 0,
--- a/templates/actor-sheet.html
+++ b/templates/actor-sheet.html
@ -59,12 +59,6 @@
            <div class="stat-item status-block">
              {{> systems/fvtt-pegasus-rpg/templates/partial-actor-status.html}}
            </div>
-
-            <!--
-                            <label class="status-small-label">Active NRG</label> 
-                          <input type="text" class="padd-right status-small-label no-grow" name="system.nrg.activated" value="{{data.nrg.activated}}" data-dtype="Number"/>
-                          -->
-
          </div>
        </div>
      </div>
--- a/templates/chat-generic-result.html
+++ b/templates/chat-generic-result.html
@ -24,8 +24,14 @@
        {{#if isDamage}}
        <li>Weapon Damage Dice : {{weaponDamageDice}}</li>
        {{/if}}
+
+        {{#if (eq subKey "dmg-res")}}
+        <li>Damage Resistance</li>
+        {{/if}}
+
        {{#if isResistance}}
        <li>Armor Resistance  Dice : {{armor.system.resistanceDice}}</li>
+        <li>ADRL : {{armor.system.adrl}}</li>
        {{/if}}
        {{#if stat}}  
        <li>Statistic : {{stat.label}}</li>
@ -38,24 +44,47 @@
        <li>Weapon : {{weaponName}}</li>
        {{/if}}
        {{#if weapon}}  
+          {{#if (eq weapon.weapon.system.damagestatistic "str")}}
+          <li>MDL : {{weapon.weapon.system.mdl}}</li>
+          {{/if}}
+          {{#if (eq weapon.weapon.system.statistic "agi")}}
+          <li>RDL : {{weapon.weapon.system.rdl}}</li>
+          {{/if}}
          {{#if vehicle}}
          <li>Damage type : {{weapon.weapon.system.damagetype}}</li>
          {{else}}
          <li>Damage type : {{weapon.weapon.system.damagetype}} {{weapon.weapon.system.damagetypelevel}}</li>
          {{/if}}
        {{/if}}
+        
+        {{#if (eq subKey "melee-dmg")}}
+          {{#if (not weaponUsed)}}
+          <li>MDL : {{MDL}}</li>
+          {{/if}}
+        {{/if}}
+
+        {{#if (eq subKey "dmg-res")}}
+          {{#if (not armorUsed)}}
+          <li>ADRL : {{ADRL}}</li>
+          {{/if}}
+          {{#each armorsList as |armor idx|}}
+            {{#if armor.applied}}
+              <li>ADRL: {{armor.adrl}}</li>
+            {{/if}}
+          {{/each}}
+        {{/if}}

        {{#if power}}  
          <li>Power Damage type : {{power.system.powerdamagetype}} {{power.system.powerdamagetypelevel}}</li>
        {{/if}}

-        {{#if isResistance}}
-        <li><strong>Defense Result : {{finalScore}}</strong>
+        {{#if hindranceFailure}}
+        <li><strong>Failed due to Hindrance Dice !!</strong>
        {{else}}
-          {{#if isDamage}}
-          <li><strong>Damages : {{finalScore}}</strong>
+          {{#if isResistance}}
+          <li><strong>Defense Result : {{finalScore}}</strong>
          {{else}}
-          <li><strong>Final Result : {{finalScore}}</strong>
+            <li><strong>Final Result : {{finalScore}}</strong>
          {{/if}}
        {{/if}}
        
--- a/templates/item-armor-sheet.html
+++ b/templates/item-armor-sheet.html
@ -26,13 +26,21 @@
              </select> 
            </li>

-            <li class="flexrow"><label class="generic-label">DMG RES Dice</label>
+            <li class="flexrow"><label class="generic-label">Damage Resistance</label>
              <select class="competence-base flexrow" type="text" name="system.resistance" value="{{data.resistance}}" data-dtype="Number">
                {{#select data.resistance}}
                {{{optionsDiceList}}}
                {{/select}}
              </select> 
            </li>
+
+            {{#if owner}}
+            <li class="flexrow">
+              <label class="generic-label">ADRL</label>
+              <label class="generic-label">{{data.adrl}}</label>
+            </li>
+            {{/if}}
+  
            <li class="flexrow"><label class="generic-label">Location Protected</label>
              <input type="text" class="" name="system.locationprotected" value="{{data.locationprotected}}" data-dtype="String"/>
            </li>
--- a/templates/item-effect-sheet.html
+++ b/templates/item-effect-sheet.html
@ -88,18 +88,23 @@
            <li class="flexrow"><label class="generic-label">Display Text when added to Actor</label>
              <input type="text" class="input-numeric-short padd-right" name="system.droptext" value="{{data.droptext}}" data-dtype="String"/>
            </li>
-            
+
+            <li class="flexrow"><label class="generic-label">Provide extra TICs ?</label>
+              <select class="competence-base flexrow" type="text" name="system.extratics" value="{{data.extratics}}" data-dtype="String">
+                {{selectOptions config.extraTIC selected=data.extratics nameAttr="key" labelAttr="name" }}
+              </select> 
+          </li>
+
            <li class="flexrow"><label class="generic-label">Affect Status?</label>
              <label class="attribute-value checkbox"><input type="checkbox" name="system.affectstatus" {{checked data.affectstatus}}/></label>
            </li>
            {{#if data.affectstatus}}
-              <li class="flexrow"><label class="generic-label">Affected status</label>
+              <li class="flexrow"><label class="generic-label">Affected status/Auto damage</label>
                <select class="competence-base flexrow" type="text" name="system.affectedstatus" value="{{data.affectedstatus}}" data-dtype="String">
                  {{#select data.affectedstatus}}
-                  <option value="health">Health</option>
-                  <option value="delirium">Delirium</option>
-                  <option value="socialhealth">Social Health</option>
-                  <option value="stealthhealth">Stealth Health</option>
+                  <option value="mdl">MDL</option>
+                  <option value="rdl">RDL</option>
+                  <option value="adrl">ADRL</option>
                  <option value="nrg">NRG</option>
                  <option value="mt">MT</option>
                  <option value="kbv">KBV</option>
--- a/templates/item-weapon-sheet.html
+++ b/templates/item-weapon-sheet.html
@ -38,6 +38,19 @@
            </select> 
          </li>

+          {{#if (and owner (eq data.damagestatistic "str"))}}
+          <li class="flexrow">
+            <label class="generic-label">MDL</label>
+            <label class="competence-base">{{data.mdl}}</label>
+          </li>
+          {{/if}}
+          {{#if (and owner (eq data.damagestatistic "pre"))}}
+          <li class="flexrow">
+            <label class="generic-label">RDL</label>
+            <label class="competence-base">{{data.rdl}}</label>
+          </li>
+          {{/if}}
+
          <li class="flexrow"><label class="generic-label">Item size</label>
            <input type="text" class="" name="system.itemsize" value="{{data.itemsize}}" data-dtype="String"/>
          </li>
--- a/templates/partial-actor-status.html
+++ b/templates/partial-actor-status.html
@ -1,25 +1,17 @@
 <ul class="status-block">
  <li class="item flexrow">
    <span class="stat-label status-small-label status-col-name"><label class="status-small-label"><strong>Status</strong></label></span>
-    <span class="status-header-label status-small-label no-grow"><label class="status-small-label">Cur</label></span>
-    <span class="status-header-label status-small-label no-grow"><label class="status-small-label">Mod</label></span>
-    <span class="status-header-label status-small-label no-grow"><label class="status-small-label">Max</label></span>
+    <span class="status-header-label status-small-label no-grow"><label class="status-medium-label">State</label></span>
  </li>
  {{#each data.secondary as |stat2 key|}}
    <li class="item flexrow " data-attr-key="{{key}}">
      <span class="stat-label flexrow status-col-name" name="{{key}}">
        <label class="status-small-label"><strong>{{stat2.label}}</strong><br>
-          {{#if (eq key "health")}}
-          (KOV -{{stat2.max}})
-          {{/if}}
-          {{#if (eq key "delirium")}}
-          (MV -{{stat2.max}})
-          {{/if}}
        </label>
      </span>
-      <input type="text" class="padd-right status-small-label no-grow" name="system.secondary.{{key}}.value" value="{{stat2.value}}" data-dtype="Number"/>
-      <input type="text" class="padd-right status-small-label no-grow" name="system.secondary.{{key}}.bonus" value="{{stat2.bonus}}" data-dtype="Number" {{@root.disabledBonus}}/>
-      <input type="text" class="padd-right status-small-label no-grow" name="system.secondary.{{key}}.max" value="{{stat2.max}}" data-dtype="Number"/>
+      <select class="padd-right status-small-label" type="text" name="system.secondary.{{key}}.status" value="{{stat2.status}}" data-dtype="String">
+        {{selectOptions (getStatusConfig key) selected=stat2.status nameAttr="key" labelAttr="name" }}
+      </select>
    </li>
  {{/each}}
  <li class="item flexrow " data-key="nrg">
--- a/templates/pegasus-combat-tracker.html
+++ b/templates/pegasus-combat-tracker.html
@ -0,0 +1,144 @@
+<section class="{{cssClass}} directory flexcol" id="{{cssId}}" data-tab="{{tabName}}">
+  <header class="combat-tracker-header">
+      {{#if user.isGM}}
+      <nav class="encounters flexrow" aria-label="{{localize 'COMBAT.NavLabel'}}">
+          <a class="combat-button combat-create" aria-label="{{localize 'COMBAT.Create'}}" role="button" data-tooltip="COMBAT.Create">
+              <i class="fas fa-plus"></i>
+          </a>
+          {{#if combatCount}}
+          <a class="combat-button combat-cycle" aria-label="{{localize 'COMBAT.EncounterPrevious'}}" role="button" data-tooltip="COMBAT.EncounterPrevious"
+             {{#if previousId}}data-document-id="{{previousId}}"{{else}}disabled{{/if}}>
+              <i class="fas fa-caret-left"></i>
+          </a>
+          <h4 class="encounter">{{localize "COMBAT.Encounter"}} {{currentIndex}} / {{combatCount}}</h4>
+          <a class="combat-button combat-cycle" aria-label="{{localize 'COMBAT.EncounterNext'}}" role="button" data-tooltip="COMBAT.EncounterNext"
+             {{#if nextId}}data-document-id="{{nextId}}"{{else}}disabled{{/if}}>
+              <i class="fas fa-caret-right"></i>
+          </a>
+          {{/if}}
+          <a class="combat-button combat-control" aria-label="{{localize 'COMBAT.Delete'}}" role="button" data-tooltip="COMBAT.Delete" data-control="endCombat" {{#unless combatCount}}disabled{{/unless}}>
+              <i class="fas fa-trash"></i>
+          </a>
+      </nav>
+      {{/if}}
+
+      <div class="encounter-controls flexrow {{#if hasCombat}}combat{{/if}}">
+          {{#if user.isGM}}
+          <a class="combat-button combat-control" aria-label="{{localize 'COMBAT.RollAll'}}" role="button" data-tooltip="COMBAT.RollAll" data-control="rollAll" {{#unless turns}}disabled{{/unless}}>
+              <i class="fas fa-users"></i>
+          </a>
+          <a class="combat-button combat-control" aria-label="{{localize 'COMBAT.RollNPC'}}" role="button" data-tooltip="COMBAT.RollNPC" data-control="rollNPC" {{#unless turns}}disabled{{/unless}}>
+              <i class="fas fa-users-cog"></i>
+          </a>
+          <a class="combat-button reset-npc-initiative" aria-label="Reset NPC" role="button" data-tooltip="Reset NPC Initiative" data-control="resetNPC" {{#unless turns}}disabled{{/unless}}>
+            <i class="fas fa-pickaxe"></i>
+        </a>
+        {{/if}}
+
+          {{#if combatCount}}
+          {{#if combat.round}}
+          <h3 class="encounter-title noborder">{{localize 'COMBAT.Round'}} {{combat.round}}</h3>
+          {{else}}
+          <h3 class="encounter-title noborder">{{localize 'COMBAT.NotStarted'}}</h3>
+          {{/if}}
+          {{else}}
+          <h3 class="encounter-title noborder">{{localize "COMBAT.None"}}</h3>
+          {{/if}}
+
+          {{#if user.isGM}}
+          <a class="combat-button combat-control" aria-label="{{localize 'COMBAT.InitiativeReset'}}" role="button" data-tooltip="COMBAT.InitiativeReset" data-control="resetAll"
+              {{#unless hasCombat}}disabled{{/unless}}>
+              <i class="fas fa-undo"></i>
+          </a>
+          <a class="combat-button combat-control" aria-label="{{localize 'labels.scope'}}" role="button" data-tooltip="{{labels.scope}}"
+              data-control="toggleSceneLink" {{#unless hasCombat}}disabled{{/unless}}>
+              <i class="fas fa-{{#unless linked}}un{{/unless}}link"></i>
+          </a>
+          {{/if}}
+          <a class="combat-button combat-settings" aria-label="{{localize 'COMBAT.Settings'}}" role="button" data-tooltip="COMBAT.Settings" data-control="trackerSettings">
+              <i class="fas fa-cog"></i>
+          </a>
+      </div>
+  </header>
+
+  <ol id="combat-tracker" class="directory-list">
+      {{#each turns}}
+      <li class="combatant actor directory-item flexrow {{this.css}}" data-combatant-id="{{this.id}}">
+          <img class="token-image" data-src="{{this.img}}" alt="{{this.name}}"/>
+          <div class="token-name flexcol">
+              <h4>{{this.name}}</h4><a class="select-combat-actor" data-combatant-id="{{this.id}}"><i class="fas fa-hand-pointer"></i></a>
+              <div class="combatant-controls flexrow">
+                  {{#if ../user.isGM}}
+                  <a class="combatant-control {{#if this.hidden}}active{{/if}}" aria-label="{{localize 'COMBAT.ToggleVis'}}" role="button" data-tooltip="COMBAT.ToggleVis" data-control="toggleHidden">
+                      <i class="fas fa-eye-slash"></i>
+                  </a>
+                  <a class="combatant-control {{#if this.defeated}}active{{/if}}" aria-label="{{localize 'COMBAT.ToggleDead'}}" role="button" data-tooltip="COMBAT.ToggleDead" data-control="toggleDefeated">
+                      <i class="fas fa-skull"></i>
+                  </a>
+                  {{/if}}
+                  {{#if this.canPing}}
+                  <a class="combatant-control" aria-label="{{localize 'COMBAT.PingCombatant'}}" role="button" data-tooltip="COMBAT.PingCombatant" data-control="pingCombatant">
+                      <i class="fa-solid fa-bullseye-arrow"></i>
+                  </a>
+                  {{/if}}
+                  <div class="token-effects">
+                      {{#each this.effects}}
+                      <img class="token-effect" src="{{this}}"/>
+                      {{/each}}
+                  </div>
+              </div>
+          </div>
+
+          {{#if this.hasResource}}
+          <div class="token-resource">
+              <span class="resource">{{this.resource}}</span>
+          </div>
+          {{/if}}
+          
+          <div class="combat-tracker-tic-section flexcol" id="{{this.id}}">
+            {{#each this.TICs as | tic index|}}
+              <button class="combat-tracker-tic-button"><a class="combat-tracker-tic" data-tic-num="{{index}}" data-combatant-id="{{../id}}">
+                {{#if tic.revealed}}
+                  ACTED
+                {{else}}
+                  {{#if ../displayTIC}}
+                    {{tic.text}}
+                  {{else}}
+                    TIC: {{add index 1}}
+                  {{/if}}
+                {{/if}}
+              </a></button>
+            {{/each}}
+          </div>
+
+          <div class="token-initiative">              
+              {{#if this.hasRolled}}
+              <span class="initiative">{{this.initiative}}</span>
+              {{else if this.owner}}
+              <a class="combatant-control roll" aria-label="{{localize 'COMBAT.InitiativeRoll'}}" role="button" data-tooltip="COMBAT.InitiativeRoll" data-control="rollInitiative"></a>
+              {{/if}}
+          </div>
+      </li>
+      {{/each}}
+  </ol>
+
+  <nav id="combat-controls" class="directory-footer flexrow" data-tooltip-direction="UP">
+  {{#if hasCombat}}
+      {{#if user.isGM}}
+          {{#if round}}
+          <a class="combat-control" aria-label="{{localize 'COMBAT.RoundPrev'}}" role="button" data-tooltip="COMBAT.RoundPrev" data-control="previousRound"><i class="fas fa-step-backward"></i></a>
+          <a class="combat-control" aria-label="{{localize 'COMBAT.TurnPrev'}}" role="button" data-tooltip="COMBAT.TurnPrev" data-control="previousTurn"><i class="fas fa-arrow-left"></i></a>
+          <a class="combat-control center" aria-label="{{localize 'COMBAT.End'}}" role="button" data-control="endCombat">{{localize 'COMBAT.End'}}</a>
+          <a class="combat-control" aria-label="{{localize 'COMBAT.TurnNext'}}" role="button" data-tooltip="COMBAT.TurnNext" data-control="nextTurn"><i class="fas fa-arrow-right"></i></a>
+          <a class="combat-control" aria-label="{{localize 'COMBAT.RoundNext'}}" role="button" data-tooltip="COMBAT.RoundNext" data-control="nextRound"><i class="fas fa-step-forward"></i></a>
+          {{else}}
+          <a class="combat-control center" aria-label="{{localize 'COMBAT.Begin'}}" role="button"  data-control="startCombat">{{localize 'COMBAT.Begin'}}</a>
+          {{/if}}
+      {{else if control}}
+      <a class="combat-control" aria-label="{{localize 'COMBAT.TurnPrev'}}" role="button"  data-tooltip="COMBAT.TurnPrev" data-control="previousTurn"><i class="fas fa-arrow-left"></i></a>
+      <a class="combat-control center" aria-label="{{localize 'COMBAT.TurnEnd'}}" role="button"  data-control="nextTurn">{{localize 'COMBAT.TurnEnd'}}</a>
+      <a class="combat-control" aria-label="{{localize 'COMBAT.TurnNext'}}" role="button"  data-tooltip="COMBAT.TurnNext" data-control="nextTurn"><i class="fas fa-arrow-right"></i></a>
+      {{/if}}
+  {{/if}}
+  </nav>
+</section>
--- a/templates/roll-dialog-generic.html
+++ b/templates/roll-dialog-generic.html
@ -26,7 +26,7 @@

      {{#if statVehicle}}
      <div class="flexrow">
-        <span class="roll-dialog-label">{{upper  statVehicle.label}} :</span>
+        <span class="roll-dialog-label">{{upper statVehicle.label}} :</span>
        <select class="roll-dialog-label" id="statVehicleLevel" type="text" name="statVehicleLevel"
          value="{{statVehicle.currentlevel}}" data-dtype="Number" {{#if statKey}}disabled{{/if}}>
          {{#select statVehicle.currentlevel}}
@ -37,74 +37,72 @@
      </div>
      {{/if}}

-        {{#if specList}}
-        <div class="flexrow">
-          <span class="roll-dialog-label">Spec : </span>
-          <select class="roll-dialog-label" id="specList" type="text" name="selectedSpec" value="{{selectedSpec}}"
-            data-dtype="String">
-            {{#select selectedSpec}}
-            <option value="0">None</option>
-            {{#each specList as |spec idx|}}
-            <option value="{{spec._id}}">{{spec.name}}</option>
-            {{/each}}
-            {{/select}}
-          </select>
-          <span class="small-label">&nbsp;</span>
-        </div>
-        <div class="flexrow">
-          <span class="roll-dialog-label">Spec Dice : </span>
-          <select class="roll-dialog-label" id="specDicesLevel" type="text" name="specDicesLevel"
-            value="{{specDicesLevel}}" data-dtype="Number" {{#if specList}}disabled{{/if}}>
-            {{#select specDicesLevel}}
-            {{{optionsDiceList}}}
-            {{/select}}
-          </select>
-          <span class="small-label">&nbsp;</span>
-        </div>
-        {{/if}}
-
-      {{/if}}
-
-      <!--
-      {{#if isDamage}}
+      {{#if specList}}
      <div class="flexrow">
-        <span class="roll-dialog-label">Weapon Damage :</span>
-        <select class="roll-dialog-label" id="damageDiceLevel" type="text" name="damageDiceLevel"
-          value="{{damageDiceLevel}}" data-dtype="Number">
-          {{#select damageDiceLevel}}
+        <span class="roll-dialog-label">Spec : </span>
+        <select class="roll-dialog-label" id="specList" type="text" name="selectedSpec" value="{{selectedSpec}}"
+          data-dtype="String">
+          {{#select selectedSpec}}
+          <option value="0">None</option>
+          {{#each specList as |spec idx|}}
+          <option value="{{spec._id}}">{{spec.name}}</option>
+          {{/each}}
+          {{/select}}
+        </select>
+        <span class="small-label">&nbsp;</span>
+      </div>
+      <div class="flexrow">
+        <span class="roll-dialog-label">Spec Dice : </span>
+        <select class="roll-dialog-label" id="specDicesLevel" type="text" name="specDicesLevel"
+          value="{{specDicesLevel}}" data-dtype="Number" {{#if specList}}disabled{{/if}}>
+          {{#select specDicesLevel}}
          {{{optionsDiceList}}}
          {{/select}}
        </select>
        <span class="small-label">&nbsp;</span>
      </div>
      {{/if}}
-      -->
-      
+
+      {{/if}}
+
      <div class="dice-pool-div">
        <span>
          <h3 class="dice-pool-label">Current pool</h3>
        </span>
        <div class="flexrow dice-pool-stack">
          {{#each dicePool as |dice idx|}}
-          <span><a class="pool-remove-dice" data-dice-idx="{{idx}}" data-dice-level="{{dice.level}}" data-dice-key="{{dice.key}}"><img class="dice-pool-image"
-                src="{{dice.img}}"></a></span>
+          <span><a class="pool-remove-dice" data-dice-idx="{{idx}}" data-dice-level="{{dice.level}}"
+              data-dice-key="{{dice.key}}"><img class="dice-pool-image" src="{{dice.img}}" alt="dices"></a></span>
          {{/each}}
        </div>
      </div>

+      <div class="dice-pool-div">
+        <span>
+          <h3 class="dice-pool-label">Hindrance Dice</h3>
+        </span>
+        <div class="flexrow dice-pool-stack">
+          {{#for 1 hindranceDices 1}}
+          <span><a class="pool-remove-hindrance-dice" data-dice-idx="{{idx}}" data-dice-level="2" data-dice-key="d6"><img class="dice-pool-image"
+                src="systems/fvtt-pegasus-rpg/images/dice/hindrance-dice.png" alt="dices"></a></span>
+          {{/for}}
+        </div>
+      </div>
+
      {{#if noBonusDice}}
-        <div class="flexrow">
-          No bonus dice due to effect !
-        </div>
-        {{else}}
-        <div class="flexrow">
-          {{#each diceList as |dice idx|}}
-          <span><a class="pool-add-dice" data-dice-key="{{dice.key}}" data-dice-level="{{dice.level}}"><img class="dice-pool-image"
-                src="{{dice.img}}"></a></span>
-          {{/each}}
-        </div>
+      <div class="flexrow">
+        No bonus dice due to effect !
+      </div>
+      {{else}}
+      <div class="flexrow">
+        {{#each diceList as |dice idx|}}
+        <span><a class="pool-add-dice" data-dice-key="{{dice.key}}" data-dice-level="{{dice.level}}"><img
+              class="dice-pool-image-add" src="{{dice.img}}" alt="dices"></a></span>
+        {{/each}}
+      </div>
      {{/if}}

+
      <div class="flexrow">

        <span class="roll-dialog-label">Modifiers : </span>
@ -130,21 +128,30 @@
          <option value="d6">Outnumbered 2 Extra Allies d6</option>
          <option value="d8">Outnumbered 3 Extra Allies d8</option>
          <option value="d10">Outnumbered 4 Extra Allies d10</option>
-          <option value="d12">Outnumbered 5 Extra Allies d12<option>
+          <option value="d12">Outnumbered 5 Extra Allies d12
+          <option>
          <option value="none4">===== Called DMG Shot Bonus</option>
-          <option value="d12">Eyes/head d12<option>
+          <option value="d12">Eyes/head d12
+          <option>
          <option value="none4">===== Impact DMG Bonus</option>
-          <option value="d4">Soft d4<option>
-          <option value="d6">Thin/Flimsy  d6<option>
-          <option value="d8">Solid Furniture d8<option>
-          <option value="d10">Thin Metal/Thick Wood d10<option>
-          <option value="d12">Solid Object/Concrete d12<option>
+          <option value="d4">Soft d4
+          <option>
+          <option value="d6">Thin/Flimsy d6
+          <option>
+          <option value="d8">Solid Furniture d8
+          <option>
+          <option value="d10">Thin Metal/Thick Wood d10
+          <option>
+          <option value="d12">Solid Object/Concrete d12
+          <option>
          <option value="none5">===== Other Circumstances</option>
-          <option value="d4">Concentrated<option>
-          <option value="d4">Off Hand d4<option>
+          <option value="d4">Concentrated
+          <option>
+          <option value="d4">Off Hand d4
+          <option>
          <option value="d6">Higher Ground d6</option>
          {{/select}}
-          </select>
+        </select>
      </div>

    </div>
@ -155,7 +162,16 @@
      {{else}}
      {{> systems/fvtt-pegasus-rpg/templates/partial-roll-select-effects.html}}
      {{/if}}
-      
+
+      {{#if isInit}}
+      {{#each TICs as |tic index|}}
+      <div class="flexrow">
+        <span class="roll-dialog-label">TIC {{add index 1}}:</span>
+        <input class="roll-input-tic" id="roll-input-tic{{index}}" type="text" value="{{tic.text}}" data-dtype="String">
+      </div>
+      {{/each}}
+      {{/if}}
+
    </div>

  </div>
Author	SHA1	Message	Date
LeRatierBretonnien	0c215e7a9c	Fix stun hindrances	2024-04-11 16:37:42 +02:00
LeRatierBretonnien	1b655a9c0e	MDL/ADRL fixes + MR fixes	2023-09-19 15:46:02 +02:00
LeRatierBretonnien	bbf0f31d4c	MDL/ADRL fixes + MR fixes	2023-09-19 13:52:09 +02:00
LeRatierBretonnien	552ff9564a	MDL/ADRL fixes + MR fixes	2023-09-19 12:47:55 +02:00
LeRatierBretonnien	26f2fba457	MDL/ADRL fixes + MR fixes	2023-09-19 11:41:58 +02:00
LeRatierBretonnien	7d6408f6b7	MDL/ADRL fixes + MR fixes	2023-09-18 18:03:00 +02:00
LeRatierBretonnien	72ff709682	Fix TIC display for NPC owned by players	2023-09-17 22:18:38 +02:00
LeRatierBretonnien	588c6655b3	Fix TIC display for NPC owned by players	2023-09-17 20:53:13 +02:00
LeRatierBretonnien	9de2bc48b8	Fix TIC display for NPC owned by players	2023-09-17 20:27:16 +02:00
LeRatierBretonnien	460fd1f0d6	Fix TIC display for NPC owned by players	2023-09-17 18:55:45 +02:00
LeRatierBretonnien	2647983e8d	Varioux fixes	2023-09-16 22:40:25 +02:00
LeRatierBretonnien	d1fdc5a97f	Varioux fixes	2023-09-16 20:31:34 +02:00
LeRatierBretonnien	9e92b904fb	Combat tracker enhancements	2023-09-16 10:19:55 +02:00
LeRatierBretonnien	c4160b2fd5	Combat tracker enhancements	2023-09-16 10:16:59 +02:00
LeRatierBretonnien	ff57953e75	Manage status	2023-09-15 07:33:44 +02:00
LeRatierBretonnien	dc07b27801	Minor changes	2023-09-14 23:23:16 +02:00
LeRatierBretonnien	2394026d0c	Minor changes	2023-09-14 21:03:08 +02:00
LeRatierBretonnien	47db569efd	Add hindrance dice	2023-09-13 21:26:47 +02:00
LeRatierBretonnien	ba98d9c264	Add hindrance dice	2023-09-13 21:25:44 +02:00
LeRatierBretonnien	c1eb33bc21	Add new init system	2023-09-13 17:37:30 +02:00
LeRatierBretonnien	d5f27ae9ea	Manage hindrance dices	2023-09-13 08:06:08 +02:00
LeRatierBretonnien	b81e5ec17e	Switch to v11	2023-09-11 20:35:03 +02:00
LeRatierBretonnien	6a3cb66391	Switch to v11	2023-09-11 20:34:33 +02:00
LeRatierBretonnien	ba50c86800	Addd gitignore	2023-09-11 20:34:15 +02:00