From 96f9603e89f9c12a3d7e0f3fc760224feb26c5f9 Mon Sep 17 00:00:00 2001
From: Shane Parker <shane.tim.parker@ea.com>
Date: Sun, 10 Jul 2022 21:03:36 -0400
Subject: [PATCH 1/5] Readme typos

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 92ad5f9..9022850 100644
--- a/README.md
+++ b/README.md
@@ -7,10 +7,10 @@ The following targetable Effects have been added:
 * **[R1]TO[R2]: types** - Damage dealt by the bearer of this effect will treat R1 as R2 for any of the damage types, where R1 and R2 may be one of ABSORB, IGNORE, RESIST, or VULN. e.g. "IMMUNETORESIST: radiant" would cause the damage dealt by a paladin's divine smite to treat radiant immunity as radiant resistance instead.
 * **MAKEVULN: types** - Damage dealt by the bearer of this effect will treat a creature without any sort of resistance to the damage types as if they were vulnerable. e.g. "MAKEVULN: slashing" would cause a wraith to take double damage from magic swords, but still take half damage from nonmagical, unsilvered swords.
 * **REDUCE: n, types** - This functions exactly as RESIST: n, except it will also stack with normal resistance.
-* **UNHEALABLE: (types)** - The bearer of this effect cannot benefit from any healing of the associated types. types is optional and may be any combination of "heal", "hitdice", and "rest", seperated by commas. If types is not provided, then all types of healing are prevented.
+* **UNHEALABLE: (types)** - The bearer of this effect cannot benefit from any healing of the associated types. types is optional and may be any combination of "heal", "hitdice", and "rest", separated by commas. If types is not provided, then all types of healing are prevented.
 * **DMGMULT: n** - The bearer of this effect has all of their damage dealt multiplied by n.
 * **HEALMULT: n** - The bearer of this effect has all of their healing done multiplied by n.
-* **HEALEDMULT: n, (types)** - The bearer of this effect has all of their healing received multiplied by n. types is optional and may be any combination of "heal", "hitdice", and "rest", seperated by commas. If types is not provided, then all types of healing are multiplied.
+* **HEALEDMULT: n, (types)** - The bearer of this effect has all of their healing received multiplied by n. types is optional and may be any combination of "heal", "hitdice", and "rest", separated by commas. If types is not provided, then all types of healing are multiplied.
 
 ## Installation
 Download [BlissfulIgnorance.ext](https://github.com/MeAndUnique/BlissfulIgnorance/releases) and place in the extensions subfolder of the Fantasy Grounds data folder.

From c882b348c88b7b8f804dbf6f2cd9a1e186090434 Mon Sep 17 00:00:00 2001
From: Michael Baird <eryon@users.noreply.github.com>
Date: Wed, 20 Jul 2022 14:42:54 -0700
Subject: [PATCH 2/5] updated applyDamage signature

---
 scripts/manager_action_damage_bi.lua | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/scripts/manager_action_damage_bi.lua b/scripts/manager_action_damage_bi.lua
index 5745ee2..8d6cfd0 100644
--- a/scripts/manager_action_damage_bi.lua
+++ b/scripts/manager_action_damage_bi.lua
@@ -328,7 +328,7 @@ function multiplyDamage(rSource, rTarget, rDamageOutput)
 	rDamageOutput.nVal = math.max(math.floor(rDamageOutput.nVal * nMult), 1);
 end
 
-function applyDamage(rSource, rTarget, bSecret, sDamage, nTotal)
+function applyDamage(rSource, rTarget, vRollOrSecret, sDamage, nTotal)
 	if string.match(sDamage, "%[RECOVERY")
 		or string.match(sDamage, "%[HEAL")
 		or nTotal < 0 then
@@ -358,14 +358,14 @@ function applyDamage(rSource, rTarget, bSecret, sDamage, nTotal)
 			end
 	end
 
-	applyDamageOriginal(rSource, rTarget, bSecret, sDamage, nTotal);
+	applyDamageOriginal(rSource, rTarget, vRollOrSecret, sDamage, nTotal);
 end
 
-function messageDamage(rSource, rTarget, bSecret, sDamageType, sDamageDesc, sTotal, sExtraResult)
+function messageDamage(rSource, rTarget, vRollOrSecret, sDamageType, sDamageDesc, sTotal, sExtraResult)
 	if nAbsorbed < 0 then
 		local nDamage = nAbsorbed;
 		nAbsorbed = 0;
-		ActionDamage.applyDamage(rSource, rTarget, bSecret, sDamageType, nDamage);
+		ActionDamage.applyDamage(rSource, rTarget, vRollOrSecret, sDamageType, nDamage);
 	else
 		if string.match(sDamageDesc, "%[UNHEALABLE") then
 			if sExtraResult ~= "" then
@@ -377,6 +377,6 @@ function messageDamage(rSource, rTarget, bSecret, sDamageType, sDamageDesc, sTot
 		if sMult then
 			sExtraResult = sExtraResult .. sMult;
 		end
-		messageDamageOriginal(rSource, rTarget, bSecret, sDamageType, sDamageDesc, sTotal, sExtraResult);
+		messageDamageOriginal(rSource, rTarget, vRollOrSecret, sDamageType, sDamageDesc, sTotal, sExtraResult);
 	end
 end
\ No newline at end of file

From 7eb93ec2699d7d7cc2dbec5d386ed696fa396d2c Mon Sep 17 00:00:00 2001
From: Michael Baird <eryon@users.noreply.github.com>
Date: Thu, 21 Jul 2022 12:14:09 -0700
Subject: [PATCH 3/5] unbox vRollOrSecret

---
 scripts/manager_action_damage_bi.lua | 34 +++++++++++++++++++++++++---
 1 file changed, 31 insertions(+), 3 deletions(-)

diff --git a/scripts/manager_action_damage_bi.lua b/scripts/manager_action_damage_bi.lua
index 8d6cfd0..575ed29 100644
--- a/scripts/manager_action_damage_bi.lua
+++ b/scripts/manager_action_damage_bi.lua
@@ -329,6 +329,11 @@ function multiplyDamage(rSource, rTarget, rDamageOutput)
 end
 
 function applyDamage(rSource, rTarget, vRollOrSecret, sDamage, nTotal)
+	if type(vRollOrSecret) == "table" then
+		sDamage = vRollOrSecret.sDesc;
+		nTotal = vRollOrSecret.nTotal;
+	end
+
 	if string.match(sDamage, "%[RECOVERY")
 		or string.match(sDamage, "%[HEAL")
 		or nTotal < 0 then
@@ -361,11 +366,34 @@ function applyDamage(rSource, rTarget, vRollOrSecret, sDamage, nTotal)
 	applyDamageOriginal(rSource, rTarget, vRollOrSecret, sDamage, nTotal);
 end
 
-function messageDamage(rSource, rTarget, vRollOrSecret, sDamageType, sDamageDesc, sTotal, sExtraResult)
+function messageDamage(rSource, rTarget, vRollOrSecret, sDamageText, sDamageDesc, sTotal, sExtraResult)
+	local bSecret, sDamageType, rRoll;
+
+	if type(vRollOrSecret) == "table" then
+		rRoll = vRollOrSecret;
+
+		bSecret = rRoll.bSecret;
+		sDamageType = rRoll.sType;
+		sDamageText = rRoll.sDamageText;
+		sDamageDesc = rRoll.sDesc;
+		sTotal = rRoll.nTotal;
+		sExtraResult = rRoll.sResults;
+	else
+		bSecret = vRollOrSecret;
+		
+		if sDamageText == "Recovery" then
+			sDamageType = "recovery";
+		elseif (sDamageText == "Heal") or (sDamageText == "Temporary hit points") then
+			sDamageType = "heal";
+		else
+			sDamageType = "damage";
+		end
+	end
+
 	if nAbsorbed < 0 then
 		local nDamage = nAbsorbed;
 		nAbsorbed = 0;
-		ActionDamage.applyDamage(rSource, rTarget, vRollOrSecret, sDamageType, nDamage);
+		ActionDamage.applyDamage(rSource, rTarget, vRollOrSecret, sDamageText, nDamage);
 	else
 		if string.match(sDamageDesc, "%[UNHEALABLE") then
 			if sExtraResult ~= "" then
@@ -377,6 +405,6 @@ function messageDamage(rSource, rTarget, vRollOrSecret, sDamageType, sDamageDesc
 		if sMult then
 			sExtraResult = sExtraResult .. sMult;
 		end
-		messageDamageOriginal(rSource, rTarget, vRollOrSecret, sDamageType, sDamageDesc, sTotal, sExtraResult);
+		messageDamageOriginal(rSource, rTarget, vRollOrSecret, sDamageText, sDamageDesc, sTotal, sExtraResult);
 	end
 end
\ No newline at end of file

From 8e417653fd9ad3cdef96eaed9f94b9c31f468ca3 Mon Sep 17 00:00:00 2001
From: Shane Parker <shane.tim.parker@ea.com>
Date: Wed, 27 Jul 2022 21:59:37 -0400
Subject: [PATCH 4/5] Minor cleanup

---
 scripts/manager_action_damage_bi.lua | 17 +----------------
 1 file changed, 1 insertion(+), 16 deletions(-)

diff --git a/scripts/manager_action_damage_bi.lua b/scripts/manager_action_damage_bi.lua
index 575ed29..0085675 100644
--- a/scripts/manager_action_damage_bi.lua
+++ b/scripts/manager_action_damage_bi.lua
@@ -367,27 +367,12 @@ function applyDamage(rSource, rTarget, vRollOrSecret, sDamage, nTotal)
 end
 
 function messageDamage(rSource, rTarget, vRollOrSecret, sDamageText, sDamageDesc, sTotal, sExtraResult)
-	local bSecret, sDamageType, rRoll;
-
 	if type(vRollOrSecret) == "table" then
-		rRoll = vRollOrSecret;
-
-		bSecret = rRoll.bSecret;
-		sDamageType = rRoll.sType;
+		local rRoll = vRollOrSecret;
 		sDamageText = rRoll.sDamageText;
 		sDamageDesc = rRoll.sDesc;
 		sTotal = rRoll.nTotal;
 		sExtraResult = rRoll.sResults;
-	else
-		bSecret = vRollOrSecret;
-		
-		if sDamageText == "Recovery" then
-			sDamageType = "recovery";
-		elseif (sDamageText == "Heal") or (sDamageText == "Temporary hit points") then
-			sDamageType = "heal";
-		else
-			sDamageType = "damage";
-		end
 	end
 
 	if nAbsorbed < 0 then

From e5c3b504cae41b4651c7435a0e63ae9c1fc77623 Mon Sep 17 00:00:00 2001
From: Shane Parker <shane.tim.parker@ea.com>
Date: Thu, 28 Jul 2022 09:00:26 -0400
Subject: [PATCH 5/5] Adapted to new ActionManager redistance logic

---
 extension.xml                        |   1 +
 scripts/manager_action_damage_bi.lua | 146 ++-----------------------
 scripts/manager_actor_bi.lua         | 154 +++++++++++++++++++++++++++
 3 files changed, 164 insertions(+), 137 deletions(-)
 create mode 100644 scripts/manager_actor_bi.lua

diff --git a/extension.xml b/extension.xml
index d8dda91..559f11f 100644
--- a/extension.xml
+++ b/extension.xml
@@ -39,6 +39,7 @@ SOFTWARE.
 
 	<base>
 		<script name="ActionDamageBI" file="scripts/manager_action_damage_bi.lua" />
+		<script name="ActorManagerBI" file="scripts/manager_actor_bi.lua" />
 		<script name="CharManagerBI" file="scripts/manager_char_bi.lua" />
 		<script name="CombatManagerBI" file="scripts/manager_combat_bi.lua" />
 
diff --git a/scripts/manager_action_damage_bi.lua b/scripts/manager_action_damage_bi.lua
index 0085675..8f51ccc 100644
--- a/scripts/manager_action_damage_bi.lua
+++ b/scripts/manager_action_damage_bi.lua
@@ -3,23 +3,19 @@
 -- attribution and copyright information.
 --
 
-local getReductionTypeOriginal;
 local checkReductionTypeHelperOriginal;
 local checkNumericalReductionTypeHelperOriginal;
 local getDamageAdjustOriginal;
 local applyDamageOriginal;
 local messageDamageOriginal;
 
+local rActiveTarget;
 local bAdjusted = false;
 local bIgnored = false;
-local tReductions = {};
 local bPreventCalculateRecursion = false;
 local nAbsorbed = 0;
 
 function onInit()
-	getReductionTypeOriginal = ActionDamage.getReductionType;
-	ActionDamage.getReductionType = getReductionType;
-
 	checkReductionTypeHelperOriginal = ActionDamage.checkReductionTypeHelper;
 	ActionDamage.checkReductionTypeHelper = checkReductionTypeHelper;
 
@@ -40,131 +36,6 @@ function onInit()
 	end
 end
 
-function getReductionType(rSource, rTarget, sEffectType)
-	local aFinal = getReductionTypeOriginal(rSource, rTarget, sEffectType);
-	tReductions[sEffectType] = aFinal;
-
-	addExtras(rSource, rTarget, "IGNORE" .. sEffectType, addIgnoredDamageType, sEffectType);
-
-	if sEffectType == "IMMUNE" and aFinal["all"] then
-		local rReduction = aFinal["all"];
-		aFinal["all"] = nil;
-		for _,sDamage in ipairs(DataCommon.dmgtypes) do
-			aFinal[sDamage] = rReduction;
-		end
-	end
-
-	if sEffectType == "RESIST" then -- Represents the last set
-		local aAbsorb = getReductionType(rSource, rTarget, "ABSORB");
-		for _,rAbsorb in pairs(aAbsorb) do
-			if rAbsorb.mod == 0 then
-				rAbsorb.mod = 1;
-			end
-			rAbsorb.mod = rAbsorb.mod + 1;
-			rAbsorb.bIsAbsorb = true;
-		end
-
-		local aReduce = getReductionType(rSource, rTarget, "REDUCE");
-		for sType,rReduce in pairs(aReduce) do
-			local rResist = tReductions["RESIST"][sType];
-			if not rResist then
-				tReductions["RESIST"][sType] = rReduce;
-			else
-				rResist.nReduceMod = rReduce.mod;
-				rResist.aReduceNegatives = rReduce.aNegatives;
-			end
-		end
-
-		for sOriginalType,_ in pairs(tReductions) do
-			for sNewType,_ in pairs(tReductions) do
-				addExtras(rSource, rTarget, sOriginalType .. "TO" .. sNewType, addDemotedDamagedType, sOriginalType, sNewType);
-			end
-		end
-
-		addExtras(rSource, rTarget, "MAKEVULN", addVulnerableDamageType);
-	end
-
-	return aFinal;
-end
-
-function addExtras(rSource, rTarget, sEffect, fAdd, sPrimaryReduction, sSecondaryReduction)
-	local bHandledAll = false;
-	local aEffects = EffectManager5E.getEffectsByType(rSource, sEffect, {}, rTarget);
-	for _,rEffect in pairs(aEffects) do
-		for _,sType in pairs(rEffect.remainder) do
-			if sType == "all" then
-				for _,sDamage in ipairs(DataCommon.dmgtypes) do
-					fAdd(sDamage, sPrimaryReduction, sSecondaryReduction);
-				end
-				bHandledAll = true;
-				break;
-			end
-			fAdd(sType, sPrimaryReduction, sSecondaryReduction);
-		end
-		if bHandledAll then
-			break;
-		end
-	end
-end
-
-function addIgnoredDamageType(sDamageType, sIgnoredType)
-	local aEffects = tReductions[sIgnoredType];
-	local rReduction = aEffects[sDamageType];
-	if rReduction then
-		if not rReduction.aIgnored then
-			rReduction.aIgnored = {};
-		end
-		table.insert(rReduction.aIgnored, sDamageType);
-	end
-
-	rReduction = aEffects["all"];
-	if rReduction then
-		if not rReduction.aIgnored then
-			rReduction.aIgnored = {};
-		end
-		table.insert(rReduction.aIgnored, sDamageType);
-	end
-end
-
-function addDemotedDamagedType(sDamageType, sOriginalType, sNewType)
-	local aOriginalEffects = tReductions[sOriginalType];
-	local aNewEffects = tReductions[sNewType]
-	local rReduction = aOriginalEffects[sDamageType];
-	if rReduction and not (rReduction.aIgnored and StringManager.contains(rReduction.aIgnored, sDamageType)) then
-		rReduction.bDemoted = true;
-		local rDemoted = getDemotedEffect(aNewEffects, sDamageType);
-		rDemoted.sDemotedFrom = sOriginalType;
-	end
-
-	rReduction = aOriginalEffects["all"];
-	if rReduction and not (rReduction.aIgnored and StringManager.contains(rReduction.aIgnored, sDamageType)) then
-		rReduction.bDemoted = true;
-		local rDemoted = getDemotedEffect(aNewEffects, sDamageType);
-		rDemoted.sDemotedFrom = sOriginalType;
-	end
-end
-
-function getDemotedEffect(aDemotedEffects, sDamageType)
-	local rDemoted = aDemotedEffects[sDamageType];
-	if not rDemoted then
-		rDemoted = {
-			mod = 0;
-			aNegatives = {}
-		};
-		aDemotedEffects[sDamageType] = rDemoted;
-	end
-	return rDemoted;
-end
-
-function addVulnerableDamageType(sDamageType)
-	local aEffects = tReductions["VULN"];
-	aEffects[sDamageType] = {
-		mod = 0,
-		aNegatives = {},
-		bAddIfUnresisted = true
-	};
-end
-
 function checkReductionTypeHelper(rMatch, aDmgType)
 	local result = checkReductionTypeHelperOriginal(rMatch, aDmgType);
 	if bPreventCalculateRecursion then
@@ -172,7 +43,7 @@ function checkReductionTypeHelper(rMatch, aDmgType)
 	end
 
 	if result then
-		if ActionDamage.checkNumericalReductionType(tReductions["ABSORB"], aDmgType) ~= 0 then
+		if ActionDamage.checkNumericalReductionType(rActiveTarget.tReductions["ABSORB"], aDmgType) ~= 0 then
 			result = false;
 		elseif rMatch.aIgnored then
 			for _,sIgnored in pairs(rMatch.aIgnored) do
@@ -187,14 +58,14 @@ function checkReductionTypeHelper(rMatch, aDmgType)
 			result = false;
 		elseif rMatch.bAddIfUnresisted then
 			bPreventCalculateRecursion = true;
-			result = not ActionDamage.checkReductionType(tReductions["RESIST"], aDmgType) and
-				not ActionDamage.checkReductionType(tReductions["IMMUNE"], aDmgType) and
-				not ActionDamage.checkReductionType(tReductions["ABSORB"], aDmgType);
+			result = not ActionDamage.checkReductionType(rActiveTarget.tReductions["RESIST"], aDmgType) and
+				not ActionDamage.checkReductionType(rActiveTarget.tReductions["IMMUNE"], aDmgType) and
+				not ActionDamage.checkReductionType(rActiveTarget.tReductions["ABSORB"], aDmgType);
 			bPreventCalculateRecursion = false;
 		end
 	elseif rMatch and (rMatch.mod ~= 0) then
 		if rMatch.sDemotedFrom then
-			local aMatches = tReductions[rMatch.sDemotedFrom];
+			local aMatches = rActiveTarget.tReductions[rMatch.sDemotedFrom];
 			bPreventCalculateRecursion = true;
 			result = ActionDamage.checkReductionType(aMatches, aDmgType) or
 				ActionDamage.checkNumericalReductionType(aMatches, aDmgType) ~= 0;
@@ -247,7 +118,8 @@ function checkNumericalReductionTypeHelper(rMatch, aDmgType, nLimit)
 end
 
 function getDamageAdjust(rSource, rTarget, nDamage, rDamageOutput)
-	tReductions = {
+	rActiveTarget = rTarget;
+	rTarget.tReductions = {
 		["VULN"] = {},
 		["RESIST"] = {},
 		["IMMUNE"] = {},
@@ -269,7 +141,7 @@ function getDamageAdjust(rSource, rTarget, nDamage, rDamageOutput)
 			end
 		end
 
-		local nLocalAbsorb = ActionDamage.checkNumericalReductionType(tReductions["ABSORB"], aSrcDmgClauseTypes);
+		local nLocalAbsorb = ActionDamage.checkNumericalReductionType(rTarget.tReductions["ABSORB"], aSrcDmgClauseTypes);
 		if nLocalAbsorb ~= 0 then
 			nDamageAdjust = nDamageAdjust - (v * nLocalAbsorb);
 			for _,sDamageType in ipairs(aSrcDmgClauseTypes) do
diff --git a/scripts/manager_actor_bi.lua b/scripts/manager_actor_bi.lua
new file mode 100644
index 0000000..355e9ba
--- /dev/null
+++ b/scripts/manager_actor_bi.lua
@@ -0,0 +1,154 @@
+--
+-- Please see the license.txt file included with this distribution for
+-- attribution and copyright information.
+--
+
+local getDamageVulnerabilitiesOriginal;
+local getDamageResistancesOriginal;
+local getDamageImmunitiesOriginal;
+
+function onInit()
+	getDamageVulnerabilitiesOriginal = ActorManager5E.getDamageVulnerabilities;
+	ActorManager5E.getDamageVulnerabilities = getDamageVulnerabilities;
+
+	getDamageResistancesOriginal = ActorManager5E.getDamageResistances;
+	ActorManager5E.getDamageResistances = getDamageResistances;
+
+	getDamageImmunitiesOriginal = ActorManager5E.getDamageImmunities;
+	ActorManager5E.getDamageImmunities = getDamageImmunities;
+end
+
+function getDamageVulnerabilities(rActor, rSource)
+	local aVuln =  getDamageVulnerabilitiesOriginal(rActor, rSource);
+	rActor.tReductions["VULN"] = aVuln;
+	addExtras(rSource, rActor, "IGNOREVULN", addIgnoredDamageType, "VULN");
+	return aVuln;
+end
+
+function getDamageResistances(rActor, rSource)
+	local aResist = getDamageResistancesOriginal(rActor, rSource);
+	rActor.tReductions["RESIST"] = aResist;
+	addExtras(rSource, rActor, "IGNORERESIST", addIgnoredDamageType, "RESIST");
+	return aResist;
+end
+
+function getDamageImmunities(rActor, rSource)
+	local aImmune = getDamageImmunitiesOriginal(rActor, rSource);
+	rActor.tReductions["IMMUNE"] = aImmune;
+	addExtras(rSource, rActor, "IGNOREVULN", addIgnoredDamageType, "VULN");
+
+	-- Prevent the ruleset from bypassing all logic in the event of IMMUNE: all
+	if aImmune["all"] then
+		local rReduction = aImmune["all"];
+		aImmune["all"] = nil;
+		for _,sDamage in ipairs(DataCommon.dmgtypes) do
+			aImmune[sDamage] = rReduction;
+		end
+	end
+
+	-- Immunities are processed last by the ruleset
+	postProcessResistances(rActor, rSource)
+
+	return aImmune;
+end
+
+function postProcessResistances(rActor, rSource)
+	local aAbsorb = ActorManager5E.getDamageVulnResistImmuneEffectHelper(rActor, "ABSORB", rSource);
+	for _,rAbsorb in pairs(aAbsorb) do
+		if rAbsorb.mod == 0 then
+			rAbsorb.mod = 1;
+		end
+		rAbsorb.mod = rAbsorb.mod + 1;
+		rAbsorb.bIsAbsorb = true;
+	end
+
+	local aReduce = ActorManager5E.getDamageVulnResistImmuneEffectHelper(rActor, "REDUCE", rSource);
+	for sType,rReduce in pairs(aReduce) do
+		local rResist = rActor.tReductions["RESIST"][sType];
+		if not rResist then
+			rActor.tReductions["RESIST"][sType] = rReduce;
+		else
+			rResist.nReduceMod = rReduce.mod;
+			rResist.aReduceNegatives = rReduce.aNegatives;
+		end
+	end
+
+	for sOriginalType,_ in pairs(rActor.tReductions) do
+		for sNewType,_ in pairs(rActor.tReductions) do
+			addExtras(rSource, rActor, sOriginalType .. "TO" .. sNewType, addDemotedDamagedType, sOriginalType, sNewType);
+		end
+	end
+
+	addExtras(rSource, rActor, "MAKEVULN", addVulnerableDamageType);
+end
+
+function addExtras(rSource, rActor, sEffect, fAdd, sPrimaryReduction, sSecondaryReduction)
+	local bHandledAll = false;
+	local aEffects = EffectManager5E.getEffectsByType(rSource, sEffect, {}, rActor);
+	for _,rEffect in pairs(aEffects) do
+		for _,sType in pairs(rEffect.remainder) do
+			if sType == "all" then
+				for _,sDamage in ipairs(DataCommon.dmgtypes) do
+					fAdd(rActor, sDamage, sPrimaryReduction, sSecondaryReduction);
+				end
+				bHandledAll = true;
+				break;
+			end
+			fAdd(rActor, sType, sPrimaryReduction, sSecondaryReduction);
+		end
+		if bHandledAll then
+			break;
+		end
+	end
+end
+
+function addIgnoredDamageType(rActor, sDamageType, sIgnoredType)
+	local aEffects = rActor.tReductions[sIgnoredType];
+	ignoreReduction(aEffects[sDamageType], sDamageType);
+	ignoreReduction(aEffects["all"], sDamageType);
+end
+
+function ignoreReduction(rReduction, sDamageType)
+	if rReduction then
+		if not rReduction.aIgnored then
+			rReduction.aIgnored = {};
+		end
+		table.insert(rReduction.aIgnored, sDamageType);
+	end
+end
+
+function addDemotedDamagedType(rActor, sDamageType, sOriginalType, sNewType)
+	local aOriginalEffects = rActor.tReductions[sOriginalType];
+	local aNewEffects = rActor.tReductions[sNewType]
+	demoteReduction(aOriginalEffects[sDamageType], sDamageType, sOriginalType, aNewEffects);
+	demoteReduction(aOriginalEffects["all"], sDamageType, sOriginalType, aNewEffects);
+end
+
+function demoteReduction(rReduction, sDamageType, sOriginalType, aNewEffects)
+	if rReduction and not (rReduction.aIgnored and StringManager.contains(rReduction.aIgnored, sDamageType)) then
+		rReduction.bDemoted = true;
+		local rDemoted = getDemotedEffect(aNewEffects, sDamageType);
+		rDemoted.sDemotedFrom = sOriginalType;
+	end
+end
+
+function getDemotedEffect(aDemotedEffects, sDamageType)
+	local rDemoted = aDemotedEffects[sDamageType];
+	if not rDemoted then
+		rDemoted = {
+			mod = 0;
+			aNegatives = {}
+		};
+		aDemotedEffects[sDamageType] = rDemoted;
+	end
+	return rDemoted;
+end
+
+function addVulnerableDamageType(rActor, sDamageType)
+	local aEffects = rActor.tReductions["VULN"];
+	aEffects[sDamageType] = {
+		mod = 0,
+		aNegatives = {},
+		bAddIfUnresisted = true
+	};
+end
\ No newline at end of file