From 7c42e83ffc7e1e29892abc62d8d4ccb3afff9a38 Mon Sep 17 00:00:00 2001
From: Nightwalker450 <nightwalker450@gmail.com>
Date: Sat, 13 May 2023 20:18:57 -0700
Subject: [PATCH] Versioning, various minor cleaning

---
 HeroSystem6eHeroic/HeroSystem6eHeroic.css  |  22 +-
 HeroSystem6eHeroic/HeroSystem6eHeroic.html | 920 ++++++++++-----------
 2 files changed, 455 insertions(+), 487 deletions(-)

diff --git a/HeroSystem6eHeroic/HeroSystem6eHeroic.css b/HeroSystem6eHeroic/HeroSystem6eHeroic.css
index ef257755cb..544e0f6f23 100644
--- a/HeroSystem6eHeroic/HeroSystem6eHeroic.css
+++ b/HeroSystem6eHeroic/HeroSystem6eHeroic.css
@@ -1312,7 +1312,7 @@
 		background-color: #fff990;
 		margin: 5px;
 		width: 450px;
-		height: 213px;
+		height: 225px;
 		margin: 0px;
 		border: solid 2px goldenrod;
 		border-radius: 3px;
@@ -1327,7 +1327,27 @@
 		max-height: 28px;
 		margin-left: 10px;
 	}
+
+	/* --------------------------------------------------- */
+	/* Version Info                                        */
+	/* --------------------------------------------------- */
 	
+	.item-version-row {
+		display: grid;
+		grid-template-areas: "versionLabel versionInfo";
+		justify-content: flex-end;
+		align-items: baseline;
+	}
+
+	.item-version-label h2 {
+		font-size: 13px;
+	}
+	
+	.item-version-information input[readonly] {
+		background-color: #fff990;
+		max-width: 45px;
+	}
+
 	/* --------------------------------------------------- */
 	/* Custom buttons                                      */
 	/* --------------------------------------------------- */
diff --git a/HeroSystem6eHeroic/HeroSystem6eHeroic.html b/HeroSystem6eHeroic/HeroSystem6eHeroic.html
index 93c2137db5..5a27b18533 100644
--- a/HeroSystem6eHeroic/HeroSystem6eHeroic.html
+++ b/HeroSystem6eHeroic/HeroSystem6eHeroic.html
@@ -345,16 +345,16 @@
 					<div class="subitem-characteristics-perception-stat-container">
 						<h1>Perception</h1>
 						<div class="subitem-characteristics-perception-column-container">
-							<input type="text" name="attr_perceptionBase" title="@{perceptionBase}" value="11" readonly tabindex="-1">
+							<input type="text" name="attr_intelligenceChance" title="@{intelligenceChance}" value="11" readonly tabindex="-1">
 							<span>+<input type="number" name="attr_enhancedPerceptionModifier" title="@{enhancedPerceptionModifier}" value="0" min="-10" max="10" step="1" tabindex="29"></span>
-							<button type="roll" class="button buttonRoll" tabindex="-1" name="roll_perceptionRoll" title="%{perceptionRoll}" value="&{template:custom} {{title=@{character_name} - @{character_title}}} {{subtitle= Uses Perception}} {{Base Chance = [[@{perceptionBase}[Intelligence Chance]+@{enhancedPerceptionModifier}[Perception Modifier]+?{Modifiers|0}[Modifier]]] }} {{Roll=[[3d6cf<7cs>0]]}} {{}}" >Roll</button>
+							<button type="roll" class="button buttonRoll" tabindex="-1" name="roll_perceptionRoll" title="%{perceptionRoll}" value="&{template:custom} {{title=@{character_name} - @{character_title}}} {{subtitle= Uses Perception}} {{Base Chance = [[@{intelligenceChance}[Intelligence Chance]+@{enhancedPerceptionModifier}[Perception Modifier]+?{Modifiers|0}[Modifier]]] }} {{Roll=[[3d6cf<7cs>0]]}} {{}}" >Roll</button>
 						</div>
 					</div>
 					
 					<div class="subitem-characteristics-perception-stat-container">
 						<input type="text" value="Vision" name="attr_perceptionVisionLabel" title="@{perceptionVisionLabel}" maxlength="12" tabindex="30">
 						<div class="subitem-characteristics-perception-column-container">
-							<input type="text" name="attr_perceptionVision" title="@{perceptionVision}" value="11" readonly tabindex="-1">
+							<input type="text" name="attr_perceptionEnhanced" title="@{perceptionEnhanced}" value="11" readonly tabindex="-1">
 							<span>+<input type="number" name="attr_perceptionModifierVision" title="@{perceptionModifierVision}" value="0" min="-10" max="10" step="1" tabindex="31"></span>
 							<button type="roll" class="button buttonRoll" tabindex="-1" name="roll_perceptionRollVision" title="%{roll_perceptionRollVision}" value="&{template:custom} {{title=@{character_name} - @{character_title}}} {{subtitle= Uses Perception - @{perceptionVisionLabel} }} {{Base Chance = [[@{intelligenceChance}[Intelligence Chance]+@{enhancedPerceptionModifier}[Perception Modifier]+@{perceptionModifierVision}[@{perceptionVisionLabel} Modifier]+?{Modifiers|0}[Modifier]]] }} {{Roll=[[3d6cf<7cs>0]]}} {{}}" >Roll</button>
 						</div>
@@ -363,7 +363,7 @@
 					<div class="subitem-characteristics-perception-stat-container">
 						<input type="text" value="Hearing" name="attr_perceptionHearingLabel" title="@{perceptionHearingLabel}" maxlength="12" tabindex="32">
 						<div class="subitem-characteristics-perception-column-container">
-							<input type="text" name="attr_perceptionHearing" title="@{perceptionHearing}" value="11" readonly tabindex="-1">
+							<input type="text" name="attr_perceptionEnhanced" title="@{perceptionEnhanced}" value="11" readonly tabindex="-1">
 							<span>+<input type="number" name="attr_perceptionModifierHearing" title="@{perceptionModifierHearing}" value="0" min="-10" max="10" step="1" tabindex="33"></span>
 							<button type="roll" class="button buttonRoll" tabindex="-1" name="roll_perceptionRollHearing" title="%{roll_perceptionRollHearing}" value="&{template:custom} {{title=@{character_name} - @{character_title}}} {{subtitle= Uses Perception - @{perceptionHearingLabel} }} {{Base Chance = [[?{Modifiers|0}+@{intelligenceChance}[Intelligence Chance]+@{enhancedPerceptionModifier}[Perception Modifier]+@{perceptionModifierHearing}[@{perceptionHearingLabel} Modifier]+?{Modifiers|0}[Modifier]]] }} {{Roll=[[3d6cf<7cs>0]]}} {{}}" >Roll</button>
 						</div>
@@ -372,7 +372,7 @@
 					<div class="subitem-characteristics-perception-stat-container">
 						<input type="text" value="Smell" name="attr_perceptionSmellLabel" title="@{perceptionSmellLabel}" maxlength="12" tabindex="34">
 						<div class="subitem-characteristics-perception-column-container">
-							<input type="text" name="attr_perceptionSmell" title="@{perceptionSmell}" value="11" readonly tabindex="-1">
+							<input type="text" name="attr_perceptionEnhanced" title="@{perceptionEnhanced}" value="11" readonly tabindex="-1">
 							<span>+<input type="number" name="attr_perceptionModifierSmell" title="@{perceptionModifierSmell}" value="0" min="-10" max="10" step="1" tabindex="35"></span>
 							<button type="roll" class="button buttonRoll" tabindex="-1" name="roll_perceptionRollSmell" title="%{roll_perceptionRollSmell}" value="&{template:custom} {{title=@{character_name} - @{character_title}}} {{subtitle= Uses Perception - @{perceptionSmellLabel} }} {{Base Chance = [[?{Modifiers|0}+@{intelligenceChance}[Intelligence Chance]+@{enhancedPerceptionModifier}[Perception Modifier]+@{perceptionModifierSmell}[@{perceptionSmellLabel} Modifier]+?{Modifiers|0}[Modifier]]] }} {{Roll=[[3d6cf<7cs>0]]}} {{}}" >Roll</button>
 						</div>
@@ -5494,6 +5494,16 @@
 				</label>
 				<h1>Takes No STUN</h1>
 			</div>
+
+			<div class="item-version-row">
+				<div class="item-version-label">
+					<h2>Version:</h2>
+				</div>
+				
+				<div class="item-version-information">
+					<input type="text" value="2.0" name="attr_version" title="@{version}" readonly tabindex="-1"/>
+				</div>
+			</div>
 		</div>	
 	</div>
 </div>
@@ -5523,6 +5533,9 @@
 
 <!-- Hidden variables to protect characteristics during option changes -->
 <input type="hidden" name="attr_hiddenSTUN" value="20"/>
+<input type="hidden" name="CurrentBODY_max" value="10"/>
+<input type="hidden" name="CurrentSTUN_max" value="20"/>
+<input type="hidden" name="CurrentEND_max" value="20"/>
 
 <!-- Some hidden variables to help simplify skill point calculations -->
 <input type="hidden" name="attr_hiddenSet1SkillsCost"  value="0"/>
@@ -5685,17 +5698,69 @@
 
 <script type="text/worker">
 
-	// Get the URL to the pseudo attribute attr_character_avatar for use in the Portrait Section.
-	on("sheet:opened", function() {  
-		getAttrs(["character_avatar"], function(values) {
-			let theAvatarURL=values.character_avatar;
-								 
-			setAttrs({
-				theSheetAvatar:theAvatarURL
-			});
-		});
-	});
+    //Async functions
+    const setActiveCharacterId = function(charId){
+        var oldAcid=getActiveCharacterId();
+        var ev = new CustomEvent("message");
+        ev.data={"id":"0", "type":"setActiveCharacter", "data":charId};
+        self.dispatchEvent(ev); 
+        return oldAcid;
+    };
+    
+    const _getAttrs = function (props){
+        var acid=getActiveCharacterId(); //save the current activeCharacterID in case it has changed when the promise runs 
+        var prevAcid=null;               //local variable defined here, because it needs to be shared across the promise callbacks defined below
+        return new Promise((resolve,reject)=>{
+                prevAcid=setActiveCharacterId(acid);  //in case the activeCharacterId has changed, restore it to what we were expecting and save the current value to restore later
+                try{
+                    getAttrs(props,(values)=>{  resolve(values); }); 
+                }
+                catch{ reject(); }
+        }).finally(()=>{
+            setActiveCharacterId(prevAcid); //restore activeCharcterId to what it was when the promise first ran
+        });
+    };
 
+	// Get the URL to the pseudo attribute attr_character_avatar for use in the Portrait Section.
+	on("sheet:opened", async function() {
+		let attributes = {sheetTab:"characteristics"};
+
+		// Fetch just what is needed to determine the version
+		let values = await _getAttrs(["version", "totalCharacterCost", "validateMay23", "character_name", "character_avatar"]);
+		let name = values.character_name;
+		let origVersion = parseFloat(values.version)||1.0;
+
+		attributes.theSheetAvatar = values.character_avatar;
+
+		// Check for unversioned sheets
+		if (values.validateMay23 == undefined) {
+			// if no points spent, then it's a new sheet
+			if (parseInt(values.totalCharacterCost)||0 != 0)
+				origVersion = 1.0;
+
+			attributes.validateMay23 = 1;
+		}
+		let version = origVersion;
+
+		
+		if (version < 1.1) {
+			values = await _getAttrs(["intelligenceChance", "enhancedPerceptionModifier", "body", "stun", "endurance"]);
+			attributes.perceptionEnhanced = parseInt(values.intelligenceChance)||11 + parseInt(values.enhancedPerceptionModifier)||0;
+			attributes.CurrentBODY_max = parseInt(values.body)||0;
+			attributes.CurrentSTUN_max = parseInt(values.stun)||0;
+			attributes.CurrentEND_max = parseInt(values.endurance)||0;
+			version = 1.1;
+		};
+
+		if (version != origVersion) {
+			console.log(`Updated ${name} from ${origVersion} to ${version}`);
+			attributes.version = version;
+		}
+
+		// We are doing this with await's in order to only do a single setAttrs at the end
+		setAttrs(attributes);
+	});
+	
 
 	// Tab buttons
 	const buttonlist = ["characteristics","skills","powers","complications","gear","options"];
@@ -5720,7 +5785,7 @@
 	function arrayOf(num) {
 		// For use in our forEach loops, this creates an array of numbers 1 to num
 		return Array.from({length: num}, (_, i) => i + 1);
-	}	
+	}
 
 	function heroRoundHigh(theNumber) {
 		// In the Hero System rounding favors the player. Here where high is good.
@@ -5891,16 +5956,10 @@
 		getAttrs(["currentEND"], function(values) {
 			const currentValue = parseInt(values.currentEND)||0;
 			
-			if (currentValue < 0) {
-				// Attempt to correct negative END values.
-				setAttrs({
-					"currentEND":0
-				});
-			} else {
-				setAttrs({
-					"currentEND":currentValue+1
-				});
-			}
+			// Attempt to correct negative END values.
+			setAttrs({
+				"currentEND": Math.max(0, currentValue+1)
+			});
 		});
 	});
 	
@@ -5909,11 +5968,9 @@
 		getAttrs(["currentEND"], function(values) {
 			const currentValue = parseInt(values.currentEND)||0;
 			
-			if (currentValue > 0) {
-				setAttrs({
-					"currentEND":currentValue-1
-				});
-			}
+			setAttrs({
+				"currentEND":Math.max(0,currentValue-1)
+			});
 		});
 	});
 	
@@ -5925,12 +5982,9 @@
 			
 			currentValue = currentValue - enduranceSpent;
 			
-			if (currentValue < 0) {
-				currentValue = 0;
-			}
-			
+			// Attempt to correct negative END values.
 			setAttrs({
-				"currentEND":currentValue
+				"currentEND":Math.max(0,currentValue)
 			});
 		});
 	}
@@ -5947,9 +6001,9 @@
 			});
 		});
 	});
-
-	/* Recover Buttons */
 	
+	/* Recover Buttons */
+			
 	// Recover endurance and stun when the recover button in the item-characteristics-health box is clicked.
 	on("clicked:recoverHealth", function () {
 		getAttrs(["endurance","stun","CurrentEND", "CurrentSTUN", "recovery"], function(values) {
@@ -5961,7 +6015,7 @@
 			
 			let newSTUN = Math.min(currentSTUN + recovery, maxSTUN);
 			let newEND = Math.min(currentEND + recovery, maxEND);
-
+			
 			// Check to see if character hasn't been boosted above character max by Aid power or similar.
 			setAttrs({
 				CurrentSTUN:Math.max(currentSTUN,newSTUN),
@@ -5969,14 +6023,14 @@
 			});
 		});
 	});
-	
+					
 	/* -------------------------------------- */
 	/* Functions used for characteristics tab */
 	/* -------------------------------------- */
 	function sumCharacteristicPoints() {
 		// Add up points spent on characteristics. 
 		// All character attributes added in one function to avoid getAttrs() limitations.
-		
+	
 		// Add attribute costs in one go
 		getAttrs(["strengthCP","dexterityCP","constitutionCP","intelligenceCP","egoCP","presenceCP","ocvCP","dcvCP","omcvCP","dmcvCP","speedCP","pdCP","edCP","bodyCP","stunCP","enduranceCP","recoveryCP","runningCP","leapingCP","swimmingCP"], function(values) {
 				const strengthCost = parseInt(values.strengthCP)||0;
@@ -5985,43 +6039,43 @@
 				const intelligenceCost = parseInt(values.intelligenceCP)||0;
 				const egoCost = parseInt(values.egoCP)||0;
 				const presenceCost = parseInt(values.presenceCP)||0;
-				
+			
 				const ocvCost = parseInt(values.ocvCP)||0;
 				const dcvCost = parseInt(values.dcvCP)||0;
 				const omcvCost = parseInt(values.omcvCP)||0;
 				const dmcvCost = parseInt(values.dmcvCP)||0;
-				
+	
 				const speedCost = parseInt(values.speedCP)||0;
-				
+			
 				const pdCost = parseInt(values.pdCP)||0;
 				const edCost = parseInt(values.edCP)||0;
 				const bodyCost = parseInt(values.bodyCP)||0;
 				const stunCost = parseInt(values.stunCP)||0;
 				const endCost = parseInt(values.enduranceCP)||0;
 				const recCost = parseInt(values.recoveryCP)||0;
-				
+	
 				const runningCost = parseInt(values.runningCP)||0;
 				const leapingCost = parseInt(values.leapingCP)||0;
 				const swimmingCost = parseInt(values.swimmingCP)||0;
-				
+			
 				let primaryAttributesCost = strengthCost+dexterityCost+constitutionCost+intelligenceCost+egoCost+presenceCost;	
 				let combatValuesCost = ocvCost+dcvCost+omcvCost+dmcvCost;
 				let defenseCost = pdCost+edCost;
 				let healthCost = bodyCost+stunCost+endCost+recCost;
 				let movementCost = runningCost+leapingCost+swimmingCost;
-				
+			
 				let characterAttributeCost = primaryAttributesCost+combatValuesCost+speedCost+defenseCost+healthCost+movementCost;
-				
-				setAttrs({
+			
+			setAttrs({
 					"characteristicsCost":parseInt(characterAttributeCost)
-				});
+			});
 		});
 	}
-
+	
 	// Update Strength related stats and skills
 	on("change:strength change:useCharacteristicMaximums", function () {
 		getAttrs(["strength","useCharacteristicMaximums"], function(values) {
-		  
+	
 			const statValue = parseInt(values.strength)||0;
 			const useMaximums = values.useCharacteristicMaximums;
 			const baseStat = 10;
@@ -6050,7 +6104,7 @@
 						break;
 				default: liftCapability=Math.round(25*Math.pow(2,(statValue/5)));
 			}
-
+	
 			freeCarry=liftCapability/10;
 			
 			// Update cost and roll chance		
@@ -6069,7 +6123,7 @@
 	// Update Dexterity
 	on("change:dexterity change:useCharacteristicMaximums", function () {
 		getAttrs(["dexterity","useCharacteristicMaximums"], function(values) {
-		  
+			
 			const statValue = parseInt(values.dexterity)||0;
 			const useMaximums = values.useCharacteristicMaximums;
 			const baseStat = 10;
@@ -6081,7 +6135,7 @@
 				statCP=(statValue-maxStat)*costStat+(statValue-baseStat)*costStat;
 			} else {
 				statCP=(statValue-baseStat)*costStat;
-			}	
+			}
 			
 			// Update cost and roll chance		
 			setAttrs({
@@ -6097,7 +6151,7 @@
 	// Update Constitution
 	on("change:constitution change:useCharacteristicMaximums", function () {
 		getAttrs(["constitution","useCharacteristicMaximums"], function(values) {
-		  
+			
 			const statValue = parseInt(values.constitution)||0;
 			const useMaximums = values.useCharacteristicMaximums;
 			const baseStat = 10;
@@ -6109,8 +6163,8 @@
 				statCP=(statValue-maxStat)*costStat+(statValue-baseStat)*costStat;
 			} else {
 				statCP=(statValue-baseStat)*costStat;
-			}	
-			
+			}
+					
 			// Update cost and roll chance		
 			setAttrs({
 				"constitutionCP":statCP,
@@ -6125,7 +6179,7 @@
 	// Update Intelligence
 	on("change:intelligence change:enhancedPerceptionModifier change:useCharacteristicMaximums", function () {
 		getAttrs(["intelligence","useCharacteristicMaximums","enhancedPerceptionModifier"], function(values) {
-		  
+			
 			const statValue = parseInt(values.intelligence)||0;
 			const useMaximums = values.useCharacteristicMaximums;
 			const baseStat = 10;
@@ -6136,30 +6190,27 @@
 			// The base value of perception is the intelligence roll. The Perception roll is the base value plus the enhancedPerceptionModifier. 
 			// Individual senses start at Intelligence Chance + Perception modifier.
 			const enhancedPerceptionMod = parseInt(values.enhancedPerceptionModifier)||0;
-			
+				
 			let statCP = 0;
-	
+			
 			if ( (statValue>maxStat) && (useMaximums != 0) ) {
 				statCP=(statValue-maxStat)*costStat+(statValue-baseStat)*costStat;
-			} else {
+					} else {
 				statCP=(statValue-baseStat)*costStat;
-			}	
-			
+			}
+	
 			// Update cost and roll chance		
-			setAttrs({
+				setAttrs({
 				"intelligenceCP":statCP,
 				"intelligenceChance":calculateRoll(statValue),
-				"perceptionBase":calculateRoll(statValue),
-				"perceptionVision":calculateRoll(statValue)+enhancedPerceptionMod,
-				"perceptionHearing":calculateRoll(statValue)+enhancedPerceptionMod,
-				"perceptionSmell":calculateRoll(statValue)+enhancedPerceptionMod
-			});
-			
+				"perceptionEnhanced":calculateRoll(statValue)+enhancedPerceptionMod
+	});
+
 			// Update costs
 			sumCharacteristicPoints();
+				});
 		});
-	});
-	
+
 	// Update Ego
 	on("change:ego change:useCharacteristicMaximums", function () {
 		getAttrs(["ego","useCharacteristicMaximums"], function(values) {
@@ -6217,7 +6268,7 @@
 	});
 	
 	// Combat Characteristics
-	
+		  
 	// Update Offensive Combat Value
 	on("change:ocv change:useCharacteristicMaximums", function () {
 		getAttrs(["ocv","useCharacteristicMaximums"], function(values) {
@@ -6385,131 +6436,23 @@
 			
 			// Update cost
 			setAttrs({
-				"speedCP":statCP
+				"speedCP":statCP,
+				"speedIndicator01": theSpeed == 12 ? "on" : 0,
+				"speedIndicator02": theSpeed >= 6 ? "on" : 0,
+				"speedIndicator03": [4,5,8,9,10,11,12].includes(theSpeed) ? "on" : 0,
+				"speedIndicator04": [3,6,7,9,10,11,12].includes(theSpeed) ? "on" : 0,
+				"speedIndicator05": [5,8,10,11,12].includes(theSpeed) ? "on" : 0,
+				"speedIndicator06": [2,4,6,7,8,9,10,11,12].includes(theSpeed) ? "on" : 0,
+				"speedIndicator07": [1,7,9,11,12].includes(theSpeed) ? "on" : 0,
+				"speedIndicator08": [3,5,6,8,9,10,11,12].includes(theSpeed) ? "on" : 0,
+				"speedIndicator09": [4,7,8,10,11,12].includes(theSpeed) ? "on" : 0,
+				"speedIndicator10": [5,6,9,10,11,12].includes(theSpeed) ? "on" : 0,
+				"speedIndicator11": theSpeed >= 7 ? "on" : 0,
+				"speedIndicator12": theSpeed != 1 ? "on" : 0
 			});
 			
 			sumCharacteristicPoints();
 			
-			// Update speed indicator checkboxes
-			if (theSpeed==12) {
-				setAttrs({
-					"speedIndicator01":"on"
-				});
-			} else {
-				setAttrs({
-					"speedIndicator01":0
-				});
-			}
-			
-			if (theSpeed>=6) {
-				setAttrs({
-					"speedIndicator02":"on"
-				});
-			} else {
-				setAttrs({
-					"speedIndicator02":0
-				});
-			}
-			
-			if ((theSpeed>=8)||(theSpeed===4)||(theSpeed===5)) {
-				setAttrs({
-					"speedIndicator03":"on"
-				});
-			} else {
-				setAttrs({
-					"speedIndicator03":0
-				});
-			}
-			
-			if ((theSpeed>=9)||(theSpeed===3)||(theSpeed===6)||(theSpeed===7)) {
-				setAttrs({
-					"speedIndicator04":"on"
-				});
-			} else {
-				setAttrs({
-					"speedIndicator04":0
-				});
-			}
-			
-			if ((theSpeed>=10)||(theSpeed===8)||(theSpeed===5)) {
-				setAttrs({
-					"speedIndicator05":"on"
-				});
-			} else {
-				setAttrs({
-					"speedIndicator05":0
-				});
-			}
-			
-			if ((theSpeed>=6)||(theSpeed===2)||(theSpeed===4)) {
-				setAttrs({
-					"speedIndicator06":"on"
-				});
-			} else {
-				setAttrs({
-					"speedIndicator06":0
-				});
-			}
-			
-			if ((theSpeed>=11)||(theSpeed===1)||(theSpeed===7)||(theSpeed===9)) {
-				setAttrs({
-					"speedIndicator07":"on"
-				});
-			} else {
-				setAttrs({
-					"speedIndicator07":0
-				});
-			}
-			
-			if ((theSpeed>=8)||(theSpeed===3)||(theSpeed===5)||(theSpeed===6)) {
-				setAttrs({
-					"speedIndicator08":"on"
-				});
-			} else {
-				setAttrs({
-					"speedIndicator08":0
-				});
-			}
-			
-			if ((theSpeed>=10)||(theSpeed===4)||(theSpeed===7)||(theSpeed===8)) {
-				setAttrs({
-					"speedIndicator09":"on"
-				});
-			} else {
-				setAttrs({
-					"speedIndicator09":0
-				});
-			}
-			
-			if ((theSpeed>=9)||(theSpeed===5)||(theSpeed===6)) {
-				setAttrs({
-					"speedIndicator10":"on"
-				});
-			} else {
-				setAttrs({
-					"speedIndicator10":0
-				});
-			}
-			
-			if (theSpeed>=7) {
-				setAttrs({
-					"speedIndicator11":"on"
-				});
-			} else {
-				setAttrs({
-					"speedIndicator11":0
-				});
-			}
-			
-			if (theSpeed>=2) {
-				setAttrs({
-					"speedIndicator12":"on"
-				});
-			} else {
-				setAttrs({
-					"speedIndicator12":0
-				});
-			}
 		});
 	});
 	
@@ -6600,7 +6543,8 @@
 			
 			// Update cost	
 			setAttrs({
-				"bodyCP":statCP
+				"CurrentBODY_max": statValue,
+				"bodyCP": statCP
 			});
 			
 			// Update costs
@@ -6626,9 +6570,10 @@
 			
 			// Update character. Reset health status.
 			setAttrs({
-				"hiddenSTUN":savedStatValue,
-				"stun":statValue,
-				"currentSTUN":statValue
+				"hiddenSTUN": savedStatValue,
+				"stun": statValue,
+				"currentSTUN": statValue,
+				"currentSTUN_max": statValue
 			});
 			
 			// Update characteristics cost
@@ -6654,6 +6599,7 @@
 				// Reset STUN and cost to zero.
 				setAttrs({
 					"stun":0,
+					"CurrentSTUN_max": 0,
 					"stunCP":0
 				});
 				
@@ -6668,6 +6614,7 @@
 				
 				setAttrs({
 					"hiddenSTUN":statValue,
+					"CurrentSTUN_max": statValue,
 					"stunCP":heroRoundLow(statCP)
 				});
 			}	
@@ -6696,6 +6643,7 @@
 			
 			// Update cost	
 			setAttrs({
+				"CurrentEND_max": statValue,
 				"enduranceCP":heroRoundLow(statCP)
 			});
 			
@@ -6862,7 +6810,7 @@
 	/* -------------------------------------------------- */
 	/* Functions used for talents and complications tab   */
 	/* -------------------------------------------------- */
-
+	
 	// Update Tally Bar after change notice any complication's CP benefit.
 	on("change:complicationCP01 change:complicationCP02 change:complicationCP03 change:complicationCP04 change:complicationCP05 change:complicationCP06", function () {
 		getAttrs(["complicationCP01","complicationCP02","complicationCP03","complicationCP04","complicationCP05","complicationCP06"], function(values) {
@@ -6881,13 +6829,13 @@
 			let talentsCost = 0;
 			for (let i = 0; i < maxTalentNum; i++)
 				talentsCost += parseInt(values["talentCP"+String(i).padStart(2,'0')])||0;
-			
+
 			let powersCost = 0;
 			for (let i = 0; i < maxPowerNum; i++)
 				powersCost += parseInt(values["powerCP"+String(i).padStart(2,'0')])||0;
 			
 			setAttrs({
-				"powersPerksTalentsCost":(talentsCost+powersCost)
+				"powersPerksTalentsCost":(talentsCost + powersCost)
 			});
 		});
 	}
@@ -7029,7 +6977,7 @@
 			default: return 0;
 		}
 	}
-
+	
 	/* Expanders for Powers */
 	arrayOf(maxPowerNum).forEach(num => {
 		var button = "powerExpand"+String(num).padStart(2,'0');
@@ -7056,41 +7004,41 @@
 				var increasedENDLimitation=increasedENDlimitation(powerReducedEND);
 				var powerLimitations = (parseFloat(values["powerLimitations"+ID])||0)+increasedENDLimitation;
 			
-				let powerActiveCost=0;
-				let powerModifiedCost=0;
-				let powerRealCost=0;
-				let powerEND=0;
-				
-				powerPreReducedEndActiveCost=powerBaseCost * (1+powerAdvantages);
-				powerEND=calculatePowerEND(powerPreReducedEndActiveCost, powerReducedEND);
-				powerActiveCost=calculateActiveCost(powerBaseCost, powerAdvantages, powerReducedEND);
-				powerActiveCost=heroRoundLow(powerActiveCost);
-				thePowerDice=thePowerDice.replace(/[^\ddD\\+\\-]/g,"");
-				
-				if (powerBaseCost != 0) {
-					switch (powerType) {
-						case 'variableSlot': 	powerRealCost=powerActiveCost/(1+powerLimitations)/5;
-										powerRealCost=heroRoundLow(powerRealCost);
-										if (powerRealCost<1) {
-											powerRealCost=1;
-										};
-										break;
-						case 'fixedSlot': 	powerRealCost=powerActiveCost/(1+powerLimitations)/10;
-										powerRealCost=heroRoundLow(powerRealCost);
-										if (powerRealCost<1) {
-											powerRealCost=1;
-										};
-										break;
-						default: powerRealCost=powerActiveCost/(1+powerLimitations);
-										powerRealCost=heroRoundLow(powerRealCost);
-										if (powerRealCost<1) {
-											powerRealCost=1;
-										};
-					}
-				} else {
-					powerActiveCost=0;
-					powerEND=0;
+			let powerActiveCost=0;
+			let powerModifiedCost=0;
+			let powerRealCost=0;
+			let powerEND=0;
+			
+			powerPreReducedEndActiveCost=powerBaseCost * (1+powerAdvantages);
+			powerEND=calculatePowerEND(powerPreReducedEndActiveCost, powerReducedEND);
+			powerActiveCost=calculateActiveCost(powerBaseCost, powerAdvantages, powerReducedEND);
+			powerActiveCost=heroRoundLow(powerActiveCost);
+			thePowerDice=thePowerDice.replace(/[^\ddD\\+\\-]/g,"");
+			
+			if (powerBaseCost != 0) {
+				switch (powerType) {
+					case 'variableSlot': 	powerRealCost=powerActiveCost/(1+powerLimitations)/5;
+									powerRealCost=heroRoundLow(powerRealCost);
+									if (powerRealCost<1) {
+										powerRealCost=1;
+									};
+									break;
+					case 'fixedSlot': 	powerRealCost=powerActiveCost/(1+powerLimitations)/10;
+									powerRealCost=heroRoundLow(powerRealCost);
+									if (powerRealCost<1) {
+										powerRealCost=1;
+									};
+									break;
+					default: powerRealCost=powerActiveCost/(1+powerLimitations);
+									powerRealCost=heroRoundLow(powerRealCost);
+									if (powerRealCost<1) {
+										powerRealCost=1;
+									};
 				}
+			} else {
+				powerActiveCost=0;
+				powerEND=0;
+			}
 			
 				var attributes = new Object();
 				attributes["powerActiveCost"+ID] = powerActiveCost;
@@ -7102,7 +7050,7 @@
 			});
 		});
 	});
-
+	
 	/* Use Power XX Endurance */
 	arrayOf(maxPowerNum).forEach(num => {
 		var powerId = String(num).padStart(2,'0');
@@ -7111,8 +7059,8 @@
 				subtractEndurance(parseInt(values["powerEND"+powerId]));
 			});
 		});
-	});	
-	
+	});
+			
 	/* Activate Power XX */
 	arrayOf(maxPowerNum).forEach(num => {
 		var powerId = String(num).padStart(2,'0');
@@ -7128,20 +7076,20 @@
 				// Roll activation and effect dice. If the option to auto apply endurance is TRUE, subtract the power's END once from endurance.
 				getAttrs(["optionAutoSubtractEND", "powerEND"+powerId], function(values) {
 					let powerEND = parseInt(values["powerEND"+powerId])||0;
-					
+
 					if (values.optionAutoSubtractEND != 0)
 						subtractEndurance(powerEND);
 				});
-				
+
 				finishRoll(results.rollId, {});
 			});
+			});
 		});
-	});
 	
 	// Update Tally Bar after change to any Power's CP cost.
 	on("change:powerCP01 change:powerCP02 change:powerCP03 change:powerCP04 change:powerCP05 change:powerCP06 change:powerCP07 change:powerCP08 change:powerCP09 change:powerCP10 change:powerCP11 change:powerCP12 change:powerCP13 change:powerCP14 change:powerCP15 change:powerCP16 change:powerCP17", function () {
 		sumPowersPerksTalents();
-	});
+	});	
 	
 	/* -------------- */
 	/* Power Movers   */
@@ -7188,20 +7136,20 @@
 	/* -------------------------------------------------- */
 	/* Functions used for skills tab                      */
 	/* -------------------------------------------------- */
-	
+			
 	function calculateLanguageSkillCost(skillFluency, skillLiteracy, enhancerLinguist, literacyCost) {
 		var enhancerBonus=0;
 		var languageCP=0;
 		let literacyCP=0;
-		
+				
 		if (skillLiteracy!=0) {
 			literacyCP=literacyCost;
 		}
-		
+			
 		if (enhancerLinguist!=0) {
 			enhancerBonus=1;
-		}
-			
+				}
+	
 		switch (skillFluency) {
 			case "native": languageCP = literacyCP;
 			break;
@@ -7216,23 +7164,23 @@
 			break;
 			
 			case "accent": languageCP = 3+literacyCP-enhancerBonus;
-			break;
+									break;
 			
 			case "idiomatic": languageCP = 4+literacyCP-enhancerBonus;
 			break;
 			
 			case "imitate": languageCP = 5+literacyCP-enhancerBonus;
-			break;
-		}
+									break;
+				}
 		return languageCP;
-	}
-	
+			}
+			
 	function standardSkillChance(theBaseSkillRoll,skillCP,additionalLevels) {
 		var skillCost=3;
 		var skillLevelCost=2;
 		var theSkillRollChance;
 		var theSkillBonus;
-		
+	
 		if (skillCP==0) {
 			theSkillRollChance=0;
 		} else if (skillCP==1) {
@@ -7245,7 +7193,7 @@
 		} 
 		return theSkillRollChance;
 	}
-	
+			
 	function knowledgeSkillChance(enhancer,skillCP,additionalLevels) {
 		// Calculate KS, PS, or AK-type skill roll chance.
 		var skillCost=2;
@@ -7253,7 +7201,7 @@
 		var theBaseSkillRoll=11;
 		var theSkillBonus=0;
 		var theSkillRollChance=0;
-		
+			
 		if (skillCP==0) {
 			theSkillRollChance = 0;
 		} else if (skillCP==1 && enhancer == 0) {
@@ -7267,8 +7215,8 @@
 			theSkillRollChance = theBaseSkillRoll+theSkillBonus+additionalLevels;
 		}
 		return theSkillRollChance;
-	}
-	
+			}
+			
 	function knowledgeIntSkillChance(theBaseSkillRoll, enhancer, skillCP, additionalLevels) {
 		// Knowledge, Professional, and Science Skills can be purchased as Intelligence-based skills. In such a case 
 		// this function replaces the more general knowledgeSkillChance(...) function.
@@ -7276,7 +7224,7 @@
 		var skillLevelCost=1;
 		var theSkillBonus=0;
 		var theSkillRollChance=0;
-		
+			
 		if (skillCP==0) {
 			theSkillRollChance = 0;
 		} else if (skillCP==1 && enhancer == 0) {
@@ -7297,18 +7245,18 @@
 		}
 		return theSkillRollChance;
 	}
-	
+				
 	function calculateSkillChance(skillType,skillCP,enhancerJack,enhancerSch,enhancerSci,enhancerTrav,strengthChance,dexterityChance,constitutionChance,intelligenceChance,egoChance,presenceChance,interactionSkillLevels,intellectSkillLevels,agilitySkillLevels,bonusLevels) {
 		// Calculates the skill roll chance for a general skill.
 		//
 		// A bit crazy, but all of these variables need to be passed to this function for the the switch function contained below
 		// to calculate the skill roll chance for the skill passed to the function.
-		
+			
 		switch (skillType) {
 			case "str":
 			theSkillRollChance=standardSkillChance( strengthChance,skillCP,bonusLevels);
 			break;
-			
+	
 			case "dex":
 			theSkillRollChance=standardSkillChance( dexterityChance,skillCP,agilitySkillLevels+bonusLevels);
 			break;
@@ -7327,11 +7275,11 @@
 			
 			case "pre":
 			theSkillRollChance=standardSkillChance( presenceChance,skillCP,interactionSkillLevels+bonusLevels);
-			break;
+									break;
 			
 			case "ps":
 			theSkillRollChance=knowledgeSkillChance( enhancerJack,skillCP,bonusLevels);
-			break;
+									break;
 			
 			case "intPS":
 			theSkillRollChance=knowledgeIntSkillChance( intelligenceChance, enhancerJack,skillCP,bonusLevels);
@@ -7340,7 +7288,7 @@
 			case "dexPS":
 			theSkillRollChance=knowledgeIntSkillChance( dexterityChance, enhancerJack,skillCP,bonusLevels);
 			break;
-			
+	
 			case "ks":
 			theSkillRollChance=knowledgeSkillChance( enhancerSch,skillCP,bonusLevels);
 			break;
@@ -7356,7 +7304,7 @@
 			case "intSS":
 			theSkillRollChance=knowledgeIntSkillChance( intelligenceChance, enhancerSci, skillCP,bonusLevels);
 			break;
-			
+	
 			case "ak":
 			theSkillRollChance=knowledgeSkillChance( enhancerTrav,skillCP,bonusLevels);;
 			break;
@@ -7364,18 +7312,18 @@
 			case "other":
 			theSkillRollChance=0;
 			break;
-			
+				
 			case "none":
 			theSkillRollChance=0;
 			break;
 			
 			case "group":
 			theSkillRollChance=0;
-			break;
-			
+						break;
+						
 			default:
 			theSkillRollChance=0;
-		} 
+		}
 		
 		return theSkillRollChance;
 	}
@@ -7402,13 +7350,13 @@
 			});
 		});
 	});
-	
+
 	/* ------------------- */
 	/* Skill Updaters      */
 	/* ------------------- */
-	
+					
 	/* Skill set 01-10 */
-	
+											 
 	on("change:skillType01 change:skillCP01 change:skillType02 change:skillCP02 change:skillType03 change:skillCP03 change:skillType04 change:skillCP04 change:skillType05 change:skillCP05 change:skillType06 change:skillCP06 change:skillType07 change:skillCP07 change:skillType08 change:skillCP08 change:skillType09 change:skillCP09 change:skillType10 change:skillCP10 change:enhancerJack change:enhancerSch change:enhancerSci change:enhancerTrav change:strengthChance change:dexterityChance change:constitutionChance change:intelligenceChance change:egoChance change:presenceChance change:interactionLevels change:intellectLevels change:agilityLevels change:noncombatLevels change:overallLevels", function() {
 		//
 		// The sandbox makes calculating the skill roll chance of general skills messy. All of these modifiers need to be accessed and checked for changes.
@@ -7416,61 +7364,61 @@
 		// the three lines below the desired group level.
 		//
 		getAttrs(["skillType01","skillCP01","skillType02","skillCP02","skillType03","skillCP03","skillType04","skillCP04","skillType05","skillCP05","skillType06","skillCP06","skillType07","skillCP07","skillType08","skillCP08","skillType09","skillCP09","skillType10","skillCP10","enhancerJack","enhancerSch","enhancerSci","enhancerTrav","strengthChance","dexterityChance","constitutionChance","intelligenceChance","egoChance","presenceChance","interactionLevels","intellectLevels","agilityLevels","noncombatLevels","overallLevels"], function(values) {
-			
+					
 			// Skill 01
 			let bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
 			let skillRollChance01=calculateSkillChance(values.skillType01, (parseInt(values.skillCP01)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+							
 			// Skill 02
 			// Bonus Levels for Skills 02, 03, and 04 may include group levels if Skill 01 is of type "group".
 			if (values.skillType01==="group") {
 				bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0)+Math.floor((parseInt(values.skillCP01))/3);
 			} else {
 				bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
-			} 
-			 
+						}
+						
 			let skillRollChance02=calculateSkillChance(values.skillType02, (parseInt(values.skillCP02)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+						
 			// Skill 03 
 			let skillRollChance03=calculateSkillChance(values.skillType03, (parseInt(values.skillCP03)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+					
 			// Skill 04 
 			let skillRollChance04=calculateSkillChance(values.skillType04, (parseInt(values.skillCP04)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+					
 			// Skill 05
 			bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
 			let skillRollChance05=calculateSkillChance(values.skillType05, (parseInt(values.skillCP05)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+					
 			// Skill 06
 			// Bonus Levels for Skills 06, 07, and 08 may include group levels if Skill 05 is of type "group".
 			if (values.skillType05=="group") {
 				bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0)+Math.floor((parseInt(values.skillCP05))/3);
 			} else {
 				bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
-			} 
-			 
+					}
+							
 			let skillRollChance06=calculateSkillChance(values.skillType06, (parseInt(values.skillCP06)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+						
 			// Skill 07 
 			let skillRollChance07=calculateSkillChance(values.skillType07, (parseInt(values.skillCP07)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+											 
 			// Skill 08 
 			let skillRollChance08=calculateSkillChance(values.skillType08, (parseInt(values.skillCP08)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
-			
+							
+						
 			// Skill 09
 			// Skills 09 and 10 aren't available for group levels.
 			bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
 			let skillRollChance09=calculateSkillChance(values.skillType09, (parseInt(values.skillCP09)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+						
 			// Skill 10
 			let skillRollChance10=calculateSkillChance(values.skillType10, (parseInt(values.skillCP10)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+						
 			// Skill Set 1 total character point cost
 			let setSkillsCost=(parseInt(values.skillCP01)||0)+(parseInt(values.skillCP02)||0)+(parseInt(values.skillCP03)||0)+(parseInt(values.skillCP04)||0)+(parseInt(values.skillCP05)||0)+(parseInt(values.skillCP06)||0)+(parseInt(values.skillCP07)||0)+(parseInt(values.skillCP08)||0)+(parseInt(values.skillCP09)||0)+(parseInt(values.skillCP10)||0);
-			
+						
 			// Assign calculated skill rolls.
-			setAttrs({
+						setAttrs({
 				"skillRollChance01":skillRollChance01,
 				"skillRollChance02":skillRollChance02,
 				"skillRollChance03":skillRollChance03,
@@ -7482,75 +7430,75 @@
 				"skillRollChance09":skillRollChance09,
 				"skillRollChance10":skillRollChance10,
 				"hiddenSet1SkillsCost":setSkillsCost
-			}); 		
+				});
 		});
 	});
 	
 	/* Skill set 11-20 */
-
+					
 	on("change:skillType11 change:skillCP11 change:skillType12 change:skillCP12 change:skillType13 change:skillCP13 change:skillType14 change:skillCP14 change:skillType15 change:skillCP15 change:skillType16 change:skillCP16 change:skillType17 change:skillCP17 change:skillType18 change:skillCP18 change:skillType19 change:skillCP19 change:skillType20 change:skillCP20 change:enhancerJack change:enhancerSch change:enhancerSci change:enhancerTrav change:strengthChance change:dexterityChance change:constitutionChance change:intelligenceChance change:egoChance change:presenceChance change:interactionLevels change:intellectLevels change:agilityLevels change:noncombatLevels change:overallLevels", function() {
 		//
 		// The sandbox makes calculating the skill roll chance of general skills messy. All of these modifiers need to be accessed and checked for changes.
 		// Group levels are handled by slotting into skills 11 and 15. A player will need to organize the three skills that the group levels apply into
 		// the three lines below the desired group level.
 		//
-		
+					
 		getAttrs(["skillType11","skillCP11","skillType12","skillCP12","skillType13","skillCP13","skillType14","skillCP14","skillType15","skillCP15","skillType16","skillCP16","skillType17","skillCP17","skillType18","skillCP18","skillType19","skillCP19","skillType20","skillCP20","enhancerJack","enhancerSch","enhancerSci","enhancerTrav","strengthChance","dexterityChance","constitutionChance","intelligenceChance","egoChance","presenceChance","interactionLevels","intellectLevels","agilityLevels","noncombatLevels","overallLevels"], function(values) {
-			
+					
 			// Skill 11
 			let bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
 			let skillRollChance11=calculateSkillChance(values.skillType11, (parseInt(values.skillCP11)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+					
 			// Skill 12
 			// Bonus Levels for Skills 12, 13, and 14 may include group levels if Skill 11 is of type "group".
 			if (values.skillType11==="group") {
 				bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0)+Math.floor((parseInt(values.skillCP11))/3);
-			} else {
+								  } else {
 				bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
-			} 
-			 
+					}
+					
 			let skillRollChance12=calculateSkillChance(values.skillType12, (parseInt(values.skillCP12)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+							
 			// Skill 13 
 			let skillRollChance13=calculateSkillChance(values.skillType13, (parseInt(values.skillCP13)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+						
 			// Skill 14 
 			let skillRollChance14=calculateSkillChance(values.skillType14, (parseInt(values.skillCP14)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+						
 			// Skill 15
 			bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
 			let skillRollChance15=calculateSkillChance(values.skillType15, (parseInt(values.skillCP15)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+						
 			// Skill 16
 			// Bonus Levels for Skills 16, 17, and 18 may include group levels if Skill 15 is of type "group".
 			if (values.skillType15==="group") {
 				bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0)+Math.floor((parseInt(values.skillCP15))/3);
 			} else {
 				bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
-			} 
-			 
+					}
+							
 			let skillRollChance16=calculateSkillChance(values.skillType16, (parseInt(values.skillCP16)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+						
 			// Skill 17 
 			let skillRollChance17=calculateSkillChance(values.skillType17, (parseInt(values.skillCP17)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+											 
 			// Skill 18 
 			let skillRollChance18=calculateSkillChance(values.skillType18, (parseInt(values.skillCP18)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
-			
+							
+						
 			// Skill 19
 			// Skills 19 and 20 aren't available for group levels.
 			bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
 			let skillRollChance19=calculateSkillChance(values.skillType19, (parseInt(values.skillCP19)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+						
 			// Skill 20
 			let skillRollChance20=calculateSkillChance(values.skillType20, (parseInt(values.skillCP20)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+						
 			// Skill Set 2 total character point cost
 			let setSkillsCost=(parseInt(values.skillCP11)||0)+(parseInt(values.skillCP12)||0)+(parseInt(values.skillCP13)||0)+(parseInt(values.skillCP14)||0)+(parseInt(values.skillCP15)||0)+(parseInt(values.skillCP16)||0)+(parseInt(values.skillCP17)||0)+(parseInt(values.skillCP18)||0)+(parseInt(values.skillCP19)||0)+(parseInt(values.skillCP20)||0); 
-			
+						
 			// Assign calculated skill rolls.
-			setAttrs({
+						setAttrs({
 				"skillRollChance11":skillRollChance11,
 				"skillRollChance12":skillRollChance12,
 				"skillRollChance13":skillRollChance13,
@@ -7562,32 +7510,32 @@
 				"skillRollChance19":skillRollChance19,
 				"skillRollChance20":skillRollChance20,
 				"hiddenSet2SkillsCost":setSkillsCost 
-			}); 
+				});
 		});
-	}); 
+	});
 	
 	/* Skill set 21-30 */
-
+					
 	on("change:skillType21 change:skillCP21 change:skillType22 change:skillCP22 change:skillType23 change:skillCP23 change:skillType24 change:skillCP24 change:skillType25 change:skillCP25 change:skillType26 change:skillCP26 change:skillType27 change:skillCP27 change:skillType28 change:skillCP28 change:skillType29 change:skillCP29 change:skillType30 change:skillCP30 change:enhancerJack change:enhancerSch change:enhancerSci change:enhancerTrav change:strengthChance change:dexterityChance change:constitutionChance change:intelligenceChance change:egoChance change:presenceChance change:interactionLevels change:intellectLevels change:agilityLevels change:noncombatLevels change:overallLevels", function() {
 		//
 		// The sandbox makes calculating the skill roll chance of general skills messy. All of these modifiers need to be accessed and checked for changes.
 		// Group levels are handled by slotting into skills 21 and 25. A player will need to organize the three skills that the group levels apply into
 		// the three lines below the desired group level.
 		//
-		
+					
 		getAttrs(["skillType21","skillCP21","skillType22","skillCP22","skillType23","skillCP23","skillType24","skillCP24","skillType25","skillCP25","skillType26","skillCP26","skillType27","skillCP27","skillType28","skillCP28","skillType29","skillCP29","skillType30","skillCP30","enhancerJack","enhancerSch","enhancerSci","enhancerTrav","strengthChance","dexterityChance","constitutionChance","intelligenceChance","egoChance","presenceChance","interactionLevels","intellectLevels","agilityLevels","noncombatLevels","overallLevels"], function(values) {
-			
+					
 			// Skill 21
 			let bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
 			let skillRollChance21=calculateSkillChance(values.skillType21, (parseInt(values.skillCP21)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+					
 			// Skill 22
 			// Bonus Levels for Skills 22, 23, and 24 may include group levels if Skill 21 is of type "group".
 			if (values.skillType21==="group") {
 				bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0)+Math.floor((parseInt(values.skillCP21))/3);
-			} else {
+								  } else {
 				bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
-			} 
+							}
 			 
 			let skillRollChance22=calculateSkillChance(values.skillType22, (parseInt(values.skillCP22)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
 			
@@ -7605,32 +7553,32 @@
 			// Bonus Levels for Skills 26, 27, and 28 may include group levels if Skill 25 is of type "group".
 			if (values.skillType25==="group") {
 				bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0)+Math.floor((parseInt(values.skillCP25))/3);
-			} else {
+								  } else {
 				bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
-			} 
-			 
+					}
+					
 			let skillRollChance26=calculateSkillChance(values.skillType26, (parseInt(values.skillCP26)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+					
 			// Skill 27 
 			let skillRollChance27=calculateSkillChance(values.skillType27, (parseInt(values.skillCP27)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+							
 			// Skill 28 
 			let skillRollChance28=calculateSkillChance(values.skillType28, (parseInt(values.skillCP28)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
-			
+						
+						
 			// Skill 29
 			// Skills 29 and 30 aren't available for group levels.
 			bonusLevels=(parseInt(values.noncombatLevels)||0)+(parseInt(values.overallLevels)||0);
 			let skillRollChance29=calculateSkillChance(values.skillType29, (parseInt(values.skillCP29)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+						
 			// Skill 30
 			let skillRollChance30=calculateSkillChance(values.skillType30, (parseInt(values.skillCP30)||0), values.enhancerJack, values.enhancerSch, values.enhancerSci, values.enhancerTrav, (parseInt(values.strengthChance)||0), (parseInt(values.dexterityChance)||0), (parseInt(values.constitutionChance)||0), (parseInt(values.intelligenceChance)||0), (parseInt(values.egoChance)||0), (parseInt(values.presenceChance)||0), (parseInt(values.interactionLevels)||0), (parseInt(values.intellectLevels)||0), (parseInt(values.agilityLevels)||0), bonusLevels);
-			
+					
 			// Skill Set 3 total character point cost
 			let setSkillsCost=(parseInt(values.skillCP21)||0)+(parseInt(values.skillCP22)||0)+(parseInt(values.skillCP23)||0)+(parseInt(values.skillCP24)||0)+(parseInt(values.skillCP25)||0)+(parseInt(values.skillCP26)||0)+(parseInt(values.skillCP27)||0)+(parseInt(values.skillCP28)||0)+(parseInt(values.skillCP29)||0)+(parseInt(values.skillCP30)||0); 
-			
+					
 			// Assign calculated skill rolls.
-			setAttrs({
+					setAttrs({
 				"skillRollChance21":skillRollChance21,
 				"skillRollChance22":skillRollChance22,
 				"skillRollChance23":skillRollChance23,
@@ -7644,8 +7592,8 @@
 				"hiddenSet3SkillsCost":setSkillsCost 
 			}); 
 		});
-	}); 
-	
+					});
+					
 	/* Combat Skills */
 	on("change:skillLevels31 change:skillType31 change:skillLevels32 change:skillType32 change:skillLevels33 change:skillType33 change:skillLevels34 change:skillType34 change:skillLevels35 change:skillType35 change:skillLevels36 change:skillType36 change:skillLevels37 change:skillType37 change:skillLevels38 change:skillLevels39 change:skillLevels40", function () {
 		//
@@ -7657,7 +7605,7 @@
 		// Skill level costs for all HTH, all ranged, and all combat are calculated here without the calculateCombatSkillCost(..).
 		//
 		getAttrs(["skillLevels31", "skillType31", "skillLevels32", "skillType32", "skillLevels33", "skillType33", "skillLevels34", "skillType34", "skillLevels35", "skillType35", "skillLevels36", "skillType36", "skillLevels37", "skillType37", "skillLevels38","skillLevels39","skillLevels40"], function(values) {
-			
+											 
 			// Skills 31-37 are general combat skills with costs determined by their skill type or levels.
 			let skill31Cost = calculateCombatSkillCost(values.skillType31, (parseInt(values.skillLevels31)||0) );
 			let skill32Cost = calculateCombatSkillCost(values.skillType32, (parseInt(values.skillLevels32)||0) );
@@ -7666,19 +7614,19 @@
 			let skill35Cost = calculateCombatSkillCost(values.skillType35, (parseInt(values.skillLevels35)||0) );
 			let skill36Cost = calculateCombatSkillCost(values.skillType36, (parseInt(values.skillLevels36)||0) );
 			let skill37Cost = calculateCombatSkillCost(values.skillType37, (parseInt(values.skillLevels37)||0) );
-			
+							
 			// Skill 38: All HTH Combat Levels cost 8 CP each.
 			let skill38Cost = 8*(parseInt(values.skillLevels38)||0);
-			
+						
 			// Skill 39: All Range Combat Levels cost 8 CP each.
 			let skill39Cost = 8*(parseInt(values.skillLevels39)||0);
-			
+						
 			// Skill 40: All Combat Levels cost 10 CP each.
 			let skill40Cost = 10*(parseInt(values.skillLevels40)||0);
-			
+						
 			let combatSkillsCost = skill31Cost+skill32Cost+skill33Cost+skill34Cost+skill35Cost+skill36Cost+skill37Cost+skill38Cost+skill39Cost+skill40Cost;
-			
-			setAttrs({
+						
+						setAttrs({
 				"hiddenCombatSkillsCost":combatSkillsCost,
 				"skillCP31":skill31Cost,
 				"skillCP32":skill32Cost,
@@ -7690,7 +7638,7 @@
 				"skillCP38":skill38Cost,
 				"skillCP39":skill39Cost,
 				"skillCP40":skill40Cost
-			});	
+				});
 		});
 	});
 	
@@ -7698,70 +7646,70 @@
 		// Used to calculate costs of general combat skill and familiarities.
 		let skillBaseCost=0;
 		let skillLevelCost=0;
-	
+					
 		switch (skillType) {
 			case "none": skillLevelCost=0;
 			skillBaseCost = 0;
 			break;
-			
+					
 			case "Fam1": skillLevelCost=0;
 			skillBaseCost = 1;
 			break;
-			
+					
 			case "Fam2": skillLevelCost=0;
 			skillBaseCost = 2;
 			break;
-			
+					
 			case "CSL2": skillLevelCost=2;
 			skillBaseCost = 0;
 			break;
-			
+					
 			case "CSL3": skillLevelCost=3;
 			skillBaseCost = 0;
 			break;
-			
+											 
 			case "CSL5": skillLevelCost=5;
 			skillBaseCost = 0;
 			break;
-			
+					
 			case "CSL8": skillLevelCost=8;
 			skillBaseCost = 0;
 			break;
-			
+							
 			case "PSL1": skillLevelCost=1;
 			skillBaseCost = 0;
 			break;
-			
+						
 			case "PSL2": skillLevelCost=2;
 			skillBaseCost = 0;
 			break;
-			
+						
 			case "PSL3": skillLevelCost=3;
 			skillBaseCost = 0;
 			break;
-			
+						
 			default: skillLevelCost=0;
 			skillBaseCost = 0;
 			break;
-		}
-		
+							}
+					
 		return skillBaseCost+numberOfLevels*skillLevelCost;
-	}
-	
-	
+					}
+							
+						
 	/* Language Skills */
 	on("change:enhancerLing change:skillFluency41 change:skillLiteracy41 change:skillFluency42 change:skillLiteracy42 change:skillFluency43 change:skillLiteracy43 change:skillFluency44 change:skillLiteracy44 change:skillFluency45 change:skillLiteracy45 change:skillFluency46 change:skillLiteracy46 change:skillFluency47 change:skillLiteracy47 change:skillFluency48 change:skillLiteracy48 change:skillFluency49 change:skillLiteracy49, optionLiteracyCostsPoints", function () {
 		// Language skills are relatively simple without levels or roll calculations. The linguist enhancer is the only complication. 
 		// All calculations handled by the function calculateLanguageSkillCost(...).
-		
+											 
 		getAttrs(["enhancerLing", "skillFluency41","skillLiteracy41", "skillFluency42","skillLiteracy42", "skillFluency43","skillLiteracy43", "skillFluency44","skillLiteracy44", "skillFluency45","skillLiteracy45", "skillFluency46","skillLiteracy46", "skillFluency47","skillLiteracy47", "skillFluency48","skillLiteracy48", "skillFluency49","skillLiteracy49","optionLiteracyCostsPoints"], function(values) {
 			const linguist = values.enhancerLing;
 			let literacyCost = 0;
-			
+							
 			if (values.optionLiteracyCostsPoints!=0) {
 				literacyCost = 1;
-			}
-			
+						}
+						
 			let skill41Cost = calculateLanguageSkillCost( values.skillFluency41 , values.skillLiteracy41, linguist, literacyCost);
 			let skill42Cost = calculateLanguageSkillCost( values.skillFluency42 , values.skillLiteracy42, linguist, literacyCost);
 			let skill43Cost = calculateLanguageSkillCost( values.skillFluency43 , values.skillLiteracy43, linguist, literacyCost);
@@ -7771,10 +7719,10 @@
 			let skill47Cost = calculateLanguageSkillCost( values.skillFluency47 , values.skillLiteracy47, linguist, literacyCost);
 			let skill48Cost = calculateLanguageSkillCost( values.skillFluency48 , values.skillLiteracy48, linguist, literacyCost);
 			let skill49Cost = calculateLanguageSkillCost( values.skillFluency49 , values.skillLiteracy49, linguist, literacyCost);
-			
+						
 			let totalLanguageCosts = skill41Cost+skill42Cost+skill43Cost+skill44Cost+skill45Cost+skill46Cost+skill47Cost+skill48Cost+skill49Cost;
-			
-			setAttrs({
+						
+						setAttrs({
 				"hiddenLanguageSkillsCost":totalLanguageCosts,
 				"skillCP41":skill41Cost,
 				"skillCP42":skill42Cost,
@@ -7785,7 +7733,7 @@
 				"skillCP47":skill47Cost,
 				"skillCP48":skill48Cost,
 				"skillCP49":skill49Cost
-			});
+				});
 		});
 	});
 	
@@ -7794,9 +7742,9 @@
 		// If any of the enhancers or wide-scope noncombat levels change (anything in the lower right skill block) recalculate their costs.
 		// Because enhancers lower the costs of other skills and wide-scope levels change the rolls of other other skills, the
 		// non-combat skills 01-30 will have their costs and roll chances recalculated as well.
-		
+					
 		getAttrs(["enhancerJack","enhancerLing","enhancerSch","enhancerSci","enhancerTrav","enhancerWell","interactionLevels","intellectLevels","agilityLevels","noncombatLevels","overallLevels"], function(values) {
-			
+					
 			// Check for purchased enhancers and assign costs of 3 CP for each.
 			const enhancerJackStatus=values.enhancerJack;
 			const enhancerLingStatus=values.enhancerLing;
@@ -7810,26 +7758,26 @@
 			let enhancerSciCost = 0;
 			let enhancerTravCost = 0;
 			let enhancerWellCost = 0;
-			
+					
 			if (enhancerJackStatus!=0) {
 				enhancerJackCost = 3;
-			}
+								  }
 			if (enhancerLingStatus!=0) {
 				enhancerLingCost = 3;
-			}
+							}
 			if (enhancerSchStatus!=0) {
 				enhancerSchCost = 3;
-			}
+								  }
 			if (enhancerSciStatus!=0) {
 				enhancerSciCost = 3;
-			}
+							}
 			if (enhancerTravStatus!=0) {
 				enhancerTravCost = 3;
-			}
+						}
 			if (enhancerWellStatus!=0) {
 				enhancerWellCost = 3;
-			}
-			
+					}
+					
 			setAttrs({
 				"enhancerJackCP":enhancerJackCost,
 				"enhancerLingCP":enhancerLingCost,
@@ -7838,54 +7786,54 @@
 				"enhancerWellCP":enhancerWellCost,
 				"enhancerTravCP":enhancerTravCost
 			});
-			
+					
 			// Calculate costs for each wide-scope non-combat level.
 			const interactionSkillLevels=parseInt(values.interactionLevels)||0;
 			const intellectSkillLevels=parseInt(values.intellectLevels)||0;
 			const agilitySkillLevels=parseInt(values.agilityLevels)||0;
 			const noncombatSkillLevels=parseInt(values.noncombatLevels)||0;
 			const overallSkillLevels=parseInt(values.overallLevels)||0;
-			
+							
 			let interactionSkillLevelsCost= interactionSkillLevels*4;
 			let intellectSkillLevelsCost= intellectSkillLevels*4;
 			let agilitySkillLevelsCost= agilitySkillLevels*6;
 			let noncombatSkillLevelsCost= noncombatSkillLevels*10;
 			let overallSkillLevelsCost= overallSkillLevels*12;
-			
-			setAttrs({
+						
+						setAttrs({
 				"interactionLevelsCP":interactionSkillLevelsCost,
 				"intellectLevelsCP":intellectSkillLevelsCost,
 				"agilityLevelsCP":agilitySkillLevelsCost,
 				"noncombatLevelsCP":noncombatSkillLevelsCost,
 				"overallLevelsCP":overallSkillLevelsCost
-			});
-			
+						});
+						
 			skillEnhancersCost = enhancerJackCost+enhancerLingCost+enhancerSchCost+enhancerSciCost+enhancerTravCost+enhancerWellCost;
 			skillLevelsCost=interactionSkillLevelsCost+intellectSkillLevelsCost+agilitySkillLevelsCost+noncombatSkillLevelsCost+overallSkillLevelsCost;
-			
+						
 			setAttrs({
 				"hiddenEnhancerSkillsCost":skillEnhancersCost+skillLevelsCost,
 			});
 			
 			//addSkillPoints();
-		});
-	});
-	
+					});
+				});
+					
 	/* Martial Skills, which are entered in the Gear Section */
 	on("change:martialManeuverCP01 change:martialManeuverCP02 change:martialManeuverCP03 change:martialManeuverCP04 change:martialManeuverCP05 change:martialManeuverCP06", function () {
 		// Martial maneuver skills are not dependent on other attributes or skills.
-		
+					
 		getAttrs(["martialManeuverCP01", "martialManeuverCP02","martialManeuverCP03", "martialManeuverCP04","martialManeuverCP05", "martialManeuverCP06"], function(values) {
-		
+					
 			let martialManeuver01Cost = parseInt(values.martialManeuverCP01)||0;
 			let martialManeuver02Cost = parseInt(values.martialManeuverCP02)||0;
 			let martialManeuver03Cost = parseInt(values.martialManeuverCP03)||0;
 			let martialManeuver04Cost = parseInt(values.martialManeuverCP04)||0;
 			let martialManeuver05Cost = parseInt(values.martialManeuverCP05)||0;
 			let martialManeuver06Cost = parseInt(values.martialManeuverCP06)||0;
-			
+					
 			let totalMartialManeuversCost = martialManeuver01Cost+martialManeuver02Cost+martialManeuver03Cost+martialManeuver04Cost+martialManeuver05Cost+martialManeuver06Cost;
-			
+							
 			setAttrs({
 				"hiddenMartialSkillsCost":totalMartialManeuversCost
 			});
@@ -7895,49 +7843,49 @@
 	/* -------------------------------------------------- */
 	/* Functions used for gear tab                        */
 	/* -------------------------------------------------- */
-	
+						
 	/* Calculate weapon endurance costs */
 	on("change:optionSuperHeroicEndurance change:weaponStrength01 change:weaponStrength02 change:weaponStrength03 change:weaponStrength04 change:weaponStrength05 change:shieldStrength", function() {
 		getAttrs(["optionSuperHeroicEndurance", "weaponStrength01","weaponStrength02","weaponStrength03","weaponStrength04","weaponStrength05","shieldStrength"], function(values) {
 			// If optionSuperHeroicEndurance is true, endurance cost is 1 per 5 strength, otherwise it is 1 per 10 strength used.
-			
+											 
 			optionSuperHeroic = values.optionSuperHeroicEndurance;
 			let enduranceCostFactor = 10;
-			
+							
 			if (optionSuperHeroic != 0) {
 				enduranceCostFactor=5;
-			}
+							}
 
 			let enduranceCost01= heroRoundLow( (parseInt(values.weaponStrength01)||0)/enduranceCostFactor );
 			if ( (enduranceCost01<1) && (parseInt(values.weaponStrength01)||0)>0) {
 				enduranceCost01=1
-			}
-			
+						}
+						
 			let enduranceCost02= heroRoundLow( (parseInt(values.weaponStrength02)||0)/enduranceCostFactor );
 			if ( (enduranceCost02<1) && (parseInt(values.weaponStrength02)||0)>0) {
 				enduranceCost02=1
 			}
-			
+						
 			let enduranceCost03= heroRoundLow( (parseInt(values.weaponStrength03)||0)/enduranceCostFactor );
 			if ( (enduranceCost03<1) && (parseInt(values.weaponStrength03)||0)>0) {
 				enduranceCost03=1
 			}
-			
+						
 			let enduranceCost04= heroRoundLow( (parseInt(values.weaponStrength04)||0)/enduranceCostFactor );
 			if ( (enduranceCost04<1) && (parseInt(values.weaponStrength04)||0)>0) {
 				enduranceCost04=1
-			}
-			
+						}
+						
 			let enduranceCost05= heroRoundLow( (parseInt(values.weaponStrength05)||0)/enduranceCostFactor );
 			if ( (enduranceCost05<1) && (parseInt(values.weaponStrength05)||0)>0) {
 				enduranceCost05=1
 			}
-			
+						
 			let enduranceCostShield= heroRoundLow( (parseInt(values.shieldStrength)||0)/enduranceCostFactor );
 			if ( (enduranceCostShield<1) && (parseInt(values.shieldStrength)||0)>0) {
 				enduranceCostShield=1
 			}
-			
+						
 			setAttrs({
 				"weaponEndurance01":enduranceCost01,
 				"weaponEndurance02":enduranceCost02,
@@ -7945,35 +7893,35 @@
 				"weaponEndurance04":enduranceCost04,
 				"weaponEndurance05":enduranceCost05,
 				"shieldEndurance":enduranceCostShield
-			});
-		}); 
-	}); 
+				});
+		});
+	});
 	
 	/* Gear Tab sum up equipment weight */
 	on("change:liftWeight change:armorEND01 change:armorEND02 change:armorEND03 change:armorEND04 change:armorMass01 change:armorMass01 change:armorMass02 change:armorMass03 change:armorMass04 change:shieldMass change:weaponMass01 change:weaponMass02 change:weaponMass03 change:weaponMass04 change:weaponMass05 change:equipMass01 change:equipMass02 change:equipMass03 change:equipMass04 change:equipMass05 change:equipMass06 change:equipMass07 change:equipMass08 change:equipMass09 change:equipMass10 change:equipMass11 change:equipMass12 change:equipMass13 change:equipMass14 change:equipMass15 change:equipMass16", function () {
 		// Add the masses of all items of equipment.
 		// Determine END used per turn, DCV/DEX roll penalty, and Movement Penalty.
-		
+					
 		getAttrs(["liftWeight","armorEND01","armorEND02","armorEND03","armorEND04","armorMass01","armorMass02","armorMass03","armorMass04","shieldMass", "weaponMass01", "weaponMass02", "weaponMass03", "weaponMass04", "weaponMass05", "equipMass01", "equipMass02", "equipMass03", "equipMass04", "equipMass05", "equipMass06", "equipMass07", "equipMass08", "equipMass09", "equipMass10", "equipMass11", "equipMass12", "equipMass13", "equipMass14", "equipMass15", "equipMass16"], function(values) {
-			
+					
 			// Add up carried mass
 			armorCarried=(parseFloat(values.armorMass01)||0)+(parseFloat(values.armorMass02)||0)+(parseFloat(values.armorMass03)||0)+(parseFloat(values.armorMass04)||0)+(parseFloat(values.shieldMass)||0);
-			
+					
 			weaponsCarried=(parseFloat(values.weaponMass01)||0)+(parseFloat(values.weaponMass02)||0)+(parseFloat(values.weaponMass03)||0)+(parseFloat(values.weaponMass04)||0)+(parseFloat(values.weaponMass05)||0);
-			
+					
 			equipmentCarried=(parseFloat(values.equipMass01)||0)+(parseFloat(values.equipMass02)||0)+(parseFloat(values.equipMass03)||0)+(parseFloat(values.equipMass04)||0)+(parseFloat(values.equipMass05)||0)+(parseFloat(values.equipMass06)||0)+(parseFloat(values.equipMass07)||0)+(parseFloat(values.equipMass08)||0)+(parseFloat(values.equipMass09)||0)+(parseFloat(values.equipMass10)||0)+(parseFloat(values.equipMass11)||0)+(parseFloat(values.equipMass12)||0)+(parseFloat(values.equipMass13)||0)+(parseFloat(values.equipMass14)||0)+(parseFloat(values.equipMass15)||0)+(parseFloat(values.equipMass16)||0);
-			
+					
 			carriedWeight=armorCarried+weaponsCarried+equipmentCarried;
 			carriedWeight=Math.floor(10*carriedWeight)/10;
-			
-			
+											 
+					
 			// Determine penalties
 			const lift=(parseFloat(values.liftWeight)||0);
 			const armorENDcost = (parseInt(values.armorEND01)||0)+(parseInt(values.armorEND02)||0)+(parseInt(values.armorEND03)||0)+(parseInt(values.armorEND04)||0);
 			let enduranceCost=0;
 			let dexPenalty=0;
 			let movePenalty=0;
-			
+							
 			if (carriedWeight<=lift*0.1) {
 				dexPenalty=0;
 				enduranceCost=0+armorENDcost;
@@ -7998,17 +7946,17 @@
 				dexPenalty=-5;
 				enduranceCost=4+armorENDcost;
 				movePenalty=-16;
-			}
-			
-			setAttrs({
+						}
+						
+						setAttrs({
 				"carriedWeight":carriedWeight,
 				"weightEndPenalty":enduranceCost,
 				"weightDexDCVPenalty":dexPenalty,
 				"weightMovePenalty":movePenalty
-			});
-		});
-	});
-	
+						});
+					});
+				});
+					
 	// Open with first tab (thanks to GiGs)
 	on("sheet:opened", function() {
 		setAttrs({sheetTab:"characteristics"});
@@ -8017,7 +7965,7 @@
 	/* ------------------------------------------------ */
 	/* --- Weapon Attacks and Hit Location Helpers  --- */
 	/* ------------------------------------------------ */
-	
+					
 	// Update weaponOCVPenalty01
 	on("change:optionHitLocationSystem change:targetSelection change:weaponAreaEffect01 change:halveTargetOCVpenalty change:penaltySkillLevels", function () {
 		getAttrs(["optionHitLocationSystem","targetSelection","weaponAreaEffect01","halveTargetOCVpenalty","penaltySkillLevels"], function(values) {
@@ -8028,7 +7976,7 @@
 			let targetSelectionType = parseInt(values.targetSelection)||1;
 			let halveTargetPenalty = values.halveTargetOCVpenalty;
 			let penaltySkillLevels = parseInt(values.penaltySkillLevels)||0;
-			
+			  
 			// For some reason I couldn't get this switch function work in an independent function. Will have to suffer with the extra space needed.
 			if ((useHitLocations != 0) && (areaEffectWeapon == 0)) {
 				switch (targetSelectionType) {
@@ -8069,22 +8017,22 @@
 				
 				if (halveTargetPenalty != 0) {
 					penalty = heroRoundHigh(penalty/2);
-				}
-				
+					}
+					
 				// Apply penalty skill levels.
 				penalty = penalty+penaltySkillLevels;
-				
+							
 				// The net penaly cannot be positive.
 				if (penalty>0) {
 					penalty=0;
-				}
-			}
-			
+						}
+						}
+						
 			// Update OCV penalty for weapon01		
-			setAttrs({
+						setAttrs({
 				"weaponOCVPenalty01":penalty
-			});
-		});
+					}); 
+				});
 	});
 	
 	// Update weaponOCVPenalty02
@@ -8097,7 +8045,7 @@
 			let targetSelectionType = parseInt(values.targetSelection)||1;
 			let halveTargetPenalty = values.halveTargetOCVpenalty;
 			let penaltySkillLevels = parseInt(values.penaltySkillLevels)||0;
-			  
+				
 			if ((useHitLocations != 0) && (areaEffectWeapon == 0)) {
 				switch (targetSelectionType) {
 					case 1:		penalty = 0;
@@ -8133,39 +8081,39 @@
 					case 16:	penalty = -4;
 								break;
 					default:	penalty = 0;
-				};
-				
+		};
+					
 				if (halveTargetPenalty != 0) {
 					penalty = heroRoundHigh(penalty/2);
-				}
+	}
 				
 				// Apply penalty skill levels.
 				penalty = penalty+penaltySkillLevels;
-				
+					
 				// The net penaly cannot be positive.
 				if (penalty>0) {
 					penalty=0;
+					}
 				}
-			}
-			
+	
 			// Update OCV penalty for weapon02		
 			setAttrs({
 				"weaponOCVPenalty02":penalty
 			});
 		});
 	});
-	
+						
 	// Update weaponOCVPenalty03
 	on("change:optionHitLocationSystem change:targetSelection change:weaponAreaEffect03 change:halveTargetOCVpenalty change:penaltySkillLevels", function () {
 		getAttrs(["optionHitLocationSystem","targetSelection","weaponAreaEffect03","halveTargetOCVpenalty","penaltySkillLevels"], function(values) {
-		  
+	
 			let penalty = 0;
 			let useHitLocations = values.optionHitLocationSystem;
 			let areaEffectWeapon = values.weaponAreaEffect03;
 			let targetSelectionType = parseInt(values.targetSelection)||1;
 			let halveTargetPenalty = values.halveTargetOCVpenalty;
 			let penaltySkillLevels = parseInt(values.penaltySkillLevels)||0;
-			  
+						
 			if ((useHitLocations != 0) && (areaEffectWeapon == 0)) {
 				switch (targetSelectionType) {
 					case 1:		penalty = 0;
@@ -8202,20 +8150,20 @@
 								break;
 					default:	penalty = 0;
 				};
-				
+	
 				if (halveTargetPenalty != 0) {
 					penalty = heroRoundHigh(penalty/2);
 				}
-				
+						
 				// Apply penalty skill levels.
 				penalty = penalty+penaltySkillLevels;
-				
+	
 				// The net penaly cannot be positive.
 				if (penalty>0) {
 					penalty=0;
 				}
 			}
-			
+						
 			// Update OCV penalty for weapon03		
 			setAttrs({
 				"weaponOCVPenalty03":penalty
@@ -8226,14 +8174,14 @@
 	// Update weaponOCVPenalty04
 	on("change:optionHitLocationSystem change:targetSelection change:weaponAreaEffect04 change:halveTargetOCVpenalty change:penaltySkillLevels", function () {
 		getAttrs(["optionHitLocationSystem","targetSelection","weaponAreaEffect04","halveTargetOCVpenalty","penaltySkillLevels"], function(values) {
-		  
+						
 			let penalty = 0;
 			let useHitLocations = values.optionHitLocationSystem;
 			let areaEffectWeapon = values.weaponAreaEffect04;
 			let targetSelectionType = parseInt(values.targetSelection)||1;
 			let halveTargetPenalty = values.halveTargetOCVpenalty;
 			let penaltySkillLevels = parseInt(values.penaltySkillLevels)||0;
-			  
+	
 			if ((useHitLocations != 0) && (areaEffectWeapon == 0)) {
 				switch (targetSelectionType) {
 					case 1:		penalty = 0;
@@ -9272,14 +9220,14 @@
 						// If the hit location system option is used and the weapon is not of type area effect call the hit location function.
 						if ((useHitLocations != 0) && (areaEffectWeapon == 0)) {					
 							var theHitLocation = new killingHitLocation(targetSelectionType);
-							
+						
 							theSTUNmultiplier = theHitLocation.stunMultiplier;
 							theMessage = theHitLocation.message;
 							}
 						else if (areaEffectWeapon != 0) {
 							theMessage = " AoE";
-						}
-						
+			}
+	
 						
 						// Add the weapon's stun modifier.
 						theSTUNmultiplier = theSTUNmultiplier + theSTUNmodifier;
@@ -9289,7 +9237,7 @@
 							theSTUNmultiplier = 1;
 						}
 						
-						setAttrs({
+			setAttrs({
 							rollDialogMessage:theMessage,
 							hiddenSTUNmultiplier:theSTUNmultiplier
 						});
@@ -9303,7 +9251,7 @@
 							}
 						); 
 					}); 
-				});
+			});
 			}
 		});
 	});
@@ -9316,13 +9264,13 @@
 			let isNormalDamage = values.weaponNormalDamage05;
 			let autoSubtractEND = values.optionAutoSubtractEND;
 			let weaponEND = parseInt(values.weaponEndurance05)||0;
-			
+
 			// If isNormalDamage is TRUE, use the Normal Damage template.
 			if (isNormalDamage != 0) {
 				startRoll("&{template:custom-normal-attack} {{title=@{character_name} - @{character_title}}} {{subtitle=Attacks with @{weaponName05}}} {{OCV=[[?{Modifier|0}+@{weaponOCV05}+@{weaponOCVPenalty05}+@{ocv}]]}} {{Result=[[3d6cf<0cs>0]]}} {{STUN=[[@{hiddenWeaponDamage05}]]}}", (results) => {
-					
+	
 					// Convert dice roll to equivalent BODY damage.
-					
+						
 					let computed =0;
 					const theDice = results.results.STUN.rolls;
 					
@@ -9355,7 +9303,7 @@
 									  computed = computed+1;
 								  }
 							}
-						}
+					}
 					}
 					
 					// Get hit location message if system used.
@@ -9364,8 +9312,8 @@
 						let areaEffectWeapon = values.weaponAreaEffect05;
 						let targetSelectionType = parseInt(values.targetSelection)||1;
 						let theMessage = " ";
-											 
-					
+	
+						
 						if ((useHitLocations != 0) && (areaEffectWeapon == 0)) {
 							var theHitLocation = new normalHitLocation(targetSelectionType);
 							theMessage = theHitLocation.message;
@@ -9373,7 +9321,7 @@
 						} else if (areaEffectWeapon != 0) {
 							theMessage = " AoE";
 						}
-						
+	
 						setAttrs({
 							rollDialogMessage:theMessage
 						});
@@ -9384,20 +9332,20 @@
 							results.rollId,
 							{
 								STUN: theResult.concat(theMessage)
-							}
+					}
 						);
 					});
 				});
 			} else {
 				// If isNormalDamage is FALSE, use the killing Damage template.
 				startRoll("&{template:custom-attack} {{title=@{character_name} - @{character_title}}} {{subtitle= Attacks with @{weaponName05}}} {{OCV=[[?{Modifier|0}+@{weaponOCV05}+@{weaponOCVPenalty05}+@{ocv}]]}} {{Result=[[3d6cf<0cs>0]]}} {{BODY=[[@{hiddenWeaponDamage05}]]}}", (results) => {
-					
+						
 					let computed = parseInt(results.results.BODY.result)||0;
 					
 					setAttrs({
 						hiddenDamageRoll: computed
 					});
-					
+	
 					// Subtract END cost if option checked.
 					if (autoSubtractEND != 0) {
 						subtractEndurance(weaponEND);
@@ -9432,7 +9380,7 @@
 						// Prevent STUN multiples of less than 1.
 						if (theSTUNmultiplier < 1) {
 							theSTUNmultiplier = 1;
-						}
+					}
 						
 						setAttrs({
 							rollDialogMessage:theMessage,
@@ -9447,15 +9395,15 @@
 								BODY: theResult.concat(theMessage)
 							}
 						); 
-					}); 
 				});
+			});
 			}
 		});
 	});
 	
 	on('clicked:attackShield', (info) => {
 		// Roll attack and damage dice for the shield.
-		
+						
 		// First determine if the shield does normal or killing damage.
 		getAttrs(["shieldNormalDamage", "optionAutoSubtractEND", "shieldEndurance"], function(values) {
 			let isNormalDamage = values.shieldNormalDamage;
@@ -9502,38 +9450,38 @@
 							}
 						}
 					}
-					
+
 					// Get hit location message if system used.
 					getAttrs(["optionHitLocationSystem", "targetSelection"], function(values) {
 						let useHitLocations = values.optionHitLocationSystem;
 						let targetSelectionType = parseInt(values.targetSelection)||1;
-						let theMessage = " ";
-											 
-					
+				let theMessage = "";
+	
+						
 						if (useHitLocations != 0) {
 							var theHitLocation = new normalHitLocation(targetSelectionType);
 							theMessage = theHitLocation.message;
-							
-						}
+	
+				}
 						
 						setAttrs({
 							rollDialogMessage:theMessage
 						});
-						
+	
 						let theResult = String(computed);
 						
 						finishRoll(
 							results.rollId,
 							{
 								STUN: theResult.concat(theMessage)
-							}
+					}
 						);
 					});
 				});
 			} else {
 				// If isNormalDamage is FALSE, use the killing Damage template.
 				startRoll("&{template:custom-attack} {{title=@{character_name} - @{character_title}}} {{subtitle= Attacks with @{shieldName}}} {{OCV=[[?{Modifiers|0}-@{shieldDCV}+@{shieldOCV}+@{targetOCVpenalty}+@{ocv}]]}} {{Result=[[3d6cf<0cs>0]]}} {{BODY=[[@{hiddenShieldDamage01}]]}}", (results) => {
-					
+						
 					let computed = parseInt(results.results.BODY.result)||0;
 					
 					setAttrs({
@@ -9562,8 +9510,8 @@
 							
 							theSTUNmultiplier = theHitLocation.stunMultiplier;
 							theMessage = theHitLocation.message;
-						}
-						
+				}
+	
 						
 						// Add the weapon's stun modifier.
 						theSTUNmultiplier = theSTUNmultiplier + theSTUNmodifier;
@@ -9571,7 +9519,7 @@
 						// Prevent STUN multiples of less than 1.
 						if (theSTUNmultiplier < 1) {
 							theSTUNmultiplier = 1;
-						}
+				}
 						
 						setAttrs({
 							rollDialogMessage:theMessage,
@@ -9587,7 +9535,7 @@
 							}
 						); 
 					}); 
-				});
+			});
 			}
 		});
 	});
@@ -9595,7 +9543,7 @@
 	on('clicked:standardAttackRoll', (info) => {
 		startRoll("&{template:custom-normal-attack} {{title=@{character_name} - @{character_title}}} {{subtitle= Attacks with Strength @{strength}}} {{OCV=[[?{Modifiers|0}+@{ocv}+@{targetOCVpenalty}]]}} {{Result=[[3d6cf<0cs>0]]}} {{STUN=[[@{hiddenManeuverDamage01}]]}}", (results) => {
 			// A standard strength-based attack is complicated by the need to use a 1d3 for strength%5 == 3 or 4, such as 4, 8, 13, 19, etc.
-			
+
 			getAttrs(["optionHitLocationSystem", "targetSelection", "strength", "optionAutoSubtractEND", "optionSuperHeroicEndurance"], function(values) {
 				let useHitLocations = values.optionHitLocationSystem;
 				let autoSubtractEND = values.optionAutoSubtractEND;
@@ -9645,31 +9593,31 @@
 						computed = computed+1;
 					}
 				}
-				
+	
 				// Get hit location message if system used.
 				if (useHitLocations != 0) {
 					var theHitLocation = new normalHitLocation(targetSelectionType);
 					theMessage = theHitLocation.message;
 					
 				}
-				
+						
 				setAttrs({
 					rollDialogMessage:theMessage
 				});
 				
 				let theResult = String(computed);
-				
+	
 				finishRoll(
 					results.rollId,
 					{
 						STUN: theResult.concat(theMessage)
-					}
+				}
 				);
 			});
 		});
 	});
 	
-	
+						
 	/* ---------------- */
 	/* Equipment Movers */
 	/* ---------------- */
@@ -9715,7 +9663,7 @@
 	/* ------------------- */
 	/* Complication Movers */
 	/* ------------------- */
-
+						
 	arrayOf(maxComplicationNum).forEach(num => {
 		var lowId = String(num).padStart(2,'0');
 		var highId = String(num == maxComplicationNum ? 1 : num + 1).padStart(2,'0');