[Minor] Damage.DealtByInvoker tweak & Damage.ApplyFIrepowerMult (#1728)

previous `Damage.DealtByInvoker` doesn't really apply to anim warhead,
this PR makes it inline with anim weapon. Notice that this might change
the behavior of anim weapon and warhead a bit, but I think this should
be the correct way. Any other feedbacks and reviews are welcome

`Damage.ApplyFirepowerMult` determines whether or not firepower
modifiers from the animation's invoker are applied on the damage dealt
from this animation, if exists

Author: Coronia

docs/Fixed-or-Improved-Logics.md

@@ -330,15 +330,17 @@ LandingDir=     ; Direction type (integers from 0-255). Accepts negative values
 - `Weapon` can be set to a WeaponType, to create a projectile and immediately detonate it instead of simply dealing `Damage` by `Warhead`. This allows weapon effects to be applied.
 - `Damage.Delay` determines delay between two applications of `Damage`. Requires `Damage` to be set to 1.0 or above. Value of 0 disables the delay. Keep in mind that this is measured in animation frames, not game frames. Depending on `Rate`, animation may or may not advance animation frames on every game frame.
 - `Damage.DealtByInvoker`, if set to true, makes any `Damage` dealt to be considered as coming from the animation's invoker (f.ex, firer of the weapon if it is Warhead `AnimList/SplashList` animation, the destroyed vehicle if it is `DestroyAnim` animation or the object the animation is attached to). If invoker has died or does not exist, the house the invoker belonged to is still used to deal damage and apply Phobos-introduced Warhead effects. Does not affect which house the `Damage` dealt by `Warhead` is dealt by.
+  - `Damage.ApplyFirepowerMult` determines whether or not firepower modifiers from the animation's invoker are applied on the damage dealt from this animation, if exists.
 - `Damage.ApplyOncePerLoop`, if set to true, makes `Damage` be dealt only once per animation loop (on single loop animations, only once, period) instead of on every frame or intervals defined by `Damage.Delay`. The frame on which it is dealt is determined by `Damage.Delay`, defaulting to after the first animation frame.
 
 In `artmd.ini`:
 ```ini
-[SOMEANIM]                     ; AnimationType
-Weapon=                        ; WeaponType
-Damage.Delay=0                 ; integer, animation frames
-Damage.DealtByInvoker=false    ; boolean
-Damage.ApplyOncePerLoop=false  ; boolean
+[SOMEANIM]                      ; AnimationType
+Weapon=                         ; WeaponType
+Damage.Delay=0                  ; integer, animation frames
+Damage.DealtByInvoker=false     ; boolean
+Damage.ApplyOncePerLoop=false   ; boolean
+Damage.ApplyFirepowerMult=false ; boolean
 ```
 
 ```{note}

src/Ext/Anim/Hooks.cpp

@@ -42,70 +42,82 @@ DEFINE_HOOK(0x42453E, AnimClass_AI_Damage, 0x6)
 
 	GET(AnimClass*, pThis, ESI);
 
+	if (pThis->IsInert)
+		return SkipDamage;
+
 	const auto pTypeExt = AnimTypeExt::ExtMap.Find(pThis->Type);
 	const int delay = pTypeExt->Damage_Delay.Get();
-	int damageMultiplier = 1;
-	double damage = 0;
-	int appliedDamage = 0;
+	const bool isTerrain = pThis->OwnerObject && pThis->OwnerObject->WhatAmI() == AbstractType::Terrain;
+	const int damageMultiplier = isTerrain ? 5 : 1;
+	const double baseDamage = pThis->Type->Damage;
 
-	if (pThis->OwnerObject && pThis->OwnerObject->WhatAmI() == AbstractType::Terrain)
-		damageMultiplier = 5;
+	int appliedDamage = 0;
 
 	if (pTypeExt->Damage_ApplyOncePerLoop) // If damage is to be applied only once per animation loop
 	{
 		if (pThis->Animation.Value == std::max(delay - 1, 1))
-			appliedDamage = static_cast<int>(std::round(pThis->Type->Damage)) * damageMultiplier;
+			appliedDamage = static_cast<int>(std::round(baseDamage)) * damageMultiplier;
 		else
 			return SkipDamage;
 	}
-	else if (delay <= 0 || pThis->Type->Damage < 1.0) // If Damage.Delay is less than 1 or Damage is a fraction.
+	else if (delay <= 0 || baseDamage < 1.0) // If Damage.Delay is less than 1 or Damage is a fraction.
 	{
-		damage = damageMultiplier * pThis->Type->Damage + pThis->Accum;
+		const double totalDamage = damageMultiplier * baseDamage + pThis->Accum;
 
 		// Deal damage if it is at least 1, otherwise accumulate it for later.
-		if (damage >= 1.0)
+		if (totalDamage >= 1.0)
 		{
-			appliedDamage = static_cast<int>(std::round(damage));
-			pThis->Accum = damage - appliedDamage;
+			appliedDamage = static_cast<int>(std::round(totalDamage));
+			pThis->Accum = totalDamage - appliedDamage;
 		}
 		else
 		{
-			pThis->Accum = damage;
+			pThis->Accum = totalDamage;
 			return SkipDamage;
 		}
 	}
 	else
 	{
 		// Accum here is used as a counter for Damage.Delay, which cannot deal fractional damage.
-		damage = pThis->Accum + 1.0;
-		pThis->Accum = damage;
+		pThis->Accum += 1.0;
 
-		if (damage < delay)
+		if (pThis->Accum < delay)
 			return SkipDamage;
 
 		// Use Type->Damage as the actually dealt damage.
-		appliedDamage = static_cast<int>(std::round(pThis->Type->Damage)) * damageMultiplier;
+		appliedDamage = static_cast<int>(std::round(baseDamage)) * damageMultiplier;
 		pThis->Accum = 0.0;
 	}
 
-	if (appliedDamage <= 0 || pThis->IsInert)
+	if (appliedDamage <= 0)
 		return SkipDamage;
 
 	TechnoClass* pInvoker = nullptr;
-	HouseClass* pOwner = nullptr;
+	HouseClass* pOwner = pThis->Owner;
 
 	if (pTypeExt->Damage_DealtByInvoker)
 	{
-		auto const pExt = AnimExt::ExtMap.Find(pThis);
+		const auto pExt = AnimExt::ExtMap.Find(pThis);
 		pInvoker = pExt->Invoker;
-		pOwner = pExt->InvokerHouse;
+
+		if (pExt->InvokerHouse)
+			pOwner = pExt->InvokerHouse;
 
 		if (!pInvoker)
 		{
-			pInvoker = pThis->OwnerObject ? abstract_cast<TechnoClass*>(pThis->OwnerObject) : nullptr;
+			if (pThis->OwnerObject)
+				pInvoker = abstract_cast<TechnoClass*, true>(pThis->OwnerObject);
+			else if (pThis->IsBuildingAnim)
+				pInvoker = pExt->ParentBuilding;
+		}
 
-			if (pInvoker && !pOwner)
+		if (pInvoker)
+		{
+			if (!pOwner)
 				pOwner = pInvoker->Owner;
+
+			if (pTypeExt->Damage_ApplyFirepowerMult)
+				appliedDamage = static_cast<int>(appliedDamage * pInvoker->FirepowerMultiplier * TechnoExt::ExtMap.Find(pInvoker)->AE.FirepowerMultiplier);
 		}
 	}
 
@@ -115,27 +127,6 @@ DEFINE_HOOK(0x42453E, AnimClass_AI_Damage, 0x6)
 	}
 	else
 	{
-		if (!pOwner)
-		{
-			if (pThis->Owner)
-			{
-				pOwner = pThis->Owner;
-			}
-			else if (pInvoker)
-			{
-				pOwner = pInvoker->Owner;
-			}
-			else if (pThis->OwnerObject)
-			{
-				pOwner = pThis->OwnerObject->GetOwningHouse();
-			}
-			else if (pThis->IsBuildingAnim)
-			{
-				auto const pBuilding = AnimExt::ExtMap.Find(pThis)->ParentBuilding;
-				pOwner = pBuilding ? pBuilding->Owner : nullptr;
-			}
-		}
-
 		auto pWarhead = pThis->Type->Warhead;
 
 		if (!pWarhead)

src/Ext/AnimType/Body.cpp

@@ -93,6 +93,7 @@ void AnimTypeExt::ExtData::LoadFromINIFile(CCINIClass* pINI)
 	this->Damage_Delay.Read(exINI, pID, "Damage.Delay");
 	this->Damage_DealtByInvoker.Read(exINI, pID, "Damage.DealtByInvoker");
 	this->Damage_ApplyOncePerLoop.Read(exINI, pID, "Damage.ApplyOncePerLoop");
+	this->Damage_ApplyFirepowerMult.Read(exINI, pID, "Damage.ApplyFirepowerMult");
 	this->ExplodeOnWater.Read(exINI, pID, "ExplodeOnWater");
 	this->Warhead_Detonate.Read(exINI, pID, "Warhead.Detonate");
 	this->WakeAnim.Read(exINI, pID, "WakeAnim");
@@ -151,6 +152,7 @@ void AnimTypeExt::ExtData::Serialize(T& Stm)
 		.Process(this->Damage_Delay)
 		.Process(this->Damage_DealtByInvoker)
 		.Process(this->Damage_ApplyOncePerLoop)
+		.Process(this->Damage_ApplyFirepowerMult)
 		.Process(this->ExplodeOnWater)
 		.Process(this->Warhead_Detonate)
 		.Process(this->WakeAnim)

src/Ext/AnimType/Body.h

@@ -29,6 +29,7 @@ class AnimTypeExt
 		Valueable<int> Damage_Delay;
 		Valueable<bool> Damage_DealtByInvoker;
 		Valueable<bool> Damage_ApplyOncePerLoop;
+		Valueable<bool> Damage_ApplyFirepowerMult;
 		Valueable<bool> ExplodeOnWater;
 		Valueable<bool> Warhead_Detonate;
 		Valueable<AnimTypeClass*> WakeAnim;
@@ -67,6 +68,7 @@ class AnimTypeExt
 			, Damage_Delay { 0 }
 			, Damage_DealtByInvoker { false }
 			, Damage_ApplyOncePerLoop { false }
+			, Damage_ApplyFirepowerMult { false }
 			, ExplodeOnWater { false }
 			, Warhead_Detonate { false }
 			, WakeAnim {}