PreventNegativeDamage

Coronia · Coronia · commit 23ad366a93fb · 2025-06-18T00:08:02.000+08:00
diff --git a/docs/New-or-Enhanced-Logics.md b/docs/New-or-Enhanced-Logics.md
@@ -76,6 +76,7 @@ This page describes all the engine features that are either new and introduced b
   - `DisableWeapons` can be used to disable ability to fire any and all weapons.
     - On TechnoTypes with `OpenTopped=true`, `OpenTopped.CheckTransportDisableWeapons` can be set to true to make passengers not be able to fire out if transport's weapons are disabled by `DisableWeapons`.
   - `Unkillable` can be used to prevent the techno from being killed by taken damage (minimum health will be 1).
+  - `PreventNegativeDamage` can be used to prevent the techno from taking negative damage. This includes both negative `Damage` and negative `Verses`.
   - It is possible to set groups for attach effect types by defining strings in `Groups`.
     - Groups can be used instead of types for removing effects and weapon filters.
 
@@ -186,6 +187,7 @@ ReflectDamage.Override=                            ; integer
 ReflectDamage.UseInvokerAsOwner=false              ; boolean
 DisableWeapons=false                               ; boolean
 Unkillable=false                                   ; boolean
+PreventNegativeDamage=false                        ; boolean
 Groups=                                            ; comma-separated list of strings (group IDs)
 
 [SOMETECHNO]                                       ; TechnoType
diff --git a/src/Ext/Techno/Body.Update.cpp b/src/Ext/Techno/Body.Update.cpp
@@ -1819,6 +1819,7 @@ void TechnoExt::ExtData::RecalculateStatMultipliers()
 	bool forceDecloak = false;
 	bool disableWeapons = false;
 	bool unkillable = false;
+	bool preventNegativeDamage = false;
 	bool hasRangeModifier = false;
 	bool hasTint = false;
 	bool reflectsDamage = false;
@@ -1842,6 +1843,7 @@ void TechnoExt::ExtData::RecalculateStatMultipliers()
 		forceDecloak |= type->ForceDecloak;
 		disableWeapons |= type->DisableWeapons;
 		unkillable |= type->Unkillable;
+		preventNegativeDamage |= type->PreventNegativeDamage;
 		hasRangeModifier |= (type->WeaponRange_ExtraRange != 0.0 || type->WeaponRange_Multiplier != 0.0);
 		hasTint |= type->HasTint();
 		reflectsDamage |= type->ReflectDamage;
@@ -1860,6 +1862,7 @@ void TechnoExt::ExtData::RecalculateStatMultipliers()
 	pAE.ForceDecloak = forceDecloak;
 	pAE.DisableWeapons = disableWeapons;
 	pAE.Unkillable = unkillable;
+	pAE.PreventNegativeDamage = preventNegativeDamage;
 	pAE.HasRangeModifier = hasRangeModifier;
 	pAE.HasTint = hasTint;
 	pAE.ReflectDamage = reflectsDamage;
diff --git a/src/Ext/Techno/Hooks.ReceiveDamage.cpp b/src/Ext/Techno/Hooks.ReceiveDamage.cpp
@@ -25,9 +25,10 @@ DEFINE_HOOK(0x701900, TechnoClass_ReceiveDamage_Shield, 0x6)
 
 	const auto pSourceHouse = args->SourceHouse;
 	const auto pTargetHouse = pThis->Owner;
+	int& damage = *args->Damage;
 
 	// Calculate Damage Multiplier
-	if (!args->IgnoreDefenses && *args->Damage)
+	if (!args->IgnoreDefenses && damage)
 	{
 		double multiplier = 1.0;
 
@@ -40,14 +41,14 @@ DEFINE_HOOK(0x701900, TechnoClass_ReceiveDamage_Shield, 0x6)
 
 		if (multiplier != 1.0)
 		{
-			const auto sgnDamage = *args->Damage > 0 ? 1 : -1;
-			const auto calculateDamage = static_cast<int>(*args->Damage * multiplier);
-			*args->Damage = calculateDamage ? calculateDamage : sgnDamage;
+			const auto sgnDamage = damage > 0 ? 1 : -1;
+			const auto calculateDamage = static_cast<int>(damage * multiplier);
+			damage = calculateDamage ? calculateDamage : sgnDamage;
 		}
 	}
 
 	// Raise Combat Alert
-	if (pRules->CombatAlert && *args->Damage > 1)
+	if (pRules->CombatAlert && damage > 1)
 	{
 		auto raiseCombatAlert = [&]()
 		{
@@ -104,7 +105,7 @@ DEFINE_HOOK(0x701900, TechnoClass_ReceiveDamage_Shield, 0x6)
 	// Shield Receive Damage
 	if (!args->IgnoreDefenses)
 	{
-		int nDamageLeft = *args->Damage;
+		int nDamageLeft = damage;
 
 		if (const auto pShieldData = pExt->Shield.get())
 		{
@@ -114,9 +115,9 @@ DEFINE_HOOK(0x701900, TechnoClass_ReceiveDamage_Shield, 0x6)
 
 				if (nDamageLeft >= 0)
 				{
-					*args->Damage = nDamageLeft;
+					damage = nDamageLeft;
 
-					if (auto pTag = pThis->AttachedTag)
+					if (const auto pTag = pThis->AttachedTag)
 						pTag->RaiseEvent((TriggerEvent)PhobosTriggerEvent::ShieldBroken, pThis, CellStruct::Empty);
 				}
 
@@ -131,11 +132,17 @@ DEFINE_HOOK(0x701900, TechnoClass_ReceiveDamage_Shield, 0x6)
 			&& MapClass::GetTotalDamage(nDamageLeft, args->WH, pThis->GetTechnoType()->Armor, args->DistanceToEpicenter) >= pThis->Health)
 		{
 			// Update remaining damage and check if the target will die and should be avoided
-			*args->Damage = 0;
+			damage = 0;
 			pThis->Health = 1;
 			pThis->EstimatedHealth = 1;
 			ReceiveDamageTemp::SkipLowDamageCheck = true;
 		}
+
+		if (pExt->AE.PreventNegativeDamage && nDamageLeft != 0 && pWHExt->CanTargetHouse(pSourceHouse, pThis)
+			&& MapClass::GetTotalDamage(nDamageLeft, args->WH, pThis->GetTechnoType()->Armor, args->DistanceToEpicenter) < 0)
+		{
+			damage = 0;
+		}
 	}
 
 	return 0;
diff --git a/src/New/Entity/AttachEffectClass.h b/src/New/Entity/AttachEffectClass.h
@@ -97,6 +97,7 @@ struct AttachEffectTechnoProperties
 	bool ForceDecloak;
 	bool DisableWeapons;
 	bool Unkillable;
+	bool PreventNegativeDamage;
 	bool HasRangeModifier;
 	bool HasTint;
 	bool ReflectDamage;
@@ -115,6 +116,7 @@ struct AttachEffectTechnoProperties
 		, ForceDecloak { false }
 		, DisableWeapons { false }
 		, Unkillable { false }
+		, PreventNegativeDamage { false }
 		, HasRangeModifier { false }
 		, HasTint { false }
 		, ReflectDamage { false }
diff --git a/src/New/Entity/ShieldClass.cpp b/src/New/Entity/ShieldClass.cpp
@@ -160,13 +160,17 @@ bool ShieldClass::ShieldIsBrokenTEvent(ObjectClass* pAttached)
 
 int ShieldClass::ReceiveDamage(args_ReceiveDamage* args)
 {
-	if (!this->HP || this->Temporal || *args->Damage == 0)
-		return *args->Damage;
+	int& damage = *args->Damage;
+
+	if (!this->HP || this->Temporal || damage == 0)
+		return damage;
+
+	auto const pTechno = this->Techno;
 
 	// Handle a special case where parasite damages shield but not the unit and unit itself cannot be targeted by repair weapons.
-	if (*args->Damage < 0)
+	if (damage < 0)
 	{
-		if (auto const pFoot = abstract_cast<FootClass*, true>(this->Techno))
+		if (auto const pFoot = abstract_cast<FootClass*, true>(pTechno))
 		{
 			if (auto const pParasite = pFoot->ParasiteEatingMe)
 			{
@@ -177,59 +181,64 @@ int ShieldClass::ReceiveDamage(args_ReceiveDamage* args)
 		}
 	}
 
-	auto const pWHExt = WarheadTypeExt::ExtMap.Find(args->WH);
-	bool IC = pWHExt->CanAffectInvulnerable(this->Techno);
+	auto const pWH = args->WH;
+	auto const pWHExt = WarheadTypeExt::ExtMap.Find(pWH);
+	const bool IC = pWHExt->CanAffectInvulnerable(pTechno);
 
-	if (!IC || CanBePenetrated(args->WH) || this->Techno->GetTechnoType()->Immune || TechnoExt::IsTypeImmune(this->Techno, args->Attacker))
-		return *args->Damage;
+	if (!IC || CanBePenetrated(pWH) || pTechno->GetTechnoType()->Immune || TechnoExt::IsTypeImmune(pTechno, args->Attacker))
+		return damage;
 
 	int nDamage = 0;
 	int shieldDamage = 0;
 	int healthDamage = 0;
+	auto const pType = this->Type;
 
-	if (pWHExt->CanTargetHouse(args->SourceHouse, this->Techno) && !args->WH->Temporal)
+	if (pWHExt->CanTargetHouse(args->SourceHouse, pTechno) && !pWH->Temporal)
 	{
-		if (*args->Damage > 0)
-			nDamage = MapClass::GetTotalDamage(*args->Damage, args->WH, this->GetArmorType(), args->DistanceToEpicenter);
+		if (damage > 0)
+			nDamage = MapClass::GetTotalDamage(damage, pWH, this->GetArmorType(), args->DistanceToEpicenter);
 		else
-			nDamage = -MapClass::GetTotalDamage(-*args->Damage, args->WH, this->GetArmorType(), args->DistanceToEpicenter);
+			nDamage = -MapClass::GetTotalDamage(damage, pWH, this->GetArmorType(), args->DistanceToEpicenter);
 
-		bool affectsShield = pWHExt->Shield_AffectTypes.size() <= 0 || pWHExt->Shield_AffectTypes.Contains(this->Type);
-		double absorbPercent = affectsShield ? pWHExt->Shield_AbsorbPercent.Get(this->Type->AbsorbPercent) : this->Type->AbsorbPercent;
-		double passPercent = affectsShield ? pWHExt->Shield_PassPercent.Get(this->Type->PassPercent) : this->Type->PassPercent;
+		const bool affectsShield = pWHExt->Shield_AffectTypes.size() <= 0 || pWHExt->Shield_AffectTypes.Contains(pType);
+		const double absorbPercent = affectsShield ? pWHExt->Shield_AbsorbPercent.Get(pType->AbsorbPercent) : pType->AbsorbPercent;
+		const double passPercent = affectsShield ? pWHExt->Shield_PassPercent.Get(pType->PassPercent) : pType->PassPercent;
 
 		shieldDamage = (int)((double)nDamage * absorbPercent);
 		// passthrough damage shouldn't be affected by shield armor
-		healthDamage = (int)((double)*args->Damage * passPercent);
+		healthDamage = (int)((double)damage * passPercent);
 	}
 
-	int originalShieldDamage = shieldDamage;
-	int min = pWHExt->Shield_ReceivedDamage_Minimum.Get(this->Type->ReceivedDamage_Minimum);
-	int max = pWHExt->Shield_ReceivedDamage_Maximum.Get(this->Type->ReceivedDamage_Maximum);
-	int minDmg = static_cast<int>(min * pWHExt->Shield_ReceivedDamage_MinMultiplier);
-	int maxDmg = static_cast<int>(max * pWHExt->Shield_ReceivedDamage_MaxMultiplier);
+	const int originalShieldDamage = shieldDamage;
+	const int min = pWHExt->Shield_ReceivedDamage_Minimum.Get(pType->ReceivedDamage_Minimum);
+	const int max = pWHExt->Shield_ReceivedDamage_Maximum.Get(pType->ReceivedDamage_Maximum);
+	const int minDmg = static_cast<int>(min * pWHExt->Shield_ReceivedDamage_MinMultiplier);
+	const int maxDmg = static_cast<int>(max * pWHExt->Shield_ReceivedDamage_MaxMultiplier);
 	shieldDamage = Math::clamp(shieldDamage, minDmg, maxDmg);
 
+	if (shieldDamage < 0 && TechnoExt::ExtMap.Find(pTechno)->AE.PreventNegativeDamage)
+		shieldDamage = 0;
+
 	if (Phobos::DisplayDamageNumbers && shieldDamage != 0)
-		GeneralUtils::DisplayDamageNumberString(shieldDamage, DamageDisplayType::Shield, this->Techno->GetRenderCoords(), TechnoExt::ExtMap.Find(this->Techno)->DamageNumberOffset);
+		GeneralUtils::DisplayDamageNumberString(shieldDamage, DamageDisplayType::Shield, pTechno->GetRenderCoords(), TechnoExt::ExtMap.Find(pTechno)->DamageNumberOffset);
 
 	if (shieldDamage > 0)
 	{
-		bool whModifiersApplied = this->Timers.SelfHealing_WHModifier.InProgress();
-		bool restart = whModifiersApplied ? this->SelfHealing_RestartInCombat_Warhead : this->Type->SelfHealing_RestartInCombat;
+		const bool whModifiersApplied = this->Timers.SelfHealing_WHModifier.InProgress();
+		const bool restart = whModifiersApplied ? this->SelfHealing_RestartInCombat_Warhead : pType->SelfHealing_RestartInCombat;
 
 		if (restart)
 		{
-			int delay = whModifiersApplied ? this->SelfHealing_RestartInCombatDelay_Warhead : this->Type->SelfHealing_RestartInCombatDelay;
+			const int delay = whModifiersApplied ? this->SelfHealing_RestartInCombatDelay_Warhead : pType->SelfHealing_RestartInCombatDelay;
 
 			if (delay > 0)
 			{
-				this->Timers.SelfHealing_CombatRestart.Start(this->Type->SelfHealing_RestartInCombatDelay);
+				this->Timers.SelfHealing_CombatRestart.Start(pType->SelfHealing_RestartInCombatDelay);
 				this->Timers.SelfHealing.Stop();
 			}
 			else
 			{
-				const int rate = whModifiersApplied ? this->SelfHealing_Rate_Warhead : this->Type->SelfHealing_Rate;
+				const int rate = whModifiersApplied ? this->SelfHealing_Rate_Warhead : pType->SelfHealing_Rate;
 				this->Timers.SelfHealing.Start(rate); // when attacked, restart the timer
 			}
 		}
@@ -238,41 +247,41 @@ int ShieldClass::ReceiveDamage(args_ReceiveDamage* args)
 			this->ResponseAttack();
 
 		if (pWHExt->DecloakDamagedTargets)
-			this->Techno->Uncloak(false);
+			pTechno->Uncloak(false);
 
-		int residueDamage = shieldDamage - this->HP;
+		const int residueDamage = shieldDamage - this->HP;
 
 		if (residueDamage >= 0)
 		{
-			int actualResidueDamage = Math::max(0, int((double)(originalShieldDamage - this->HP) /
-				GeneralUtils::GetWarheadVersusArmor(args->WH, this->GetArmorType()))); //only absord percentage damage
+			const int actualResidueDamage = Math::max(0, int((double)(originalShieldDamage - this->HP) /
+				GeneralUtils::GetWarheadVersusArmor(pWH, this->GetArmorType()))); //only absord percentage damage
 
 			this->BreakShield(pWHExt->Shield_BreakAnim, pWHExt->Shield_BreakWeapon.Get(nullptr));
 
-			return this->Type->AbsorbOverDamage ? healthDamage : actualResidueDamage + healthDamage;
+			return pType->AbsorbOverDamage ? healthDamage : actualResidueDamage + healthDamage;
 		}
 		else
 		{
-			if (this->Type->HitFlash && pWHExt->Shield_HitFlash)
+			if (pType->HitFlash && pWHExt->Shield_HitFlash)
 			{
-				int size = this->Type->HitFlash_FixedSize.Get((shieldDamage * 2));
+				const int size = pType->HitFlash_FixedSize.Get((shieldDamage * 2));
 				SpotlightFlags flags = SpotlightFlags::NoColor;
 
-				if (this->Type->HitFlash_Black)
+				if (pType->HitFlash_Black)
 				{
 					flags = SpotlightFlags::NoColor;
 				}
 				else
 				{
-					if (!this->Type->HitFlash_Red)
+					if (!pType->HitFlash_Red)
 						flags = SpotlightFlags::NoRed;
-					if (!this->Type->HitFlash_Green)
+					if (!pType->HitFlash_Green)
 						flags |= SpotlightFlags::NoGreen;
-					if (!this->Type->HitFlash_Blue)
+					if (!pType->HitFlash_Blue)
 						flags |= SpotlightFlags::NoBlue;
 				}
 
-				MapClass::FlashbangWarheadAt(size, args->WH, this->Techno->Location, true, flags);
+				MapClass::FlashbangWarheadAt(size, pWH, pTechno->Location, true, flags);
 			}
 
 			if (!pWHExt->Shield_SkipHitAnim)
diff --git a/src/New/Type/AttachEffectTypeClass.cpp b/src/New/Type/AttachEffectTypeClass.cpp
@@ -186,6 +186,7 @@ void AttachEffectTypeClass::LoadFromINI(CCINIClass* pINI)
 
 	this->DisableWeapons.Read(exINI, pSection, "DisableWeapons");
 	this->Unkillable.Read(exINI, pSection, "Unkillable");
+	this->PreventNegativeDamage.Read(exINI, pSection, "PreventNegativeDamage");
 
 	// Groups
 	exINI.ParseStringList(this->Groups, pSection, "Groups");
@@ -274,6 +275,7 @@ void AttachEffectTypeClass::Serialize(T& Stm)
 		.Process(this->ReflectDamage_UseInvokerAsOwner)
 		.Process(this->DisableWeapons)
 		.Process(this->Unkillable)
+		.Process(this->PreventNegativeDamage)
 		.Process(this->Groups)
 		;
 }
diff --git a/src/New/Type/AttachEffectTypeClass.h b/src/New/Type/AttachEffectTypeClass.h
@@ -118,6 +118,7 @@ class AttachEffectTypeClass final : public Enumerable<AttachEffectTypeClass>
 	Valueable<bool> ReflectDamage_UseInvokerAsOwner;
 	Valueable<bool> DisableWeapons;
 	Valueable<bool> Unkillable;
+	Valueable<bool> PreventNegativeDamage;
 
 	std::vector<std::string> Groups;
 
@@ -200,6 +201,7 @@ class AttachEffectTypeClass final : public Enumerable<AttachEffectTypeClass>
 		, ReflectDamage_UseInvokerAsOwner { false }
 		, DisableWeapons { false }
 		, Unkillable { false }
+		, PreventNegativeDamage { false }
 		, Groups {}
 	{};
 

Original file line number	Diff line number	Diff line change
`@@ -25,9 +25,10 @@ DEFINE_HOOK(0x701900, TechnoClass_ReceiveDamage_Shield, 0x6)`
`25`	`25`
`26`	`26`	`const auto pSourceHouse = args->SourceHouse;`
`27`	`27`	`const auto pTargetHouse = pThis->Owner;`
	`28`	`+ int& damage = *args->Damage;`
`28`	`29`
`29`	`30`	`// Calculate Damage Multiplier`
`30`		`- if (!args->IgnoreDefenses && *args->Damage)`
	`31`	`+ if (!args->IgnoreDefenses && damage)`
`31`	`32`	`{`
`32`	`33`	`double multiplier = 1.0;`
`33`	`34`
`@@ -40,14 +41,14 @@ DEFINE_HOOK(0x701900, TechnoClass_ReceiveDamage_Shield, 0x6)`
`40`	`41`
`41`	`42`	`if (multiplier != 1.0)`
`42`	`43`	`{`
`43`		`- const auto sgnDamage = *args->Damage > 0 ? 1 : -1;`
`44`		`- const auto calculateDamage = static_cast<int>(args->Damage multiplier);`
`45`		`- *args->Damage = calculateDamage ? calculateDamage : sgnDamage;`
	`44`	`+ const auto sgnDamage = damage > 0 ? 1 : -1;`
	`45`	`+ const auto calculateDamage = static_cast<int>(damage * multiplier);`
	`46`	`+ damage = calculateDamage ? calculateDamage : sgnDamage;`
`46`	`47`	`}`
`47`	`48`	`}`
`48`	`49`
`49`	`50`	`// Raise Combat Alert`
`50`		`- if (pRules->CombatAlert && *args->Damage > 1)`
	`51`	`+ if (pRules->CombatAlert && damage > 1)`
`51`	`52`	`{`
`52`	`53`	`auto raiseCombatAlert = [&]()`
`53`	`54`	`{`
`@@ -104,7 +105,7 @@ DEFINE_HOOK(0x701900, TechnoClass_ReceiveDamage_Shield, 0x6)`
`104`	`105`	`// Shield Receive Damage`
`105`	`106`	`if (!args->IgnoreDefenses)`
`106`	`107`	`{`
`107`		`- int nDamageLeft = *args->Damage;`
	`108`	`+ int nDamageLeft = damage;`
`108`	`109`
`109`	`110`	`if (const auto pShieldData = pExt->Shield.get())`
`110`	`111`	`{`
`@@ -114,9 +115,9 @@ DEFINE_HOOK(0x701900, TechnoClass_ReceiveDamage_Shield, 0x6)`
`114`	`115`
`115`	`116`	`if (nDamageLeft >= 0)`
`116`	`117`	`{`
`117`		`- *args->Damage = nDamageLeft;`
	`118`	`+ damage = nDamageLeft;`
`118`	`119`
`119`		`- if (auto pTag = pThis->AttachedTag)`
	`120`	`+ if (const auto pTag = pThis->AttachedTag)`
`120`	`121`	`pTag->RaiseEvent((TriggerEvent)PhobosTriggerEvent::ShieldBroken, pThis, CellStruct::Empty);`
`121`	`122`	`}`
`122`	`123`
`@@ -131,11 +132,17 @@ DEFINE_HOOK(0x701900, TechnoClass_ReceiveDamage_Shield, 0x6)`
`131`	`132`	`&& MapClass::GetTotalDamage(nDamageLeft, args->WH, pThis->GetTechnoType()->Armor, args->DistanceToEpicenter) >= pThis->Health)`
`132`	`133`	`{`
`133`	`134`	`// Update remaining damage and check if the target will die and should be avoided`
`134`		`- *args->Damage = 0;`
	`135`	`+ damage = 0;`
`135`	`136`	`pThis->Health = 1;`
`136`	`137`	`pThis->EstimatedHealth = 1;`
`137`	`138`	`ReceiveDamageTemp::SkipLowDamageCheck = true;`
`138`	`139`	`}`
	`140`	`+`
	`141`	`+ if (pExt->AE.PreventNegativeDamage && nDamageLeft != 0 && pWHExt->CanTargetHouse(pSourceHouse, pThis)`
	`142`	`+ && MapClass::GetTotalDamage(nDamageLeft, args->WH, pThis->GetTechnoType()->Armor, args->DistanceToEpicenter) < 0)`
	`143`	`+ {`
	`144`	`+ damage = 0;`
	`145`	`+ }`
`139`	`146`	`}`
`140`	`147`
`141`	`148`	`return 0;`
Original file line number	Diff line number	Diff line change
`@@ -186,6 +186,7 @@ void AttachEffectTypeClass::LoadFromINI(CCINIClass* pINI)`
`186`	`186`
`187`	`187`	`this->DisableWeapons.Read(exINI, pSection, "DisableWeapons");`
`188`	`188`	`this->Unkillable.Read(exINI, pSection, "Unkillable");`
	`189`	`+ this->PreventNegativeDamage.Read(exINI, pSection, "PreventNegativeDamage");`
`189`	`190`
`190`	`191`	`// Groups`
`191`	`192`	`exINI.ParseStringList(this->Groups, pSection, "Groups");`
`@@ -274,6 +275,7 @@ void AttachEffectTypeClass::Serialize(T& Stm)`
`274`	`275`	`.Process(this->ReflectDamage_UseInvokerAsOwner)`
`275`	`276`	`.Process(this->DisableWeapons)`
`276`	`277`	`.Process(this->Unkillable)`
	`278`	`+ .Process(this->PreventNegativeDamage)`
`277`	`279`	`.Process(this->Groups)`
`278`	`280`	`;`
`279`	`281`	`}`