[Customized] Extended gattling rate down logic (#1469)

- Now you can customize some effects of RateDown.
- `RateDown.Delay` controls the delay before using `RateDown` to reduce
the gattling value.
- `RateDown.Reset` controls whether to reset the gattling value directly
when the techno has no target or changes targets.
- `RateDown.Cover.Value` replaces the original `RateDown` when techno's
ammo is lower than `RateDown.Cover.AmmoBelow`.

In `rulesmd.ini`:
```ini
[SOMETECHNO]                  ; TechnoType, `IsGattling=yes`
RateDown.Delay=0              ; integer, game frames
RateDown.Reset=false          ; boolean
RateDown.Cover.Value=0        ; integer
RateDown.Cover.AmmoBelow=-2   ; integer
```

Author: CrimRecya

CREDITS.md

@@ -390,6 +390,7 @@ This page lists all the individual contributions to the project by their author.
   - Enhanced Bombard trajectory
   - No turret unit turn to the target
   - Damage multiplier for different houses
+  - Extended gattling rate down logic
 - **Ollerus**
   - Build limit group enhancement
   - Customizable rocker amplitude

docs/New-or-Enhanced-Logics.md

@@ -1577,6 +1577,22 @@ Convert.HumanToComputer=    ; TechnoType
 Convert.ComputerToHuman=    ; TechnoType
 ```
 
+### Extended gattling rate down logic
+
+- Now you can customize some effects of RateDown.
+  - `RateDown.Delay` controls the delay before using `RateDown` to reduce the gattling value.
+  - `RateDown.Reset` controls whether to reset the gattling value directly when the techno has no target or changes targets.
+  - `RateDown.Cover.Value` replaces the original `RateDown` when techno's ammo is lower than `RateDown.Cover.AmmoBelow`.
+
+In `rulesmd.ini`:
+```ini
+[SOMETECHNO]                  ; TechnoType, `IsGattling=yes`
+RateDown.Delay=0              ; integer, game frames
+RateDown.Reset=false          ; boolean
+RateDown.Cover.Value=0        ; integer
+RateDown.Cover.AmmoBelow=-2   ; integer
+```
+
 ## Terrain
 
 ### Destroy animation & sound

docs/Whats-New.md

@@ -327,6 +327,7 @@ New:
 - No turret unit turn to the target (by CrimRecya & TaranDahl)
 - Damage multiplier for different houses (by CrimRecya)
 - Customizable duration for electric bolts (by Starkku)
+- Extended gattling rate down logic (by CrimRecya)
 
 Vanilla fixes:
 - Prevent the units with locomotors that cause problems from entering the tank bunker (by TaranDahl)

src/Ext/Techno/Body.Update.cpp

@@ -43,6 +43,7 @@ void TechnoExt::ExtData::OnEarlyUpdate()
 	this->UpdateLaserTrails();
 	this->DepletedAmmoActions();
 	this->UpdateAttachEffects();
+	this->UpdateGattlingRateDownReset();
 }
 
 void TechnoExt::ExtData::ApplyInterceptor()
@@ -614,6 +615,25 @@ void TechnoExt::ExtData::UpdateMindControlAnim()
 	}
 }
 
+void TechnoExt::ExtData::UpdateGattlingRateDownReset()
+{
+	const auto pTypeExt = this->TypeExtData;
+
+	if (pTypeExt->OwnerObject()->IsGattling)
+	{
+		const auto pThis = this->OwnerObject();
+
+		if (pTypeExt->RateDown_Reset && (!pThis->Target || this->LastTargetID != pThis->Target->UniqueID))
+		{
+			this->LastTargetID = pThis->Target ? pThis->Target->UniqueID : 0xFFFFFFFF;
+			pThis->GattlingValue = 0;
+			pThis->CurrentGattlingStage = 0;
+			this->AccumulatedGattlingValue = 0;
+			this->ShouldUpdateGattlingValue = false;
+		}
+	}
+}
+
 void TechnoExt::ApplyGainedSelfHeal(TechnoClass* pThis)
 {
 	if (!RulesExt::Global()->GainSelfHealAllowMultiplayPassive && pThis->Owner->Type->MultiplayPassive)

src/Ext/Techno/Body.cpp

@@ -555,6 +555,9 @@ void TechnoExt::ExtData::Serialize(T& Stm)
 		.Process(this->WHAnimRemainingCreationInterval)
 		.Process(this->FiringObstacleCell)
 		.Process(this->IsDetachingForCloak)
+		.Process(this->LastTargetID)
+		.Process(this->AccumulatedGattlingValue)
+		.Process(this->ShouldUpdateGattlingValue)
 		.Process(this->OriginalPassengerOwner)
 		.Process(this->HasRemainingWarpInDelay)
 		.Process(this->LastWarpInDelay)

src/Ext/Techno/Body.h

@@ -52,6 +52,9 @@ class TechnoExt
 		bool CanCurrentlyDeployIntoBuilding; // Only set on UnitClass technos with DeploysInto set in multiplayer games, recalculated once per frame so no need to serialize.
 		CellClass* FiringObstacleCell; // Set on firing if there is an obstacle cell between target and techno, used for updating WaveClass target etc.
 		bool IsDetachingForCloak; // Used for checking animation detaching, set to true before calling Detach_All() on techno when this anim is attached to and to false after when cloaking only.
+		DWORD LastTargetID;
+		int AccumulatedGattlingValue;
+		bool ShouldUpdateGattlingValue;
 
 		// Used for Passengers.SyncOwner.RevertOnExit instead of TechnoClass::InitialOwner / OriginallyOwnedByHouse,
 		// as neither is guaranteed to point to the house the TechnoClass had prior to entering transport and cannot be safely overridden.
@@ -92,6 +95,9 @@ class TechnoExt
 			, CanCurrentlyDeployIntoBuilding { false }
 			, FiringObstacleCell {}
 			, IsDetachingForCloak { false }
+			, LastTargetID { 0xFFFFFFFF }
+			, AccumulatedGattlingValue { 0 }
+			, ShouldUpdateGattlingValue { false }
 			, OriginalPassengerOwner {}
 			, HasRemainingWarpInDelay { false }
 			, LastWarpInDelay { 0 }
@@ -112,6 +118,7 @@ class TechnoExt
 		void UpdateTypeData(TechnoTypeClass* currentType);
 		void UpdateLaserTrails();
 		void UpdateAttachEffects();
+		void UpdateGattlingRateDownReset();
 		void UpdateCumulativeAttachEffects(AttachEffectTypeClass* pAttachEffectType, AttachEffectClass* pRemoved = nullptr);
 		void RecalculateStatMultipliers();
 		void UpdateTemporal();

src/Ext/Techno/Hooks.Misc.cpp

@@ -338,6 +338,108 @@ DEFINE_HOOK(0x74691D, UnitClass_UpdateDisguise_EMP, 0x6)
 
 #pragma endregion
 
+#pragma region ExtendedGattlingRateDown
+
+DEFINE_HOOK(0x70DE40, BuildingClass_sub_70DE40_GattlingRateDownDelay, 0xA)
+{
+	enum { Return = 0x70DE62 };
+
+	GET(BuildingClass* const, pThis, ECX);
+	GET_STACK(int, rateDown, STACK_OFFSET(0x0, 0x4));
+
+	const auto pExt = TechnoExt::ExtMap.Find(pThis);
+	const auto pTypeExt = pExt->TypeExtData;
+
+	if (pTypeExt->RateDown_Delay < 0)
+		return Return;
+
+	++pExt->AccumulatedGattlingValue;
+	auto remain = pExt->AccumulatedGattlingValue;
+
+	if (!pExt->ShouldUpdateGattlingValue)
+		remain -= pTypeExt->RateDown_Delay;
+
+	if (remain <= 0)
+		return Return;
+
+	// Time's up
+	pExt->AccumulatedGattlingValue = 0;
+	pExt->ShouldUpdateGattlingValue = true;
+
+	if (pThis->Ammo <= pTypeExt->RateDown_Cover_AmmoBelow)
+		rateDown = pTypeExt->RateDown_Cover_Value;
+
+	if (!rateDown)
+	{
+		pThis->GattlingValue = 0;
+		return Return;
+	}
+
+	auto newValue = pThis->GattlingValue;
+	newValue -= (rateDown * remain);
+	pThis->GattlingValue = (newValue <= 0) ? 0 : newValue;
+	return Return;
+}
+
+DEFINE_HOOK(0x70DE70, TechnoClass_sub_70DE70_GattlingRateDownReset, 0x5)
+{
+	GET(TechnoClass* const, pThis, ECX);
+
+	const auto pExt = TechnoExt::ExtMap.Find(pThis);
+	pExt->AccumulatedGattlingValue = 0;
+	pExt->ShouldUpdateGattlingValue = false;
+
+	return 0;
+}
+
+DEFINE_HOOK(0x70E01E, TechnoClass_sub_70E000_GattlingRateDownDelay, 0x6)
+{
+	enum { SkipGameCode = 0x70E04D };
+
+	GET(TechnoClass* const, pThis, ESI);
+	GET_STACK(int, rateMult, STACK_OFFSET(0x10, 0x4));
+
+	const auto pExt = TechnoExt::ExtMap.Find(pThis);
+	const auto pTypeExt = pExt->TypeExtData;
+
+	if (pTypeExt->RateDown_Delay < 0)
+		return SkipGameCode;
+
+	pExt->AccumulatedGattlingValue += rateMult;
+	auto remain = pExt->AccumulatedGattlingValue;
+
+	if (!pExt->ShouldUpdateGattlingValue)
+		remain -= pTypeExt->RateDown_Delay;
+
+	if (remain <= 0 && rateMult)
+		return SkipGameCode;
+
+	// Time's up
+	pExt->AccumulatedGattlingValue = 0;
+	pExt->ShouldUpdateGattlingValue = true;
+
+	if (!rateMult)
+	{
+		pThis->GattlingValue = 0;
+		return SkipGameCode;
+	}
+
+	const auto rateDown = (pThis->Ammo <= pTypeExt->RateDown_Cover_AmmoBelow) ? pTypeExt->RateDown_Cover_Value.Get() : pTypeExt->OwnerObject()->RateDown;
+
+	if (!rateDown)
+	{
+		pThis->GattlingValue = 0;
+		return SkipGameCode;
+	}
+
+	auto newValue = pThis->GattlingValue;
+	newValue -= (rateDown * remain);
+	pThis->GattlingValue = (newValue <= 0) ? 0 : newValue;
+	return SkipGameCode;
+}
+
+#pragma endregion
+
 #pragma region NoTurretUnitAlwaysTurnToTarget
 
 DEFINE_HOOK(0x7410BB, UnitClass_GetFireError_CheckFacingError, 0x8)

src/Ext/TechnoType/Body.cpp

@@ -464,6 +464,11 @@ void TechnoTypeExt::ExtData::LoadFromINIFile(CCINIClass* const pINI)
 	this->BuildLimitGroup_ExtraLimit_MaxCount.Read(exINI, pSection, "BuildLimitGroup.ExtraLimit.MaxCount");
 	this->BuildLimitGroup_ExtraLimit_MaxNum.Read(exINI, pSection, "BuildLimitGroup.ExtraLimit.MaxNum");
 
+	this->RateDown_Delay.Read(exINI, pSection, "RateDown.Delay");
+	this->RateDown_Reset.Read(exINI, pSection, "RateDown.Reset");
+	this->RateDown_Cover_Value.Read(exINI, pSection, "RateDown.Cover.Value");
+	this->RateDown_Cover_AmmoBelow.Read(exINI, pSection, "RateDown.Cover.AmmoBelow");
+
 	this->NoTurret_TrackTarget.Read(exINI, pSection, "NoTurret.TrackTarget");
 
 	this->Wake.Read(exINI, pSection, "Wake");
@@ -849,6 +854,11 @@ void TechnoTypeExt::ExtData::Serialize(T& Stm)
 		.Process(this->BuildLimitGroup_ExtraLimit_MaxCount)
 		.Process(this->BuildLimitGroup_ExtraLimit_MaxNum)
 
+		.Process(this->RateDown_Delay)
+		.Process(this->RateDown_Reset)
+		.Process(this->RateDown_Cover_Value)
+		.Process(this->RateDown_Cover_AmmoBelow)
+
 		.Process(this->NoTurret_TrackTarget)
 
 		.Process(this->Wake)

src/Ext/TechnoType/Body.h

@@ -233,6 +233,11 @@ class TechnoTypeExt
 		ValueableVector<int> BuildLimitGroup_ExtraLimit_MaxCount;
 		Valueable<int> BuildLimitGroup_ExtraLimit_MaxNum;
 
+		Valueable<int> RateDown_Delay;
+		Valueable<bool> RateDown_Reset;
+		Valueable<int> RateDown_Cover_Value;
+		Valueable<int> RateDown_Cover_AmmoBelow;
+
 		Nullable<bool> NoTurret_TrackTarget;
 
 		Nullable<AnimTypeClass*> Wake;
@@ -471,6 +476,11 @@ class TechnoTypeExt
 			, BuildLimitGroup_ExtraLimit_MaxCount {}
 			, BuildLimitGroup_ExtraLimit_MaxNum { 0 }
 
+			, RateDown_Delay { 0 }
+			, RateDown_Reset { false }
+			, RateDown_Cover_Value { 0 }
+			, RateDown_Cover_AmmoBelow { -2 }
+
 			, NoTurret_TrackTarget {}
 
 			, Wake { }