ExtraWarheads AE

Author: Coronia

CREDITS.md

@@ -468,6 +468,8 @@ This page lists all the individual contributions to the project by their author.
   - Fire weapon when Warhead kills something
   - Promotion animation deglobalization
   - Forcing specific weapon by range
+  - Attached effect attach/discard by health
+  - Attached effect with `ExtraWarheads`
 - **NaotoYuuki** - Vertical & meteor trajectory projectile prototypes
 - **handama** - AI script action to `16005 Jump Back To Previous Script`
 - **TaranDahl (航味麻酱)**:

docs/New-or-Enhanced-Logics.md

@@ -8,7 +8,7 @@ This page describes all the engine features that are either new and introduced b
 
 - Similar (but not identical) to [Ares' AttachEffect](https://ares-developers.github.io/Ares-docs/new/attacheffect.html), but with some differences and new features. The largest difference is that here attached effects are explicitly defined types.
   - `Duration` determines how long the effect lasts for. It can be overriden by `DurationOverrides` on TechnoTypes and Warheads.
-    - `Duration.ApplyVersus.Warhead` can multiply the duration by the set warhead's versus against the target's armor type if it's not negative. Can't reduce duration to below 0 by a negative versus.
+    - If `Duration.ApplyVersus.Warhead` is set, it can multiply the duration by the set warhead's versus against the target's armor type if it's not negative. Can't reduce duration to below 0 by a negative versus.
     - If `Duration.ApplyFirepowerMult` set to true, the duration will multiply the invoker's firepower multipliers if it's not negative. Can't reduce duration to below 0 by a negative firepower multiplier.
     - If `Duration.ApplyArmorMultOnTarget` set to true, the duration will divide the target's armor multipliers if it's not negative. This'll also include `ArmorMultiplier` from its own and ignore `ArmorMultiplier.Allow/DisallowWarheads`. Can't reduce duration to below 0 by a negative armor multiplier.
   - `Cumulative`, if set to true, allows the same type of effect to be applied on same object multiple times, up to `Cumulative.MaxCount` number or with no limit if `Cumulative.MaxCount` is a negative number. If the target already has `Cumulative.MaxCount` number of the same effect applied on it, trying to attach another will refresh duration of the attached instance with shortest remaining duration.
@@ -36,6 +36,11 @@ This page describes all the engine features that are either new and introduced b
   - Attached effect can fire off a weapon when expired / removed / object dies by setting `ExpireWeapon`.
     - `ExpireWeapon.TriggerOn` determines the exact conditions upon which the weapon is fired, defaults to `expire` which means only if the effect naturally expires.
     - `ExpireWeapon.CumulativeOnlyOnce`, if set to true, makes it so that `Cumulative=true` attached effects only detonate the weapon once period, instead of once per active instance. On `remove` and `expire` condition this means it will only detonate after last instance has expired or been removed.
+  - Attached effect can allow the TechnoType's weapon to detonate multiple Warheads on impact by listing `ExtraWarheads`. The warheads are detonated at same location as the main one, after it in listed order. This only works in cases where a projectile has been fired by a weapon and still remembers it when it is detonated (due to currently existing technical limitations, this excludes `AirburstWeapon`).
+    - `ExtraWarheads.DamageOverrides` can be used to override the weapon's `Damage` for the extra Warhead detonations. Value from position matching the position from `ExtraWarheads` is used if found, or last listed value if not found. If list is empty, WeaponType `Damage` is used.
+    - `ExtraWarheads.DetonationChances` can be used to customize the chance of each extra Warhead detonation occuring. Value from position matching the position from `ExtraWarheads` is used if found, or last listed value if not found. If list is empty, every extra Warhead detonation is guaranteed to occur.
+    - `ExtraWarheads.FullDetonation` can be used to customize whether or not each individual Warhead is detonated fully (as part of a dummy weapon) or simply deals area damage and applies Phobos' Warhead effects. Value from position matching the position from `ExtraWarheads` is used if found, or last listed value if not found. If list is empty, defaults to true.
+    - Note that the listed Warheads must be listed in `[Warheads]` for them to work.
   - `Tint.Color` & `Tint.Intensity` can be used to set a color tint effect and additive lighting increase/decrease on the object the effect is attached to, respectively.
     - `Tint.VisibleToHouses` can be used to control which houses can see the tint effect.
   - `FirepowerMultiplier`, `ArmorMultiplier`, `SpeedMultiplier` and `ROFMultiplier` can be used to modify the object's firepower, armor strength, movement speed and weapon reload rate, respectively.
@@ -112,6 +117,10 @@ CumulativeAnimations.RestartOnChange=true          ; boolean
 ExpireWeapon=                                      ; WeaponType
 ExpireWeapon.TriggerOn=expire                      ; List of expire weapon trigger condition enumeration (none|expire|remove|death|discard|all)
 ExpireWeapon.CumulativeOnlyOnce=false              ; boolean
+ExtraWarheads=                                     ; List of WarheadTypes
+ExtraWarheads.DamageOverrides=                     ; List of integers
+ExtraWarheads.DetonationChances=                   ; List of floating-point values (percentage or absolute)
+ExtraWarheads.FullDetonation=                      ; List of booleans
 Tint.Color=                                        ; integer - R,G,B
 Tint.Intensity=                                    ; floating point value
 Tint.VisibleToHouses=all                           ; List of Affected House Enumeration (none|owner/self|allies/ally|team|enemies/enemy|all)

docs/Whats-New.md

@@ -370,6 +370,8 @@ New:
 - Customize airstrike targets (by NetsuNegi)
 - Aggressive attack move mission (by CrimRecya)
 - Amphibious access vehicle (by CrimRecya)
+- Attached effect attach/discard by health (by Ollerus)
+- Attached effect with `ExtraWarheads` (by Ollerus)
 
 Vanilla fixes:
 - Fixed sidebar not updating queued unit numbers when adding or removing units when the production is on hold (by CrimRecya)

src/Ext/Bullet/Body.cpp

@@ -154,6 +154,47 @@ void BulletExt::ExtData::InitializeLaserTrails()
 	}
 }
 
+void BulletExt::ExtData::ApplyExtraWarheads(std::vector<WarheadTypeClass*> exWH, std::vector<int> exWHDamageOverrides, std::vector<double> exWHChances, std::vector<bool> exWHFull, CoordStruct* coords, HouseClass* pOwner)
+{
+	auto const pThis = this->OwnerObject();
+	int damage = pThis->WeaponType ? pThis->WeaponType->Damage : 0;
+
+	for (size_t i = 0; i < exWH.size(); i++)
+	{
+		auto const pWH = exWH[i];
+		size_t size = exWHDamageOverrides.size();
+
+		if (size > i)
+			damage = exWHDamageOverrides[i];
+		else if (size > 0)
+			damage = exWHDamageOverrides[size - 1];
+
+		bool detonate = true;
+		size = exWHChances.size();
+
+		if (size > i)
+			detonate = exWHChances[i] >= ScenarioClass::Instance->Random.RandomDouble();
+		else if (size > 0)
+			detonate = exWHChances[size - 1] >= ScenarioClass::Instance->Random.RandomDouble();
+
+		bool isFull = true;
+		size = exWHFull.size();
+
+		if (size > i)
+			isFull = exWHFull[i];
+		else if (size > 0)
+			isFull = exWHFull[size - 1];
+
+		if (!detonate)
+			continue;
+
+		if (isFull)
+			WarheadTypeExt::DetonateAt(pWH, *coords, pThis->Owner, damage, pOwner, pThis->Target);
+		else
+			WarheadTypeExt::ExtMap.Find(pWH)->DamageAreaWithTarget(*coords, damage, pThis->Owner, pWH, true, pOwner, abstract_cast<TechnoClass*>(pThis->Target));
+	}
+}
+
 static inline int SetBuildingFireAnimZAdjust(BuildingClass* pBuilding, int animY)
 {
 	if (pBuilding->GetOccupantCount() > 0)

src/Ext/Bullet/Body.h

@@ -54,6 +54,7 @@ class BulletExt
 		void InterceptBullet(TechnoClass* pSource, WeaponTypeClass* pWeapon);
 		void ApplyRadiationToCell(CellStruct Cell, int Spread, int RadLevel);
 		void InitializeLaserTrails();
+		void ApplyExtraWarheads(std::vector<WarheadTypeClass*> exWH, std::vector<int> exWHDamageOverrides, std::vector<double> exWHChances, std::vector<bool> exWHFull, CoordStruct* coords, HouseClass* pOwner);
 
 	private:
 		template <typename T>

src/Ext/Bullet/Hooks.DetonateLogics.cpp

@@ -297,48 +297,29 @@ DEFINE_HOOK(0x469AA4, BulletClass_Logics_Extras, 0x5)
 	GET(BulletClass*, pThis, ESI);
 	GET_BASE(CoordStruct*, coords, 0x8);
 
-	auto const pOwner = pThis->Owner ? pThis->Owner->Owner : BulletExt::ExtMap.Find(pThis)->FirerHouse;
+	auto const pBulletExt = BulletExt::ExtMap.Find(pThis);
+	auto const pOwner = pThis->Owner ? pThis->Owner->Owner : pBulletExt->FirerHouse;
 
 	// Extra warheads
 	if (pThis->WeaponType)
 	{
 		auto const pWeaponExt = WeaponTypeExt::ExtMap.Find(pThis->WeaponType);
-		int defaultDamage = pThis->WeaponType->Damage;
-
-		for (size_t i = 0; i < pWeaponExt->ExtraWarheads.size(); i++)
-		{
-			auto const pWH = pWeaponExt->ExtraWarheads[i];
-			int damage = defaultDamage;
-			size_t size = pWeaponExt->ExtraWarheads_DamageOverrides.size();
-
-			if (size > i)
-				damage = pWeaponExt->ExtraWarheads_DamageOverrides[i];
-			else if (size > 0)
-				damage = pWeaponExt->ExtraWarheads_DamageOverrides[size - 1];
-
-			bool detonate = true;
-			size = pWeaponExt->ExtraWarheads_DetonationChances.size();
-
-			if (size > i)
-				detonate = pWeaponExt->ExtraWarheads_DetonationChances[i] >= ScenarioClass::Instance->Random.RandomDouble();
-			else if (size > 0)
-				detonate = pWeaponExt->ExtraWarheads_DetonationChances[size - 1] >= ScenarioClass::Instance->Random.RandomDouble();
-
-			bool isFull = true;
-			size = pWeaponExt->ExtraWarheads_FullDetonation.size();
+		pBulletExt->ApplyExtraWarheads(pWeaponExt->ExtraWarheads, pWeaponExt->ExtraWarheads_DamageOverrides, pWeaponExt->ExtraWarheads_DetonationChances, pWeaponExt->ExtraWarheads_FullDetonation, coords, pOwner);
+	}
 
-			if (size > i)
-				isFull = pWeaponExt->ExtraWarheads_FullDetonation[i];
-			else if (size > 0)
-				isFull = pWeaponExt->ExtraWarheads_FullDetonation[size - 1];
+	if (pThis->Owner)
+	{
+		auto const pExt = TechnoExt::ExtMap.Find(pThis->Owner);
 
-			if (!detonate)
-				continue;
+		if (pExt->AE.HasExtraWarheads)
+		{
+			for (auto const& pAE : pExt->AttachedEffects)
+			{
+				auto const pType = pAE->GetType();
 
-			if (isFull)
-				WarheadTypeExt::DetonateAt(pWH, *coords, pThis->Owner, damage, pOwner, pThis->Target);
-			else
-				WarheadTypeExt::ExtMap.Find(pWH)->DamageAreaWithTarget(*coords, damage, pThis->Owner, pWH, true, pOwner, abstract_cast<TechnoClass*>(pThis->Target));
+				if (pType->ExtraWarheads.size() > 0)
+					pBulletExt->ApplyExtraWarheads(pType->ExtraWarheads, pType->ExtraWarheads_DamageOverrides, pType->ExtraWarheads_DetonationChances, pType->ExtraWarheads_FullDetonation, coords, pOwner);
+			}
 		}
 	}
 

src/Ext/Techno/Body.Update.cpp

@@ -1169,6 +1169,8 @@ void TechnoExt::ExtData::RecalculateStatMultipliers()
 	bool reflectsDamage = false;
 	bool hasOnFireDiscardables = false;
 	bool hasRestrictedArmorMultipliers = false;
+	bool hasCritModifiers = false;
+	bool hasExtraWarheads = false;
 
 	for (const auto& attachEffect : this->AttachedEffects)
 	{
@@ -1189,6 +1191,8 @@ void TechnoExt::ExtData::RecalculateStatMultipliers()
 		reflectsDamage |= type->ReflectDamage;
 		hasOnFireDiscardables |= (type->DiscardOn & DiscardCondition::Firing) != DiscardCondition::None;
 		hasRestrictedArmorMultipliers |= (type->ArmorMultiplier != 1.0 && (type->ArmorMultiplier_AllowWarheads.size() > 0 || type->ArmorMultiplier_DisallowWarheads.size() > 0));
+		hasCritModifiers |= (type->Crit_Multiplier != 1.0 || type->Crit_ExtraChance != 0.0);
+		hasExtraWarheads |= type->ExtraWarheads.size() > 0;
 	}
 
 	this->AE.FirepowerMultiplier = firepower;
@@ -1204,6 +1208,8 @@ void TechnoExt::ExtData::RecalculateStatMultipliers()
 	this->AE.ReflectDamage = reflectsDamage;
 	this->AE.HasOnFireDiscardables = hasOnFireDiscardables;
 	this->AE.HasRestrictedArmorMultipliers = hasRestrictedArmorMultipliers;
+	this->AE.HasCritModifiers = hasCritModifiers;
+	this->AE.HasExtraWarheads = hasExtraWarheads;
 
 	if (forceDecloak && pThis->CloakState == CloakState::Cloaked)
 		pThis->Uncloak(true);

src/Ext/WarheadType/Detonate.cpp

@@ -634,6 +634,10 @@ double WarheadTypeExt::ExtData::GetCritChance(TechnoClass* pFirer) const
 		return critChance;
 
 	auto const pExt = TechnoExt::ExtMap.Find(pFirer);
+
+	if (!pExt->AE.HasCritModifiers)
+		return critChance;
+
 	double extraChance = 0.0;
 
 	for (auto& attachEffect : pExt->AttachedEffects)

src/New/Entity/AttachEffectClass.cpp

@@ -46,21 +46,26 @@ AttachEffectClass::AttachEffectClass(AttachEffectTypeClass* pType, TechnoClass*
 
 	this->Duration = this->DurationOverride != 0 ? this->DurationOverride : this->Type->Duration;
 
-	if (this->Duration > 0)
+	if (this->Type->Duration_ApplyVersus_Warhead && this->Duration > 0)
 	{
-		if (this->Type->Duration_ApplyVersus_Warhead)
+		auto const pTechnoExt = TechnoExt::ExtMap.Find(pTechno);
+		auto pArmor = pTechno->GetTechnoType()->Armor;
+
+		if (auto const pShieldData = pTechnoExt->Shield.get())
 		{
-			auto const pArmor = pTechno->Shield && pTechno->Shield->IsActive() ? pTechno->Shield->GetArmor() : pTechno->GetTechnoType()->Armor;
-			this->Duration = Math::max(static_cast<int>(this->Duration * GeneralUtils::GetWarheadVersusArmor(this->Type->Duration_ApplyVersus_Warhead, pArmor), 0));
+			if (pShieldData->IsActive())
+				pArmor = pShieldData->GetArmorType();
 		}
 
-		if (this->Type->Duration_ApplyFirepowerMult && pInvoker)
-			this->Duration = Math::max(static_cast<int>(this->Duration * pInvoker->FirepowerMultiplier * TechnoExt::ExtMap.Find(pInvoker)->AE.FirepowerMultiplier), 0);
-
-		if (this->Type->Duration_ApplyArmorMultOnTarget) // count its own ArmorMultiplier as well
-			this->Duration = Math::max(static_cast<int>(this->Duration / pTechno->ArmorMultiplier / TechnoExt::ExtMap.Find(pTechno)->AE.ArmorMultiplier / this->Type->ArmorMultiplier), 0);
+		this->Duration = Math::max(static_cast<int>(this->Duration * GeneralUtils::GetWarheadVersusArmor(this->Type->Duration_ApplyVersus_Warhead, pArmor)), 0);
 	}
 
+	if (this->Type->Duration_ApplyFirepowerMult && this->Duration > 0 && pInvoker)
+		this->Duration = Math::max(static_cast<int>(this->Duration * pInvoker->FirepowerMultiplier * TechnoExt::ExtMap.Find(pInvoker)->AE.FirepowerMultiplier), 0);
+
+	if (this->Type->Duration_ApplyArmorMultOnTarget && this->Duration > 0) // count its own ArmorMultiplier as well
+		this->Duration = Math::max(static_cast<int>(this->Duration / pTechno->ArmorMultiplier / TechnoExt::ExtMap.Find(pTechno)->AE.ArmorMultiplier / this->Type->ArmorMultiplier), 0);
+
 	AttachEffectClass::Array.emplace_back(this);
 }
 
@@ -399,8 +404,16 @@ void AttachEffectClass::RefreshDuration(int durationOverride)
 
 	if (this->Type->Duration_ApplyVersus_Warhead)
 	{
-		auto const pArmor = this->Techno->Shield && this->Techno->Shield->IsActive() ? this->Techno->Shield->GetArmor() : this->Techno->GetTechnoType()->Armor;
-		this->Duration = Math::max(static_cast<int>(this->Duration * GeneralUtils::GetWarheadVersusArmor(this->Type->Duration_ApplyVersus_Warhead, pArmor), 0));
+		auto const pTechnoExt = TechnoExt::ExtMap.Find(this->Techno);
+		auto pArmor = this->Techno->GetTechnoType()->Armor;
+
+		if (auto const pShieldData = pTechnoExt->Shield.get())
+		{
+			if (pShieldData->IsActive())
+				pArmor = pShieldData->GetArmorType();
+		}
+
+		this->Duration = Math::max(static_cast<int>(this->Duration * GeneralUtils::GetWarheadVersusArmor(this->Type->Duration_ApplyVersus_Warhead, pArmor)), 0);
 	}
 
 	if (this->Type->Duration_ApplyFirepowerMult && this->Duration > 0 && this->Invoker)

src/New/Entity/AttachEffectClass.h

@@ -96,6 +96,8 @@ struct AttachEffectTechnoProperties
 	bool ReflectDamage;
 	bool HasOnFireDiscardables;
 	bool HasRestrictedArmorMultipliers;
+	bool HasCritModifiers;
+	bool HasExtraWarheads;
 
 	AttachEffectTechnoProperties() :
 		FirepowerMultiplier { 1.0 }

src/New/Type/AttachEffectTypeClass.cpp

@@ -124,6 +124,11 @@ void AttachEffectTypeClass::LoadFromINI(CCINIClass* pINI)
 	this->ExpireWeapon_TriggerOn.Read(exINI, pSection, "ExpireWeapon.TriggerOn");
 	this->ExpireWeapon_CumulativeOnlyOnce.Read(exINI, pSection, "ExpireWeapon.CumulativeOnlyOnce");
 
+	this->ExtraWarheads.Read(exINI, pSection, "ExtraWarheads");
+	this->ExtraWarheads_DamageOverrides.Read(exINI, pSection, "ExtraWarheads.DamageOverrides");
+	this->ExtraWarheads_DetonationChances.Read(exINI, pSection, "ExtraWarheads.DetonationChances");
+	this->ExtraWarheads_FullDetonation.Read(exINI, pSection, "ExtraWarheads.FullDetonation");
+
 	this->Tint_Color.Read(exINI, pSection, "Tint.Color");
 	this->Tint_Intensity.Read(exINI, pSection, "Tint.Intensity");
 	this->Tint_VisibleToHouses.Read(exINI, pSection, "Tint.VisibleToHouses");
@@ -198,6 +203,10 @@ void AttachEffectTypeClass::Serialize(T& Stm)
 		.Process(this->ExpireWeapon)
 		.Process(this->ExpireWeapon_TriggerOn)
 		.Process(this->ExpireWeapon_CumulativeOnlyOnce)
+		.Process(this->ExtraWarheads)
+		.Process(this->ExtraWarheads_DamageOverrides)
+		.Process(this->ExtraWarheads_DetonationChances)
+		.Process(this->ExtraWarheads_FullDetonation)
 		.Process(this->Tint_Color)
 		.Process(this->Tint_Intensity)
 		.Process(this->Tint_VisibleToHouses)

src/New/Type/AttachEffectTypeClass.h

@@ -66,6 +66,10 @@ class AttachEffectTypeClass final : public Enumerable<AttachEffectTypeClass>
 	Valueable<WeaponTypeClass*> ExpireWeapon;
 	Valueable<ExpireWeaponCondition> ExpireWeapon_TriggerOn;
 	Valueable<bool> ExpireWeapon_CumulativeOnlyOnce;
+	ValueableVector<WarheadTypeClass*> ExtraWarheads;
+	ValueableVector<int> ExtraWarheads_DamageOverrides;
+	ValueableVector<double> ExtraWarheads_DetonationChances;
+	ValueableVector<bool> ExtraWarheads_FullDetonation;
 	Nullable<ColorStruct> Tint_Color;
 	Valueable<double> Tint_Intensity;
 	Valueable<AffectedHouse> Tint_VisibleToHouses;
@@ -127,6 +131,10 @@ class AttachEffectTypeClass final : public Enumerable<AttachEffectTypeClass>
 		, ExpireWeapon {}
 		, ExpireWeapon_TriggerOn { ExpireWeaponCondition::Expire }
 		, ExpireWeapon_CumulativeOnlyOnce { false }
+		, ExtraWarheads {}
+		, ExtraWarheads_DamageOverrides {}
+		, ExtraWarheads_DetonationChances {}
+		, ExtraWarheads_FullDetonation {}
 		, Tint_Color {}
 		, Tint_Intensity { 0.0 }
 		, Tint_VisibleToHouses { AffectedHouse::All }