Fix #103 size warning

modules/pegasus-actor-sheet.js

@@ -61,6 +61,7 @@ export class PegasusActorSheet extends ActorSheet {
       encCapacity: this.actor.getEncumbranceCapacity(),
       levelRemainingList: this.actor.getLevelRemainingList(),
       maxLevelRemainingList: this.actor.getMaxLevelRemainingList(),
+      disabledBonus: (this.actor.system.biodata.noautobonus) ? "" : "disabled",
       containersTree: this.actor.containersTree,
       encCurrent: this.actor.encCurrent,
       encHindrance: this.actor.encHindrance,
@@ -249,13 +250,13 @@ export class PegasusActorSheet extends ActorSheet {
       this.actor.rollPool( 'def', true, "defence");
     });
     html.find('.damage-melee').click((event) => {
-      this.actor.rollPool( 'str', false, "melee-dmg");
+      this.actor.rollPool( 'str', false, "melee-dmg")
     });
     html.find('.damage-ranged').click((event) => {
       this.actor.rollPool( 'per', false, "ranged-dmg");
     });
     html.find('.damage-resistance').click((event) => {
-      this.actor.rollPool( 'phy', false, "dmg-res");
+      this.actor.rollPool( 'phy', false, "dmg-res")
     });
             
     html.find('.roll-stat').click((event) => {

modules/pegasus-actor.js

@@ -124,9 +124,9 @@ export class PegasusActor extends Actor {
       this.updateSize()
     }
     if (this.type == 'vehicle') {
-      this.computeVehicleStats();
+      this.computeVehicleStats()
     }
-    super.prepareDerivedData();
+    super.prepareDerivedData()
   }
 
   /* -------------------------------------------- */
@@ -240,7 +240,7 @@ export class PegasusActor extends Actor {
   /* -------------------------------------------- */
   getRoleLevel() {
     let role = this.items.find(item => item.type == 'role')
-    if (role ) {
+    if (role) {
       console.log("Role", role)
       return role.system.rolelevel
     }
@@ -253,23 +253,26 @@ export class PegasusActor extends Actor {
     return role && role.system.perksrole == "tactician"
   }
   hasTacticianBonus() {
-    let effect = this.items.find( item => item.name.toLowerCase().includes("tactician bonus dice") )
+    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.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})` })
+    ChatMessage.create({
+      content: `Tactician Bonus Dice has been added to ${this.name} (${level})`,
+      whisper: ChatMessage.getWhisperRecipients('GM')
+    })
   }
   async removeTacticianEffect() {
-    let effect = this.items.find( item => item.name.toLowerCase().includes("tactician bonus dice") )
+    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}` })  
+      ChatMessage.create({ content: `Tactician Bonus Dice has been removed to ${this.name}`, whisper: ChatMessage.getWhisperRecipients('GM') })
     }
   }
 
@@ -279,23 +282,23 @@ export class PegasusActor extends Actor {
     return role && role.system.perksrole == "enhancer"
   }
   hasEnhancerBonus() {
-    let effect = this.items.find( item => item.name.toLowerCase().includes("enhancer bonus dice") )
+    let effect = this.items.find(item => item.name.toLowerCase().includes("enhancer bonus dice"))
     return effect
   }
-  async addEnhancerEffect( name, level) {
+  async addEnhancerEffect(name, level) {
     let effect = duplicate(__bonusEffect)
     effect.name = `${name} Enhancer Bonus Dice ALL`
-    effect.system.effectlevel = level 
+    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})` })
+    ChatMessage.create({ content: `Enhancer Bonus Dice has been added to ${this.name} (${level})`, whisper: ChatMessage.getWhisperRecipients('GM') })
   }
   async removeEnhancerEffect() {
-    let effect = this.items.find( item => item.name.toLowerCase().includes("enhancer bonus dice") )
+    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}` })  
+      ChatMessage.create({ content: `Enhancer Bonus Dice has been removed to ${this.name}`, whisper: ChatMessage.getWhisperRecipients('GM') })
     }
   }
 
@@ -305,24 +308,24 @@ export class PegasusActor extends Actor {
     return role && role.system.perksrole == "agitator"
   }
   hasAgitatorHindrance() {
-    let effect = this.items.find( item => item.name.toLowerCase().includes("hindered by agitator") )
+    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.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})` })
+    ChatMessage.create({ content: `Agitator Hindrance has been added to ${this.name} (${level})`, whisper: ChatMessage.getWhisperRecipients('GM') })
   }
   async removeAgitatorHindrance() {
-    let effect = this.items.find( item => item.name.toLowerCase().includes("hindered by agitator") )
+    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}` })  
+      ChatMessage.create({ content: `Agitator Hindrance has been removed to ${this.name}`, whisper: ChatMessage.getWhisperRecipients('GM') })
     }
   }
 
@@ -808,9 +811,11 @@ export class PegasusActor extends Actor {
         ChatMessage.create({ content: "Effects of this type cannot be applied while Immunity is applied" })
         return
       }
+      if (item.system.droptext && item.system.droptext.length > 0) {
+        ChatMessage.create({ content: `Effect ${item.name} message : ${item.system.droptext}` })
+      }
     }
 
-
     if (item.type == 'race') {
       this.applyRace(item)
     } else if (item.type == 'role') {
@@ -909,12 +914,16 @@ export class PegasusActor extends Actor {
   getStat(statKey) {
     let stat
     if (this.type == "character" && statKey == 'mr') {
-      stat = duplicate(this.system.mr);
+      stat = duplicate(this.system.mr)
     } else {
-      stat = duplicate(this.system.statistics[statKey]);
+      stat = duplicate(this.system.statistics[statKey])
     }
-    stat.dice = PegasusUtility.getDiceFromLevel(stat.value || stat.level);
-    return stat;
+    if (stat.currentlevel) {
+      stat.dice = PegasusUtility.getDiceFromLevel(stat.currentlevel)
+    } else {
+      stat.dice = PegasusUtility.getDiceFromLevel(stat.value || stat.level)
+    }
+    return stat
   }
 
   /* -------------------------------------------- */
@@ -1442,6 +1451,9 @@ export class PegasusActor extends Actor {
 
   /* -------------------------------------------- */
   parseStatEffects() {
+    if (this.system.biodata.noautobonus) { // If we are in "no-bonus mode
+      return
+    }
     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])
@@ -1460,6 +1472,9 @@ export class PegasusActor extends Actor {
 
   /* -------------------------------------------- */
   parseStatusEffects() {
+    if (this.system.biodata.noautobonus) { // If we are in "no-bonus mode
+      return
+    }
     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])
@@ -1745,8 +1760,8 @@ export class PegasusActor extends Actor {
   }
 
   /* -------------------------------------------- */
-  addArmorsShields(rollData, statKey = "none", useShield = false) {
-    if (statKey == 'phy') {
+  addArmorsShields(rollData, statKey = "none", useShield = false, subKey = undefined) {
+    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 })
@@ -1795,6 +1810,27 @@ export class PegasusActor extends Actor {
     }
   }
 
+  /* -------------------------------------------- */
+  processVehicleTargetMessage(rollData) {
+    if (rollData.defenderTokenId) {
+      let vehicle = game.canvas.tokens.get(rollData.defenderTokenId).actor
+      if (vehicle.type == "vehicle") {
+        if (rollData.subKey == "defence" && vehicle.system.statistics.ad.currentspeed == "crawling") {
+          ChatMessage.create({ content: `${vehicle.name} is moving at Crawling speed : add a D8 to your Attack Dice Pool against this Vehicle` })
+        }
+        if (rollData.subKey == "defence" && vehicle.system.statistics.ad.currentspeed == "slow") {
+          ChatMessage.create({ content: `${vehicle.name} is moving at Slow speed : add a D4 to your Attack Dice Pool against this Vehicle` })
+        }
+      }
+      if (this.type == "vehicle"  && rollData.statKey == "man" && this.system.statistics.ad.currentspeed == "fast") {
+        ChatMessage.create({ content: `Vehicle is moving at Fast speed : anyone using the vehicles MAN Dice Pool suffers a D8 Hindrance which is added to the Difficulty Dice Pool against this Vehicle` })
+      }
+      if (this.type == "vehicle"  && rollData.statKey == "man" && this.system.statistics.ad.currentspeed == "extfast") {
+        ChatMessage.create({ content: `Vehicle is moving at Extremely Fast speed : anyone using the vehicles MAN Dice Pool suffers a D12 Hindrance which is added to the Difficulty Dice Pool against this Vehicle` })
+      }
+    }
+  }
+
   /* -------------------------------------------- */
   getCommonRollData(statKey = undefined, useShield = false, isInit = false, isPower = false, subKey = "", vehicle = undefined) {
     let rollData = PegasusUtility.getBasicRollData(isInit)
@@ -1819,8 +1855,12 @@ export class PegasusActor extends Actor {
       rollData.stat = this.getStat(statKey)
       if (rollData.stat.value != undefined) {
         rollData.stat.level = rollData.stat.value // Normalize
+        rollData.statDicesLevel = rollData.stat.level + rollData.stat.bonuseffect
+      }
+      if (rollData.stat.currentlevel) {
+        rollData.stat.level = rollData.stat.currentlevel
+        rollData.statDicesLevel = rollData.stat.currentlevel
       }
-      rollData.statDicesLevel = rollData.stat.level + rollData.stat.bonuseffect
       rollData.statMod = rollData.stat.mod
       if (vehicle) {
         rollData.vehicle = duplicate(vehicle)
@@ -1850,8 +1890,6 @@ export class PegasusActor extends Actor {
           vehicle.addVehicleShields(rollData)
         }
         vehicle.addEffects(rollData, false, false, false)
-        //this.addVehiculeHindrances(rollData.effectsList, vehicle)
-        //this.addVehicleBonus(rollData, vehicle)
       }
 
       rollData.specList = this.getRelevantSpec(statKey)
@@ -1868,11 +1906,35 @@ export class PegasusActor extends Actor {
       }
     }
 
+    if (statKey == "mr") {
+      if (this.type == "character") {
+        rollData.mrVehicle = PegasusUtility.checkIsVehicleCrew(this.id)
+        if (rollData.mrVehicle) {
+          rollData.effectsList.push({
+            label: `Vehicle ${rollData.mrVehicle.name} MR Bonus`,
+            type: "effect", applied: false, isdynamic: true, value: rollData.mrVehicle.system.statistics.mr.currentlevel
+          })
+        }
+      }
+      if (this.type == "vehicle") {
+        for (let member of this.system.crew) {
+          let actor = game.actors.get(member.id)
+          let specList = actor.getRelevantSpec("mr")
+          rollData.effectsList.push({
+            label: `Crew ${actor.name} MR Bonus`,
+            type: "effect", applied: false, isdynamic: true, value: actor.system.mr.value + actor.system.mr.bonuseffect, specList: specList
+          })
+        }
+      }
+    }
+
     this.processSizeBonus(rollData)
     this.addEffects(rollData, isInit, isPower, subKey == "power-dmg")
-    this.addArmorsShields(rollData, statKey, useShield)
+    this.addArmorsShields(rollData, statKey, useShield, subKey)
     this.addWeapons(rollData, statKey, useShield)
     this.addEquipments(rollData, statKey)
+    this.processVehicleTargetMessage(rollData)
+
     console.log("ROLLDATA", rollData)
 
     return rollData
@@ -1881,7 +1943,14 @@ export class PegasusActor extends Actor {
   /* -------------------------------------------- */
   processSizeBonus(rollData) {
     if (rollData.defenderTokenId) {
-      let diffSize = rollData.defenderSize - this.system.biodata.sizenum + this.system.biodata.sizebonus
+      let diffSize = 0
+      if (this.type == "character") {
+        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
+      } else {
+        diffSize = rollData.defenderSize - this.system.statistics.hr.size
+      }
       //console.log("Diffsize", diffSize)
       if (rollData.subKey == "melee-atk" || rollData.subKey == "ranged-atk") {
         if (diffSize > 0) {
@@ -1978,7 +2047,7 @@ export class PegasusActor extends Actor {
 
   /*-------------------------------------------- */
   rollStat(statKey) {
-    let stat = this.getStat(statKey);
+    let stat = this.getStat(statKey)
     if (stat) {
       let rollData = this.getCommonRollData(statKey)
       rollData.mode = "stat"
@@ -2132,6 +2201,23 @@ export class PegasusActor extends Actor {
     effect.system.isspeed = speed
     await this.createEmbeddedDocuments("Item", [effect])
   }
+  /* -------------------------------------------- */
+  processVehicleStatEffects() {
+    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
+      for (let effect of effects) {
+        if (effect.system.stataffected == statKey) {
+          bonus += Number(effect.system.effectlevel)
+        }
+      }
+      if (bonus != stat.bonuseffect) {
+        stat.bonuseffect = bonus
+        this.update({ [`system.statistics.${statKey}`]: stat })
+      }
+    }
+  }
 
   /* -------------------------------------------- */
   async computeVehicleStats() {
@@ -2223,6 +2309,7 @@ export class PegasusActor extends Actor {
         ChatMessage.create({ content: `The vehicle ${this.name} has been destroyed !` })
       }
       this.processVehicleArmorShields()
+      this.processVehicleStatEffects()
     }
   }
 
@@ -2247,6 +2334,9 @@ export class PegasusActor extends Actor {
       return
     }
 
+    if (item.type == "effect" && item.system.droptext && item.system.droptext.length > 0) {
+      ChatMessage.create({ content: `Effect ${item.name} message : ${item.system.droptext}` })
+    }
     //console.log(">>>>> item", item.type, __isVehicleUnique[item.type])
     if (__isVehicleUnique[item.type]) {
       let toDelList = []
@@ -2299,7 +2389,6 @@ export class PegasusActor extends Actor {
     return crew
   }
 
-  /* -------------------------------------------- */
   addCrew(actorId) {
     if (this.system.crew.length >= this.system.crewmax) {
       ui.notifications.warn("Vehicle crew is already full.")
@@ -2309,11 +2398,13 @@ export class PegasusActor extends Actor {
     crewList.push({ id: actorId })
     this.update({ 'system.crew': crewList })
   }
-  /* -------------------------------------------- */
   delCrew(actorId) {
     let crewList = duplicate(this.system.crew.filter(actorDef => actorDef.id != actorId) || [])
     this.update({ 'system.crew': crewList })
   }
+  inCrew(actorId) {
+    return this.system.crew.find(member => member.id == actorId)
+  }
 
   /* -------------------------------------------- */
   isVehicleFullStop() {

modules/pegasus-roll-dialog.js

@@ -90,6 +90,9 @@ export class PegasusRollDialog extends Dialog {
     PegasusUtility.updateDamageDicePool(this.rollData)
     PegasusUtility.updateEffectsBonusDice(this.rollData)
     PegasusUtility.updateHindranceBonusDice(this.rollData)
+    if ( effect.specList) {
+      this.rollData.specList = duplicate(effect.specList)
+    }
   }
 
   /* -------------------------------------------- */

modules/pegasus-utility.js

@@ -146,10 +146,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 && effect.effect.system.bonusdice) {
+      if (effect && 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) {
+      if (effect && 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))
       }
     }
@@ -161,7 +161,9 @@ export class PegasusUtility {
     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))) {
+        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)
       }
     }
     rollData.dicePool = newDicePool
@@ -175,12 +177,13 @@ export class PegasusUtility {
         newDicePool = newDicePool.concat(this.buildDicePool("armor-shield", armor.value, 0))
       }
     }
-    newDicePool = rollData.dicePool.filter(dice => dice.name != "vehicle-shield")
+    newDicePool = newDicePool.filter(dice => dice.name != "vehicle-shield")
     for (let shield of rollData.vehicleShieldList) {
       if (shield.applied) {
         newDicePool = newDicePool.concat(this.buildDicePool("vehicle-shield", shield.value, 0))
       }
     }
+    console.log(">>>>Dicepoool", newDicePool)
     rollData.dicePool = newDicePool
   }
 
@@ -1026,7 +1029,12 @@ export class PegasusUtility {
     if (target) {
       let defenderActor = target.actor
       rollData.defenderTokenId = target.id
-      rollData.defenderSize = Number(defenderActor.system.biodata.sizenum) + Number(defenderActor.system.biodata.sizebonus)
+      rollData.defenderSize = 0
+      if ( defenderActor.type == "character") {
+        rollData.defenderSize = Number(defenderActor.system.biodata.sizenum) + Number(defenderActor.system.biodata.sizebonus)
+      } 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)
@@ -1067,31 +1075,15 @@ export class PegasusUtility {
   }
 
   /* -------------------------------------------- */
-  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 checkIsVehicleCrew(actorId) {
+    let vehicles = game.actors.filter( actor=> actor.type == "vehicle") || []
+    for(let vehicle of vehicles)  {
+      console.log("Checking", vehicle.name)
+      if ( vehicle.inCrew(actorId) ) {
+        return vehicle
+      }
+    }
+    return false
   }
 
   /* -------------------------------------------- */
@@ -1114,12 +1106,13 @@ export class PegasusUtility {
   }
 
   /* -------------------------------------------- */
-  static async processTactician(friends) {
+  static async processTactician() {
     // Tactician management
     let toApply = {}
-    let tacticianTokens = canvas.tokens.placeables.filter(token => token.actor.isTactician())
+    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)  
       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: [] }
@@ -1161,12 +1154,13 @@ export class PegasusUtility {
   }
 
   /* -------------------------------------------- */
-  static async processEnhancer(friends) {
+  static async processEnhancer() {
     // Enhancer management
     let toApply = {}
-    let enhancerTokens = canvas.tokens.placeables.filter(token => token.actor.isEnhancer())
+    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)  
       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: [] }
@@ -1210,12 +1204,22 @@ export class PegasusUtility {
   }
 
   /* -------------------------------------------- */
-  static async processAgitator(ennemies) {
+  static async processAgitator() {
     // Agitator management
     let toApply = {}
-    let agitatorTokens = canvas.tokens.placeables.filter(token => token.actor.isAgitator())
+    let agitatorTokens = canvas.tokens.placeables.filter(token => token.actor.isAgitator() && !token.document.hidden)
     for (let token of agitatorTokens) {
       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 ))
+      }
+      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 ))
+      }
+      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 ))
+      }
       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: [] }
@@ -1246,11 +1250,11 @@ export class PegasusUtility {
         applyDef.actor.removeAgitatorHindrance()
       }
     }
-    // Delete all effects if no more tacticians (ie deleted case)
+    // Delete all effects if no more agtators (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()) {
+        if (token.actor.hasAgitatorHindrance()) {
           token.actor.removeAgitatorHindrance()
         }
       }
@@ -1269,26 +1273,9 @@ export class PegasusUtility {
     this.lastRoleEffectProcess = now
     console.log("=========================+> Searching/Processing roles effects")
 
-    let friends = canvas.tokens.placeables.filter(token => token.actor.type == "character" && token.document.disposition == 1)
-    let ennemies = canvas.tokens.placeables.filter(token => token.actor.type == "character" && token.document.disposition == -1)
-
-    await this.processTactician(friends)
-    await this.processEnhancer(friends)
-    await this.processAgitator(ennemies)
-
-    // Cleanup if disposition has changed
-    let allTokens = canvas.tokens.placeables.filter(token => token.actor.type == "character")
-    for (let token of allTokens) {
-      if (token.document.disposition != -1 && token.actor.hasAgitatorHindrance()) {
-        token.actor.removeAgitatorHindrance()
-      }
-      if (token.document.disposition != 1 && token.actor.hasTacticianBonus()) {
-        token.actor.removeTacticianEffect()
-      }
-      if (token.document.disposition != 1 && token.actor.hasEnhancerBonus()) {
-        token.actor.removeEnhancerEffect()
-      }
-    }
+    await this.processTactician()
+    await this.processEnhancer()
+    await this.processAgitator()
 
   }
 

system.json

@@ -23,7 +23,7 @@
   "manifest": "https://www.uberwald.me/gitea/uberwald/fvtt-pegasus-rpg/raw/branch/master/system.json",
   "compatibility": {
     "minimum": "10",
-    "verified": "10.285",
+    "verified": "10.286",
     "maximum": "10"
   },
   "id": "fvtt-pegasus-rpg",
@@ -253,7 +253,7 @@
   ],
   "title": "Pegasus RPG",
   "url": "https://www.uberwald.me/data/files/fvtt-pegasus-rpg",
-  "version": "10.0.31",
-  "download": "https://www.uberwald.me/gitea/uberwald/fvtt-pegasus-rpg/archive/fvtt-pegasus-rpg-v10.0.31.zip",
+  "version": "10.1.3",
+  "download": "https://www.uberwald.me/gitea/uberwald/fvtt-pegasus-rpg/archive/fvtt-pegasus-rpg-v10.1.3.zip",
   "background": "systems/fvtt-pegasus-rpg/images/ui/pegasus_welcome_page.webp"
 }

template.json

@@ -37,6 +37,7 @@
           "rolename": "",
           "morality": 5,
           "bonusselection": "",
+          "noautobonus": false,
           "moralitythreshold": 0
         }
       },
@@ -416,6 +417,7 @@
       "affectstatus": false,
       "affectedstatus": "",
       "locked": false,
+      "droptext": "",
       "description": ""
     },
     "race": {

templates/actor-sheet.html

@@ -869,6 +869,12 @@
               <label class="generic-label">Hair</label>
               <input type="text" class="" name="system.biodata.hair" value="{{data.biodata.hair}}" data-dtype="String" />
             </li>
+            {{#if isGM}}
+              <li class="item flexrow">
+                <label class="generic-label">Manual bonuses only ?</label>
+                <input type="checkbox" class="change-worstfear" name="system.biodata.noautobonus" {{checked data.biodata.noautobonus}} />
+              </li>
+            {{/if}}
           </ul>
         </div>
        <div>

templates/item-effect-sheet.html

@@ -34,6 +34,27 @@
               </select> 
             </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">
+                  {{#select data.effectstat}}
+                  {{> systems/fvtt-pegasus-rpg/templates/partial-options-statistics.html notapplicable=false mr=true all=false}}
+                  {{/select}}
+                </select> 
+              </li>
+            {{else}}
+              <li class="flexrow"><label class="generic-label">Effect Level</label>
+                <input type="text" class="input-numeric-short padd-right" name="system.effectlevel" value="{{data.effectlevel}}" data-dtype="Number"/>
+              </li>
+              <li class="flexrow"><label class="generic-label">Affect size ?</label>
+                <label class="attribute-value checkbox"><input type="checkbox" name="system.affectsize" {{checked data.affectsize}}/></label>
+              </li>              
+            {{/if}}
+
+            
             <li class="flexrow"><label class="generic-label">One use?</label>
               <label class="attribute-value checkbox"><input type="checkbox" name="system.oneuse" {{checked data.oneuse}}/></label>
             </li>
@@ -64,27 +85,10 @@
             <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 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>
-            {{#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">
-                  {{#select data.effectstat}}
-                  {{> systems/fvtt-pegasus-rpg/templates/partial-options-statistics.html notapplicable=false mr=true all=false}}
-                  {{/select}}
-                </select> 
-              </li>
-            {{else}}
-              <li class="flexrow"><label class="generic-label">Effect Level</label>
-                <input type="text" class="input-numeric-short padd-right" name="system.effectlevel" value="{{data.effectlevel}}" data-dtype="Number"/>
-              </li>
-              <li class="flexrow"><label class="generic-label">Affect size ?</label>
-                <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>

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" disabled/>
+      <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"/>
     </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" disabled/>
+    <input type="text" class="padd-right status-small-label no-grow" name="system.nrg.mod" value="{{data.nrg.mod}}" data-dtype="Number" {{@root.disabledBonus}}/>
     <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/partial-vehicle-stat-block.html

@@ -14,7 +14,7 @@
       </span>
       <select class="status-small-label color-class-common" type="text" name="system.statistics.{{key}}.level"
         value="{{stat.level}}" data-dtype="Number" disabled>
-        {{#select stat.level}}
+        {{#select (add stat.level stat.bonuseffect)}}
           {{#if (eq key "ad")}}
             {{{@root.optionsLevel}}}
           {{else}}