Better management of roles effects

modules/pegasus-actor.js

@@ -237,6 +237,95 @@ export class PegasusActor extends Actor {
     let role = this.items.filter(item => item.type == 'role')
     return role[0] ?? [];
   }
+  /* -------------------------------------------- */
+  getRoleLevel() {
+    let role = this.items.find(item => item.type == 'role')
+    if (role ) {
+      console.log("Role", role)
+      return role.system.rolelevel
+    }
+    return 0
+  }
+
+  /* -------------------------------------------- */
+  isTactician() {
+    let role = this.items.find(item => item.type == 'role')
+    return role && role.system.perksrole == "tactician"
+  }
+  hasTacticianBonus() {
+    let effect = this.items.find( item => item.name.toLowerCase().includes("tactician bonus dice") )
+    return effect
+  }
+  async addTacticianEffect(name, level) {
+    let effect = duplicate(__bonusEffect)
+    effect.name = `${name} Tactician Bonus Dice`
+    effect.system.effectlevel = level 
+    effect.system.stataffected = "mr"
+    effect.system.bonusdice = true
+    await this.createEmbeddedDocuments('Item', [effect])
+    ChatMessage.create({ content: `Tactician Bonus Dice has been added to ${this.name} (${level})` })
+  }
+  async removeTacticianEffect() {
+    let effect = this.items.find( item => item.name.toLowerCase().includes("tactician bonus dice") )
+    if (effect) {
+      await this.deleteEmbeddedDocuments('Item', [effect.id])
+      ChatMessage.create({ content: `Tactician Bonus Dice has been removed to ${this.name}` })  
+    }
+  }
+
+  /* -------------------------------------------- */
+  isEnhancer() {
+    let role = this.items.find(item => item.type == 'role')
+    return role && role.system.perksrole == "enhancer"
+  }
+  hasEnhancerBonus() {
+    let effect = this.items.find( item => item.name.toLowerCase().includes("enhancer bonus dice") )
+    return effect
+  }
+  async addEnhancerEffect( name, level) {
+    let effect = duplicate(__bonusEffect)
+    effect.name = `${name} Enhancer Bonus Dice ALL`
+    effect.system.effectlevel = level 
+    effect.system.stataffected = "all"
+    effect.system.bonusdice = true
+    await this.createEmbeddedDocuments('Item', [effect])
+    ChatMessage.create({ content: `Enhancer Bonus Dice has been added to ${this.name} (${level})` })
+  }
+  async removeEnhancerEffect() {
+    let effect = this.items.find( item => item.name.toLowerCase().includes("enhancer bonus dice") )
+    if (effect) {
+      await this.deleteEmbeddedDocuments('Item', [effect.id])
+      ChatMessage.create({ content: `Enhancer Bonus Dice has been removed to ${this.name}` })  
+    }
+  }
+
+  /* -------------------------------------------- */
+  isAgitator() {
+    let role = this.items.find(item => item.type == 'role')
+    return role && role.system.perksrole == "agitator"
+  }
+  hasAgitatorHindrance() {
+    let effect = this.items.find( item => item.name.toLowerCase().includes("hindered by agitator") )
+    return effect
+  }
+  async addAgitatorHindrance(name, level) {
+    let effect = duplicate(__bonusEffect)
+    effect.name = `Hindered by Agitator ${name}`
+    effect.system.effectlevel = level 
+    effect.system.stataffected = "all"
+    effect.system.genre = "negative"
+    effect.system.hindrance = true
+    await this.createEmbeddedDocuments('Item', [effect])
+    ChatMessage.create({ content: `Agitator Hindrance has been added to ${this.name} (${level})` })
+  }
+  async removeAgitatorHindrance() {
+    let effect = this.items.find( item => item.name.toLowerCase().includes("hindered by agitator") )
+    if (effect) {
+      await this.deleteEmbeddedDocuments('Item', [effect.id])
+      ChatMessage.create({ content: `Agitator Hindrance has been removed to ${this.name}` })  
+    }
+  }
+
   /* -------------------------------------------- */
   checkAndPrepareEquipment(item) {
     if (item.system.resistance) {
@@ -379,13 +468,13 @@ export class PegasusActor extends Actor {
   /* -------------------------------------------- */
   updateSize() {
     let sizeBonus = 0
-    for(let effect of this.items) {
-      if (effect.type == "effect" && effect.system.effectlevel > 0 &&  effect.system.affectsize) {
+    for (let effect of this.items) {
+      if (effect.type == "effect" && effect.system.effectlevel > 0 && effect.system.affectsize) {
         sizeBonus += effect.system.effectlevel
       }
     }
     if (sizeBonus != this.system.biodata.sizebonus) {
-      this.update( {'system.biodata.sizebonus': sizeBonus})
+      this.update({ 'system.biodata.sizebonus': sizeBonus })
     }
   }
 
@@ -771,6 +860,9 @@ export class PegasusActor extends Actor {
     if (this.type == 'character') {
       this.rollMR(true, combatId, combatantId)
     }
+    if (this.type == 'vehicle') {
+      this.rollMR(true, combatId, combatantId)
+    }
     console.log("Init required !!!!")
     return -1;
   }
@@ -1344,12 +1436,13 @@ export class PegasusActor extends Actor {
       this.getTraumaState()
       this.cleanupPerksIfTrauma()
       this.parseStatEffects()
+      this.parseStatusEffects()
     }
   }
 
   /* -------------------------------------------- */
   parseStatEffects() {
-    let effects = this.items.filter(effect => effect.type == "effect" && effect.system.genre == "positive" && effect.system.statdice )
+    let effects = this.items.filter(effect => effect.type == "effect" && effect.system.genre == "positive" && effect.system.statdice)
     for (let statKey in this.system.statistics) {
       let stat = duplicate(this.system.statistics[statKey])
       let bonus = 0
@@ -1358,13 +1451,44 @@ export class PegasusActor extends Actor {
           bonus += Number(effect.system.effectlevel)
         }
       }
-      if ( bonus != stat.bonuseffect) {
+      if (bonus != stat.bonuseffect) {
         stat.bonuseffect = bonus
-        this.update( { [`system.statistics.${statKey}`]: stat} )
+        this.update({ [`system.statistics.${statKey}`]: stat })
       }
     }
   }
 
+  /* -------------------------------------------- */
+  parseStatusEffects() {
+    let effects = this.items.filter(effect => effect.type == "effect" && effect.system.affectstatus && (Number(effect.system.effectlevel) > 0))
+    for (let statusKey in this.system.secondary) {
+      let status = duplicate(this.system.secondary[statusKey])
+      let bonus = 0
+      for (let effect of effects) {
+        if (effect.system.affectedstatus && effect.system.affectedstatus == statusKey) {
+          bonus += Number(effect.system.effectlevel)
+        }
+      }
+      if (bonus != status.bonus) {
+        status.bonus = bonus
+        this.update({ [`system.secondary.${statusKey}`]: status })
+      }
+    }
+
+    let nrg = duplicate(this.system.nrg)
+    let bonus = 0
+    for (let effect of effects) {
+      if (effect.system.affectedstatus && effect.system.affectedstatus == "nrg") {
+        bonus += Number(effect.system.effectlevel)
+      }
+    }
+    if (bonus != nrg.mod) {
+      nrg.mod = bonus
+      this.update({ [`system.nrg`]: nrg })
+    }
+
+  }
+
   /* -------------------------------------------- */
   async modStat(key, inc = 1) {
     let stat = duplicate(this.system.statistics[key])
@@ -1600,7 +1724,7 @@ export class PegasusActor extends Actor {
     let effects = this.items.filter(item => item.type == 'effect')
     for (let effect of effects) {
       effect = duplicate(effect)
-      if (!effect.system.hindrance && !effect.system.statdice 
+      if (!effect.system.hindrance && !effect.system.statdice
         && (effect.system.stataffected != "notapplicable" || effect.system.specaffected.length > 0)
         && effect.system.stataffected != "special"
         && effect.system.stataffected != "powerroll"
@@ -1693,7 +1817,7 @@ export class PegasusActor extends Actor {
     if (statKey) {
       rollData.statKey = statKey
       rollData.stat = this.getStat(statKey)
-      if ( rollData.stat.value != undefined ) {
+      if (rollData.stat.value != undefined) {
         rollData.stat.level = rollData.stat.value // Normalize
       }
       rollData.statDicesLevel = rollData.stat.level + rollData.stat.bonuseffect
@@ -1755,30 +1879,30 @@ export class PegasusActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  processSizeBonus( rollData) { 
-    if ( rollData.defenderTokenId) {
-      let diffSize = rollData.defenderSize - this.system.biodata.sizenum+this.system.biodata.sizebonus
+  processSizeBonus(rollData) {
+    if (rollData.defenderTokenId) {
+      let diffSize = rollData.defenderSize - this.system.biodata.sizenum + this.system.biodata.sizebonus
       //console.log("Diffsize", diffSize)
-      if( rollData.subKey == "melee-atk" || rollData.subKey == "ranged-atk")  {
-        if ( diffSize > 0) {
+      if (rollData.subKey == "melee-atk" || rollData.subKey == "ranged-atk") {
+        if (diffSize > 0) {
           rollData.effectsList.push({ label: "Size Bonus", type: "effect", applied: false, isdynamic: true, value: diffSize })
         }
-      } 
-      if( rollData.subKey == "dmg-res" )  {
-        if ( diffSize < 0) {
+      }
+      if (rollData.subKey == "dmg-res") {
+        if (diffSize < 0) {
           rollData.effectsList.push({ label: "Size Bonus", type: "effect", applied: false, isdynamic: true, value: Math.abs(diffSize) })
         }
       }
-      if( rollData.subKey == "defence" )  {
-        if ( diffSize > 0) {
+      if (rollData.subKey == "defence") {
+        if (diffSize > 0) {
           rollData.effectsList.push({ label: "Size Bonus", type: "effect", applied: false, isdynamic: true, value: Math.abs(diffSize) })
         }
       }
-      if( rollData.subKey == "melee-dmg" || rollData.subKey == "ranged-dmg" || rollData.subKey == "power-dmg")  {
-        if ( diffSize < 0) {
+      if (rollData.subKey == "melee-dmg" || rollData.subKey == "ranged-dmg" || rollData.subKey == "power-dmg") {
+        if (diffSize < 0) {
           rollData.effectsList.push({ label: "Size Bonus", type: "effect", applied: false, isdynamic: true, value: Math.abs(diffSize) })
         }
-      } 
+      }
     }
   }
 
@@ -1887,7 +2011,8 @@ export class PegasusActor extends Actor {
 
   /* -------------------------------------------- */
   async rollMR(isInit = false, combatId = 0, combatantId = 0) {
-    let mr = duplicate(this.system.mr)
+
+    let mr = duplicate((this.type == "vehicle") ? this.system.statistics.mr : this.system.mr)
     if (mr) {
       mr.dice = PegasusUtility.getDiceFromLevel(mr.value);
 
@@ -2261,12 +2386,13 @@ export class PegasusActor extends Actor {
     if (actor) {
       let stat = this.getStat("hr")
       let rollData = this.getCommonRollData("hr")
+      rollData.vehicle = duplicate(this)
+      rollData.isVehicleStun = true
       rollData.mode = "stat"
-      rollData.title = `Stat ${stat.label}`;
+      rollData.title = `Stat ${stat.label}`
 
       this.addVehicleArmors(rollData)
       this.startRoll(rollData)
-      this.modifyVehicleStun(1)
     }
   }
 

modules/pegasus-main.js

@@ -57,8 +57,9 @@ Hooks.once("init", async function () {
   CONFIG.Combat.documentClass = PegasusCombat
   CONFIG.Actor.documentClass = PegasusActor
   CONFIG.Item.documentClass = PegasusItem
-  //CONFIG.Token.objectClass = PegasusToken
-  game.system.pegasus = { };
+  game.system.pegasus = { 
+    utility: PegasusUtility
+  }
 
   /* -------------------------------------------- */
   // Register sheet application classes
@@ -69,8 +70,9 @@ Hooks.once("init", async function () {
   Items.unregisterSheet("core", ItemSheet);
   Items.registerSheet("fvtt-pegasus", PegasusItemSheet, { makeDefault: true });
 
-  PegasusUtility.init();
-  
+  PegasusUtility.init()
+
+
 });
 
 /* -------------------------------------------- */

modules/pegasus-utility.js

@@ -23,7 +23,6 @@ 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) => {
       PegasusUtility.pushInitiativeOptions(html, options);
     });
@@ -35,9 +34,10 @@ export class PegasusUtility {
     this.defenderStore = {}
     this.diceList = [];
     this.diceFoundryList = [];
-    this.optionsDiceList = "";
-    this.buildDiceLists();
-    PegasusCommands.init();
+    this.optionsDiceList = ""
+    this.lastRoleEffectProcess = Date.now()
+    this.buildDiceLists()
+    PegasusCommands.init()
 
     Handlebars.registerHelper('count', function (list) {
       return (list) ? list.length : 0;
@@ -269,6 +269,10 @@ export class PegasusUtility {
   static async ready() {
     const specs = await PegasusUtility.loadCompendium("fvtt-pegasus-rpg.specialisations");
     this.specs = specs.map(i => i.toObject());
+
+    if (game.user.isGM) {
+      Hooks.on('sightRefresh', (app, html, data) => PegasusUtility.refreshSightForEffect(app, html, data))
+    }
   }
 
   /* -------------------------------------------- */
@@ -831,10 +835,13 @@ export class PegasusUtility {
       combat.updateEmbeddedDocuments("Combatant", [{ _id: rollData.combatantId, initiative: rollData.finalScore }])
     }
 
-    // Stun specific -> Suffere a stun level when dmg-res
+    // Stun specific -> Suffer a stun level when dmg-res for character
     if (rollData.subKey && rollData.subKey == "dmg-res") {
       actor.modifyStun(+1)
     }
+    if (rollData.isVehicleStun) {
+      actor.modifyVehicleStun(1)
+    }
 
     //this.removeUsedPerkEffects( rollData) // Unused for now
     this.removeOneUseEffects(rollData) // Unused for now
@@ -1059,4 +1066,229 @@ export class PegasusUtility {
     d.render(true);
   }
 
+  /* -------------------------------------------- */
+  static glowToken(token) {
+    let params =
+      [{
+        filterType: "glow",
+        filterId: "superSpookyGlow",
+        outerStrength: 15,
+        innerStrength: 0,
+        color: 0x6AAB8E,
+        quality: 0.5,
+        padding: 40,
+        autoDestroy: true,
+        animated:
+        {
+          color:
+          {
+            active: true,
+            loopDuration: 3000,
+            loops: 2,
+            animType: "colorOscillation",
+            val1: 0x6AAB8E,
+            val2: 0x66FF33
+          }
+        }
+      }]
+    TokenMagic.addUpdateFilters(token, params)
+  }
+
+  /* -------------------------------------------- */
+  static async getRelevantTokens() {
+    if (!_token) { return }
+    let tokens = canvas.tokens.placeables.filter(token => token.document.disposition == 1)
+    for (let token of tokens) {
+      console.log("Parsing tokens", token.name)
+      let dist = canvas.grid.measureDistances(
+        [{ ray: new Ray(_token.center, token.center) }], { gridSpaces: false })
+      if (dist && dist[0] && dist[0] > 0) {
+        console.log("    Friendly Tokens at : ", token.name, dist / canvas.grid.grid.options.dimensions.distance)
+      }
+      let visible = canvas.effects.visibility.testVisibility(token.center, { object: _token })
+      if (visible && dist[0] > 0) {
+        this.glowToken(token)
+      }
+      console.log("    Visible!", visible)
+    }
+  }
+
+  /* -------------------------------------------- */
+  static async processTactician() {
+    // Tactician management
+    let toApply = {}
+    let tacticianTokens = canvas.tokens.placeables.filter(token => token.actor.isTactician() && !newToken.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)  
+      for (let friend of friends) {
+        if (friend.actor.id != token.actor.id) {
+          let existing = toApply[friend.actor.id] || { actor: friend.actor, add: false, level: 0, names: [] }
+          let visible = canvas.effects.visibility.testVisibility(friend.center, { object: token })
+          console.log("parse visible TACTICIAN : ", visible, token.name, friend.name)
+          if (visible) {
+            existing.add = true
+            existing.level += token.actor.getRoleLevel()
+            existing.names.push(token.actor.name)
+          }
+          toApply[friend.actor.id] = existing
+        }
+      }
+    }
+    for (let id in toApply) {
+      let applyDef = toApply[id]
+      let hasBonus = applyDef.actor.hasTacticianBonus()
+      if (applyDef.add) {
+        if (!hasBonus) {
+          applyDef.actor.addTacticianEffect(applyDef.names.toString(), applyDef.level)
+        } else if (applyDef.level != hasBonus.system.effectlevel) {
+          await applyDef.actor.removeTacticianEffect()
+          applyDef.actor.addTacticianEffect(applyDef.names.toString(), applyDef.level)
+        }
+      } else if (hasBonus) {
+        applyDef.actor.removeTacticianEffect()
+      }
+    }
+    //Delete all effects if no more tacticians (ie deleted case)
+    if (tacticianTokens.length == 0) {
+      let allTokens = canvas.tokens.placeables.filter(token => token.actor.type == "character")
+      for (let token of allTokens) {
+        if (token.actor.hasTacticianBonus()) {
+          token.actor.removeTacticianEffect()
+        }
+      }
+    }
+
+  }
+
+  /* -------------------------------------------- */
+  static async processEnhancer() {
+    // Enhancer management
+    let toApply = {}
+    let enhancerTokens = canvas.tokens.placeables.filter(token => token.actor.isEnhancer() && !newToken.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)  
+      for (let friend of friends) {
+        if (friend.actor.id != token.actor.id) {
+          let existing = toApply[friend.actor.id] || { actor: friend.actor, add: false, level: 0, names: [] }
+          let visible = canvas.effects.visibility.testVisibility(friend.center, { object: token })
+          console.log("parse visible ENHANCER: ", visible, token.name, friend.name)
+          if (visible) {
+            let dist = canvas.grid.measureDistances([{ ray: new Ray(token.center, friend.center) }], { gridSpaces: false })
+            if (dist && dist[0] && (dist[0] / canvas.grid.grid.options.dimensions.distance) <= 5) {
+              existing.add = true
+              existing.level += token.actor.getRoleLevel()
+              existing.names.push(token.actor.name)
+            }
+          }
+          toApply[friend.actor.id] = existing
+        }
+      }
+    }
+    for (let id in toApply) {
+      let applyDef = toApply[id]
+      let hasBonus = applyDef.actor.hasEnhancerBonus()
+      if (applyDef.add) {
+        if (!hasBonus) {
+          applyDef.actor.addEnhancerEffect(applyDef.names.toString(), applyDef.level)
+        } else if (applyDef.level != hasBonus.system.effectlevel) {
+          await applyDef.actor.removeEnhancerEffect()
+          applyDef.actor.addEnhancerEffect(applyDef.names.toString(), applyDef.level)
+        }
+      } else if (hasBonus) {
+        applyDef.actor.removeEnhancerEffect()
+      }
+    }
+    // Delete all effects if no more tacticians (ie deleted case)
+    if (enhancerTokens.length == 0) {
+      let allTokens = canvas.tokens.placeables.filter(token => token.actor.type == "character")
+      for (let token of allTokens) {
+        if (token.actor.hasEnhancerBonus()) {
+          token.actor.removeEnhancerEffect()
+        }
+      }
+    }
+  }
+
+  /* -------------------------------------------- */
+  static async processAgitator() {
+    // Agitator management
+    let toApply = {}
+    let agitatorTokens = canvas.tokens.placeables.filter(token => token.actor.isAgitator())
+    for (let token of agitatorTokens) {
+      token.refresh()
+      if (token.document.disposition == 0) {
+        continue
+      }
+      let disposition = ( token.document.disposition == -1) ? 1 : -1
+      let ennemies = canvas.tokens.placeables.filter(newToken => newToken.actor.type == "character" && !newToken.document.hidden && newToken.document.disposition == disposition)  
+      let neutrals = canvas.tokens.placeables.filter(newToken => newToken.actor.type == "character" && !newToken.document.hidden && newToken.document.disposition == 0)
+      if (neutrals ) {
+        ennemies = ennemies.concat(neutrals)
+      }
+      for (let ennemy of ennemies) {
+        if (ennemy.actor.id != token.actor.id) {
+          let existing = toApply[ennemy.actor.id] || { actor: ennemy.actor, add: false, level: 0, names: [] }
+          let visible = canvas.effects.visibility.testVisibility(ennemy.center, { object: token })
+          if (visible) {
+            let dist = canvas.grid.measureDistances([{ ray: new Ray(token.center, ennemy.center) }], { gridSpaces: false })
+            if (dist && dist[0] && (dist[0] / canvas.grid.grid.options.dimensions.distance) <= 5) {
+              existing.add = true
+              existing.level += token.actor.getRoleLevel()
+              existing.names.push(token.actor.name)
+            }
+          }
+          toApply[ennemy.actor.id] = existing
+        }
+      }
+    }
+    for (let id in toApply) {
+      let applyDef = toApply[id]
+      let hasHindrance = applyDef.actor.hasAgitatorHindrance()
+      if (applyDef.add) {
+        if (!hasHindrance) {
+          applyDef.actor.addAgitatorHindrance(applyDef.names.toString(), applyDef.level)
+        } else if (applyDef.level != hasHindrance.system.effectlevel) {
+          await applyDef.actor.removeAgitatorHindrance()
+          applyDef.actor.addAgitatorHindrance(applyDef.names.toString(), applyDef.level)
+        }
+      } else if (hasHindrance) {
+        applyDef.actor.removeAgitatorHindrance()
+      }
+    }
+    // Delete all effects if no more tacticians (ie deleted case)
+    if (agitatorTokens.length == 0) {
+      let allTokens = canvas.tokens.placeables.filter(token => token.actor.type == "character")
+      for (let token of allTokens) {
+        if (token.actor.addAgitatorHindrance()) {
+          token.actor.removeAgitatorHindrance()
+        }
+      }
+    }
+
+  }
+
+  /* -------------------------------------------- */
+  static async processRoleEffects() {
+
+    // Small optimization
+    let now = Date.now()
+    if (now - this.lastRoleEffectProcess < 300) {
+      return // Save some processing
+    }
+    this.lastRoleEffectProcess = now
+    console.log("=========================+> Searching/Processing roles effects")
+
+    await this.processTactician()
+    await this.processEnhancer()
+    await this.processAgitator()
+
+  }
+
+  /* -------------------------------------------- */
+  static async refreshSightForEffect() {
+    setTimeout(500, this.processRoleEffects())
+  }
+
 }

system.json

@@ -253,7 +253,7 @@
   ],
   "title": "Pegasus RPG",
   "url": "https://www.uberwald.me/data/files/fvtt-pegasus-rpg",
-  "version": "10.0.26",
-  "download": "https://www.uberwald.me/gitea/uberwald/fvtt-pegasus-rpg/archive/fvtt-pegasus-rpg-v10.0.26.zip",
+  "version": "10.0.32",
+  "download": "https://www.uberwald.me/gitea/uberwald/fvtt-pegasus-rpg/archive/fvtt-pegasus-rpg-v10.0.32.zip",
   "background": "systems/fvtt-pegasus-rpg/images/ui/pegasus_welcome_page.webp"
 }

template.json

@@ -154,6 +154,7 @@
           "label": "MR (Initiative)",
           "type": "dice",
           "value": 0,
+          "bonuseffect": 0,
           "mod": 0
         },
         "momentum": {
@@ -412,6 +413,9 @@
       "physicalimmunity": false,
       "nobonusdice": false,
       "noperksallowed": false,
+      "affectstatus": false,
+      "affectedstatus": "",
+      "locked": false,
       "description": ""
     },
     "race": {

templates/actor-sheet.html

@@ -302,18 +302,30 @@
           </li>
 
           {{#each effects as |effect key|}}
-          <li class="item stat flexrow list-item list-item-shadow" data-arme-id="{{effect.id}}"
-            data-item-id="{{effect._id}}">
-            <a class="item-edit item-name-img" title="Edit Item"><img class="sheet-competence-img"
-                src="{{effect.img}}" /></a>
+          <li class="item stat flexrow list-item list-item-shadow" data-arme-id="{{effect.id}}" data-item-id="{{effect._id}}">
+            {{#if effect.system.locked}}
+              {{#if @root.isGM}}
+                <a class="item-edit item-name-img" title="Edit Item"><img class="sheet-competence-img" src="{{effect.img}}" /></a>
+              {{else}}
+                <img class="sheet-competence-img" src="{{effect.img}}" />
+              {{/if}}
+            {{else}}
+              <a class="item-edit item-name-img" title="Edit Item"><img class="sheet-competence-img" src="{{effect.img}}" /></a>
+            {{/if}}
             <span class="item-name-label-long2">{{effect.name}}</span>
             <span class="item-field-label-short">{{effect.system.effectlevel}}</span>
             <span class="item-field-label-short">{{upperFirst effect.system.type}}</span>
-            <span class="item-field-label-short">{{upperFirst effect.datsystema.genre}}</span>
+            <span class="item-field-label-short">{{upperFirst effect.system.genre}}</span>
             <span class="item-field-label-short">{{upper effect.system.stataffected}}</span>
             <div class="item-filler">&nbsp;</div>
             <div class="item-controls item-controls-fixed">
-              <a class="item-control item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
+              {{#if effect.system.locked}}
+                {{#if  @root.isGM}}
+                  <a class="item-control item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
+                {{/if}}
+              {{else}}
+                <a class="item-control item-delete" title="Delete Item"><i class="fas fa-trash"></i></a>
+              {{/if}}
             </div>
           </li>
           {{/each}}

templates/item-effect-sheet.html

@@ -61,11 +61,13 @@
             <li class="flexrow"><label class="generic-label">No perks allowed ?</label>
               <label class="attribute-value checkbox"><input type="checkbox" name="system.noperksallowed" {{checked data.noperksallowed}}/></label>
             </li>
+            <li class="flexrow"><label class="generic-label">Locked (Only GM can change/edit) ?</label>
+              <label class="attribute-value checkbox"><input type="checkbox" name="system.locked" {{checked data.locked}}/></label>
+            </li>
 
             <li class="flexrow"><label class="generic-label">Effect Level is a Stat?</label>
               <label class="attribute-value checkbox"><input type="checkbox" name="system.effectstatlevel" {{checked data.effectstatlevel}}/></label>
             </li>
-
             {{#if data.effectstatlevel}}
               <li class="flexrow"><label class="generic-label">Stat to use for Effect Level</label>
                 <select class="competence-base flexrow" type="text" name="system.effectstat" value="{{data.effectstat}}" data-dtype="String">
@@ -82,7 +84,24 @@
                 <label class="attribute-value checkbox"><input type="checkbox" name="system.affectsize" {{checked data.affectsize}}/></label>
               </li>              
             {{/if}}
-            
+
+            <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>
+                <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="nrg">NRG</option>
+                  {{/select}}
+                </select> 
+              </li>
+            {{/if}}
+
             <li class="flexrow"> <label class="generic-label">Affected Specialisations </label></li>
             <li class="flexrow">
               <ul class="ul-level1">

templates/item-power-sheet.html

@@ -34,8 +34,8 @@
     <div class="tab details" data-group="primary" data-tab="details">
       <ul>
         <li class="flexrow"><label class="generic-label">Roll Needed ?</label>
-          <label class="attribute-value checkbox"><input type="checkbox" name="system.rollneeded" {{checked
-              data.rollneeded}} /></label>
+          <label class="attribute-value checkbox">
+          <input type="checkbox" name="system.rollneeded" {{checked data.rollneeded}} /></label>
         </li>
         {{#if data.rollneeded}}
         <li class="flexrow"><label class="generic-label">Related Statistic (only if roll is needed)</label>

templates/partial-actor-status.html

@@ -18,7 +18,7 @@
         </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"/>
+      <input type="text" class="padd-right status-small-label no-grow" name="system.secondary.{{key}}.bonus" value="{{stat2.bonus}}" data-dtype="Number" disabled/>
       <input type="text" class="padd-right status-small-label no-grow" name="system.secondary.{{key}}.max" value="{{stat2.max}}" data-dtype="Number"/>
     </li>
   {{/each}}
@@ -27,7 +27,7 @@
       <label class="status-small-label"><strong>{{data.nrg.label}}</strong></label>               
     </span>
     <input type="text" class="padd-right status-small-label no-grow" name="system.nrg.value" value="{{data.nrg.value}}" data-dtype="Number"/>
-    <input type="text" class="padd-right status-small-label no-grow" name="system.nrg.mod" value="{{data.nrg.mod}}" data-dtype="Number"/>
+    <input type="text" class="padd-right status-small-label no-grow" name="system.nrg.mod" value="{{data.nrg.mod}}" data-dtype="Number" disabled/>
     <input type="text" class="padd-right status-small-label no-grow" name="system.nrg.max" value="{{data.nrg.max}}" data-dtype="Number"/>
     <span class="small-label status-small-label">&nbsp;/ {{data.nrg.absolutemax}}</span>
   </li>

templates/roll-dialog-generic.html

@@ -119,10 +119,9 @@
           <option value="d4">Slight cover d4</option>
           <option value="d8">Half cover d8</option>
           <option value="d12">Full cover d12</option>
-          <option value="d12">Full cover d12</option>
           <option value="none2">===== Cover Damage Resistance</option>
           <option value="d4">Soft cover d4</option>
-          <option value="d6">Dense cover d16</option>
+          <option value="d6">Dense cover d6</option>
           <option value="d8">Light cover d8</option>
           <option value="d10">Thick cover d10</option>
           <option value="d12">Solid cover d12</option>
@@ -131,7 +130,7 @@
           <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 d1<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="none4">===== Impact DMG Bonus</option>