Mastermind Overload characteristic deharcoded (#549)

```ini
[MASTERMIND]
Overload.Count=               ; list of integer, default to [CombatDamage]->OverloadCount
Overload.Damage=              ; list of integer, default to [CombatDamage]->OverloadDamage
Overload.Frames=              ; list of integer, default to [CombatDamage]->OverloadFrames
Overload.DeathSound=          ; Sound entry, default to [AudioVisual]->MasterMindOverloadDeathSound
Overload.ParticleSys=         ; ParticleSystemType, default to [CombatDamage]->DefaultSparkSystem
Overload.ParticleSysCount=5   ; integer
MindControlLink.VisibleToHouse=all ; Affected House Enumeration (none|owner/self|allies/ally|team|enemies/enemy|all)
```

---------

Co-authored-by: Coronia <[email protected]>
Co-authored-by: Trsdy <[email protected]>
Co-authored-by: Starkku <[email protected]>

Author: 4 people

CREDITS.md

@@ -117,6 +117,7 @@ This page lists all the individual contributions to the project by their author.
   - Ares detection and integration
   - Help with custom locomotors
   - Extension class optimization
+  - Overload characteristic dehardcoded
 - **FS-21**:
   - Dump Object Info enhancements
   - `Powered.KillSpawns`

docs/New-or-Enhanced-Logics.md

@@ -1518,12 +1518,14 @@ AutoDeath.TechnosExist.Houses=owner            ; Affected House Enumeration (non
 *Multiple Mind Control unit auto-releases the first victim in [Fantasy ADVENTURE](https://www.moddb.com/mods/fantasy-adventure)*
 
 - Mind controllers now can have the upper limit of the control distance. Tag values greater than 0 will activate this feature.
+- Mind controllers now can decide which house can see the link drawn between itself and the controlled units.
 - Mind controllers with multiple controlling slots can now release the first controlled unit when they have reached the control limit and are ordered to control a new target.
 
 In `rulesmd.ini`:
 ```ini
 [SOMETECHNO]                          ; TechnoType
 MindControlRangeLimit=-1.0            ; floating point value
+MindControlLink.VisibleToHouse=all    ; Affected House Enumeration (none|owner/self|allies/ally|team|enemies/enemy|all)
 MultiMindControl.ReleaseVictim=false  ; boolean
 ```
 
@@ -1561,6 +1563,22 @@ NoReload.UnderEMP=       ; boolean
 NoReload.Temporal=       ; boolean
 ```
 
+### Overload characteristic dehardcoded
+
+- It is now possible to customize `Overload` behaviors for a TechnoType with `InfiniteMindControl=yes` weapon.
+
+In `rulesmd.ini`:
+```ini
+
+[SOMETECHNO]                  ; TechnoType
+Overload.Count=               ; list of integer, default to [CombatDamage] -> OverloadCount
+Overload.Damage=              ; list of integer, default to [CombatDamage] -> OverloadDamage
+Overload.Frames=              ; list of integer, default to [CombatDamage] -> OverloadFrames
+Overload.DeathSound=          ; Sound entry, default to [AudioVisual] -> MasterMindOverloadDeathSound
+Overload.ParticleSys=         ; ParticleSystemType, default to [CombatDamage] -> DefaultSparkSystem
+Overload.ParticleSysCount=5   ; integer
+```
+
 ### Promoted Spawns
 
 ![image](_static/images/promotedspawns-01.gif)

docs/Whats-New.md

@@ -360,6 +360,7 @@ New:
 - [Removed dependency on `blowfish.dll`](Miscellanous.md#blowfish-dependency) (by ZivDero)
 - [Warhead that can not kill](New-or-Enhanced-Logics.md#warhead-that-cannot-kill) (by FS-21)
 - [Customize parasite culling targets](Fixed-or-Improved-Logics.md#customizing-parasite-culling-targets) (by NetsuNegi)
+- [Overload characteristic dehardcoded](New-or-Enhanced-Logics.md#overload-characteristic-dehardcoded) (by Otamaa)
 
 Vanilla fixes:
 - Prevent the units with locomotors that cause problems from entering the tank bunker (by TaranDahl)

src/Ext/CaptureManager/Hooks.cpp

@@ -1,5 +1,9 @@
 #include "Body.h"
 
+#include <ParticleSystemClass.h>
+#include <Utilities/Macro.h>
+#include <Utilities/EnumFunctions.h>
+
 DEFINE_HOOK(0x471D40, CaptureManagerClass_CaptureUnit, 0x7)
 {
 	GET(CaptureManagerClass*, pThis, ECX);
@@ -49,3 +53,117 @@ DEFINE_HOOK(0x519F71, InfantryClass_UpdatePosition_BeforeBuildingChangeHouse, 0x
 
 	return 0;
 }
+
+static void __stdcall DrawALinkTo(CoordStruct nFrom, CoordStruct nTo, ColorStruct color)
+{
+	JMP_STD(0x704E40);
+}
+
+DEFINE_HOOK(0x4721E6, CaptureManagerClass_DrawLinkToVictim, 0x6)
+{
+	GET(CaptureManagerClass*, pThis, EDI);
+	GET(TechnoClass*, pVictim, ECX);
+	GET_STACK(int, nNodeCount, STACK_OFFSET(0x30, -0x1C));
+
+	auto const pAttacker = pThis->Owner;
+	const auto pExt = TechnoTypeExt::ExtMap.Find(pAttacker->GetTechnoType());
+
+	if (EnumFunctions::CanTargetHouse(pExt->MindControlLink_VisibleToHouse, pAttacker->Owner, HouseClass::CurrentPlayer))
+	{
+		auto nVictimCoord = pVictim->Location;
+		nVictimCoord.Z += pVictim->GetTechnoType()->LeptonMindControlOffset;
+		auto nFLH = pAttacker->GetFLH(-1 - nNodeCount % 5, CoordStruct::Empty);
+		DrawALinkTo(nFLH, nVictimCoord, pAttacker->Owner->Color);
+	}
+
+	R->EBP(nNodeCount);
+	return 0x472287;
+}
+
+void __fastcall CaptureManagerClass_Overload_AI(CaptureManagerClass* pThis, void* _)
+{
+	auto const pOwner = pThis->Owner;
+	auto const pOwnerTypeExt = TechnoTypeExt::ExtMap.Find(pOwner->GetTechnoType());
+
+	if (!pOwnerTypeExt) // we cant find type Ext for this , just return to original function !
+	{
+		pThis->HandleOverload();
+		return;
+	}
+
+	if (pThis->InfiniteMindControl)
+	{
+		auto const pRules = RulesClass::Instance;
+
+		if (pThis->OverloadPipState > 0)
+			--pThis->OverloadPipState;
+
+		if (pThis->OverloadDamageDelay <= 0)
+		{
+			auto const& OverloadCount = pOwnerTypeExt->Overload_Count.GetElements(pRules->OverloadCount);
+
+			if (OverloadCount.empty())
+				return;
+
+			int nCurIdx = 0;
+			int const nNodeCount = pThis->ControlNodes.Count;
+
+			for (int i = 0; i < (int)(OverloadCount.size()); ++i)
+			{
+				if (nNodeCount > OverloadCount[i])
+					nCurIdx = i + 1; // select the index !
+			}
+
+			// prevent nCurIdx selecting out of bound index !
+			constexpr auto FixIdx = [](const Iterator<int>& iter, int nInput) {
+				return iter.empty() ? 0 : iter[nInput >= (int)iter.size() ? (int)iter.size() - 1 : nInput];
+			};
+
+			auto const& nOverloadfr = pOwnerTypeExt->Overload_Frames.GetElements(pRules->OverloadFrames);
+			pThis->OverloadDamageDelay = FixIdx(nOverloadfr, nCurIdx);
+
+			auto const& nOverloadDmg = pOwnerTypeExt->Overload_Damage.GetElements(pRules->OverloadDamage);
+			auto nDamage = FixIdx(nOverloadDmg, nCurIdx);
+
+			if (nDamage <= 0)
+			{
+				pThis->OverloadDeathSoundPlayed = false;
+			}
+			else
+			{
+				pThis->OverloadPipState = 10;
+				pOwner->ReceiveDamage(&nDamage, 0, pRules->C4Warhead, 0, 0, 0, 0);
+
+				if (!pThis->OverloadDeathSoundPlayed)
+				{
+					VocClass::PlayAt(pOwnerTypeExt->Overload_DeathSound.Get(pRules->MasterMindOverloadDeathSound), pOwner->Location, 0);
+					pThis->OverloadDeathSoundPlayed = true;
+				}
+
+				if (auto const pParticle = pOwnerTypeExt->Overload_ParticleSys.Get(pRules->DefaultSparkSystem))
+				{
+					for (int i = pOwnerTypeExt->Overload_ParticleSysCount; i > 0; --i)
+					{
+						auto const nRandomY = ScenarioClass::Instance->Random.RandomRanged(-200, 200);
+						auto const nRamdomX = ScenarioClass::Instance->Random.RandomRanged(-200, 200);
+						CoordStruct nParticleCoord{ pOwner->Location.X + nRamdomX, nRandomY + pOwner->Location.Y, pOwner->Location.Z + 100 };
+						GameCreate<ParticleSystemClass>(pParticle, nParticleCoord, nullptr, nullptr, CoordStruct::Empty, nullptr);
+					}
+				}
+
+				if (nCurIdx > 0 && pOwner->IsAlive && pOwner->Health > 0 && !pOwner->InLimbo)
+				{
+					double const nBase = (nCurIdx != 1) ? 0.015 : 0.03;
+					double const nCopied_base = (ScenarioClass::Instance->Random.RandomRanged(0, 100) < 50) ? -nBase : nBase;
+					pOwner->RockingSidewaysPerFrame = (float)nCopied_base;
+				}
+			}
+		}
+		else
+		{
+			--pThis->OverloadDamageDelay;
+		}
+	}
+}
+
+DEFINE_FUNCTION_JUMP(CALL, 0x6FA730, CaptureManagerClass_Overload_AI);

src/Ext/TechnoType/Body.cpp

@@ -275,6 +275,7 @@ void TechnoTypeExt::ExtData::LoadFromINIFile(CCINIClass* const pINI)
 	this->UIDescription.Read(exINI, pSection, "UIDescription");
 	this->LowSelectionPriority.Read(exINI, pSection, "LowSelectionPriority");
 	this->MindControlRangeLimit.Read(exINI, pSection, "MindControlRangeLimit");
+	this->MindControlLink_VisibleToHouse.Read(exINI, pSection, "MindControlLink.VisibleToHouse");
 	this->FactoryPlant_Multiplier.Read(exINI, pSection, "FactoryPlant.Multiplier");
 
 	this->Spawner_LimitRange.Read(exINI, pSection, "Spawner.LimitRange");
@@ -527,6 +528,13 @@ void TechnoTypeExt::ExtData::LoadFromINIFile(CCINIClass* const pINI)
 	this->Promote_VeteranAnimation.Read(exINI, pSection, "Promote.VeteranAnimation");
 	this->Promote_EliteAnimation.Read(exINI, pSection, "Promote.EliteAnimation");
 
+	this->Overload_Count.Read(exINI, pSection, "Overload.Count");
+	this->Overload_Damage.Read(exINI, pSection, "Overload.Damage");
+	this->Overload_Frames.Read(exINI, pSection, "Overload.Frames");
+	this->Overload_DeathSound.Read(exINI, pSection, "Overload.DeathSound");
+	this->Overload_ParticleSys.Read(exINI, pSection, "Overload.ParticleSys");
+	this->Overload_ParticleSysCount.Read(exINI, pSection, "Overload.ParticleSysCount");
+
 	// Ares 0.2
 	this->RadarJamRadius.Read(exINI, pSection, "RadarJamRadius");
 
@@ -699,6 +707,7 @@ void TechnoTypeExt::ExtData::Serialize(T& Stm)
 		.Process(this->UIDescription)
 		.Process(this->LowSelectionPriority)
 		.Process(this->MindControlRangeLimit)
+		.Process(this->MindControlLink_VisibleToHouse)
 		.Process(this->FactoryPlant_Multiplier)
 
 		.Process(this->InterceptorType)
@@ -972,6 +981,13 @@ void TechnoTypeExt::ExtData::Serialize(T& Stm)
 
 		.Process(this->Promote_VeteranAnimation)
 		.Process(this->Promote_EliteAnimation)
+
+		.Process(this->Overload_Count)
+		.Process(this->Overload_Damage)
+		.Process(this->Overload_Frames)
+		.Process(this->Overload_DeathSound)
+		.Process(this->Overload_ParticleSys)
+		.Process(this->Overload_ParticleSysCount)
 		;
 }
 void TechnoTypeExt::ExtData::LoadFromStream(PhobosStreamReader& Stm)

src/Ext/TechnoType/Body.h

@@ -14,7 +14,7 @@
 #include <New/Type/Affiliated/DroppodTypeClass.h>
 
 class Matrix3D;
-
+class ParticleSystemTypeClass;
 class TechnoTypeExt
 {
 public:
@@ -35,6 +35,7 @@ class TechnoTypeExt
 		Nullable<int> DesignatorRange;
 		Valueable<float> FactoryPlant_Multiplier;
 		Valueable<Leptons> MindControlRangeLimit;
+		Valueable<AffectedHouse> MindControlLink_VisibleToHouse;
 
 		std::unique_ptr<InterceptorTypeClass> InterceptorType;
 
@@ -321,6 +322,12 @@ class TechnoTypeExt
 		Valueable<bool> SuppressKillWeapons;
 		ValueableVector<WeaponTypeClass*> SuppressKillWeapons_Types;
 
+		NullableVector<int> Overload_Count;
+		NullableVector<int> Overload_Damage;
+		NullableVector<int> Overload_Frames;
+		NullableIdx<VocClass> Overload_DeathSound;
+		Nullable<ParticleSystemTypeClass*> Overload_ParticleSys;
+		Valueable<int> Overload_ParticleSysCount;
 
 		ExtData(TechnoTypeClass* OwnerObject) : Extension<TechnoTypeClass>(OwnerObject)
 			, HealthBar_Hide { false }
@@ -332,6 +339,7 @@ class TechnoTypeExt
 			, DesignatorRange { }
 			, FactoryPlant_Multiplier { 1.0 }
 			, MindControlRangeLimit {}
+			, MindControlLink_VisibleToHouse{ AffectedHouse::All }
 
 			, InterceptorType { nullptr }
 
@@ -597,6 +605,13 @@ class TechnoTypeExt
 
 			, Promote_VeteranAnimation { }
 			, Promote_EliteAnimation { }
+
+			, Overload_Count {}
+			, Overload_Damage {}
+			, Overload_Frames {}
+			, Overload_DeathSound {}
+			, Overload_ParticleSys {}
+			, Overload_ParticleSysCount { 5 }
 		{ }
 
 		virtual ~ExtData() = default;