Infantry support for IsGattling (#1689)

![加特林](https://github.com/user-attachments/assets/27492c16-cc6b-4db2-b5d9-be9363a72b95)
Infantry support `IsGattling=yes`.

---------
让步兵支持`IsGattling=yes`。

Author: Fly-Star-him

CREDITS.md

@@ -369,6 +369,7 @@ This page lists all the individual contributions to the project by their author.
   - Second weapon with `ElectricAssault=yes` will not unconditionally attack your building with `Overpowerable=yes`
   - Fix the issue where some units crashed after the deployment transformation
   - Turretless vehicles with `Voxel=no` support use `FireUp` like infantry
+  - Infantry support `IsGattling=yes`
 - **NetsuNegi**:
   - Forbidding parallel AI queues by type
   - Jumpjet crash speed fix when crashing onto building

Phobos.vcxproj

@@ -18,6 +18,7 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="src\Ext\Infantry\Hooks.Firing.cpp" />
     <ClCompile Include="src\Ext\Unit\Hooks.Firing.cpp" />
     <ClCompile Include="src\New\Type\Affiliated\CreateUnitTypeClass.cpp" />
     <ClCompile Include="src\Blowfish\blowfish.cpp" />

docs/Fixed-or-Improved-Logics.md

@@ -229,6 +229,7 @@ This page describes all ingame logics that are fixed or improved in Phobos witho
 - Fixed an issue where airstrike flare line drawn to target at lower elevation would clip.
 - Fixed the bug that uncontrolled scatter when elite techno attacked by aircraft or some unit try crush it.
 - Second weapon with `ElectricAssault=yes` will not unconditionally attack your building with `Overpowerable=yes`.
+- Infantry support `IsGattling=yes`.
 
 ## Fixes / interactions with other extensions
 

docs/Whats-New.md

@@ -389,6 +389,7 @@ New:
 - [Customize whether `Crater=yes` animation would destroy tiberium](Fixed-or-Improved-Logics.md#customize-whether-crater-yes-animation-would-destroy-tiberium) (by TaranDahl)
 - Weapon target filtering by health percentage (by NetsuNegi)
 - [Turretless vehicles with `Voxel=no` support use `FireUp` like infantry](New-or-Enhanced-Logics.md#turretless-shape-vehicle-fireup) (by FlyStar)
+- Infantry support `IsGattling=yes` (by FlyStar)
 
 Vanilla fixes:
 - Fixed sidebar not updating queued unit numbers when adding or removing units when the production is on hold (by CrimRecya)

src/Ext/Building/Hooks.cpp

@@ -21,7 +21,6 @@ DEFINE_HOOK(0x43FE69, BuildingClass_AI, 0xA)
 	auto const pExt = BuildingExt::ExtMap.Find(pThis);
 	pExt->DisplayIncomeString();
 	pExt->ApplyPoweredKillSpawns();
-	pExt->TechnoExtData->UpdateGattlingRateDownReset();
 
 	return 0;
 }

src/Ext/Infantry/Hooks.Firing.cpp

@@ -0,0 +1,170 @@
+#include <Helpers/Macro.h>
+#include <InfantryClass.h>
+
+#include <Ext/Techno/Body.h>
+#include <Ext/WeaponType/Body.h>
+
+namespace FiringAITemp
+{
+	bool canFire;
+	int weaponIndex;
+	bool isSecondary;
+	WeaponTypeClass* WeaponType;
+	FireError fireError;
+}
+
+DEFINE_HOOK(0x520AD2, InfantryClass_FiringAI_NoTarget, 0x7)
+{
+	GET(InfantryClass*, pThis, EBP);
+
+	if (pThis->Type->IsGattling)
+		pThis->GattlingRateDown(1);
+
+	FiringAITemp::canFire = false;
+	return 0;
+}
+
+DEFINE_HOOK(0x5206D2, InfantryClass_FiringAI_SetContext, 0x6)
+{
+	GET(InfantryClass*, pThis, EBP);
+	GET(int, WeaponIndex, EDI);
+	enum { SkipGameCode = 0x5209A6 };
+
+	auto const pWeapon = pThis->GetWeapon(WeaponIndex)->WeaponType;
+
+	if (!pWeapon)
+	{
+		if (pThis->Type->IsGattling)
+			pThis->GattlingRateDown(1);
+
+		R->AL(false);
+		FiringAITemp::canFire = false;
+		return SkipGameCode;
+	}
+
+	const auto pTarget = pThis->Target;
+	FiringAITemp::weaponIndex = WeaponIndex;
+	FiringAITemp::isSecondary = TechnoTypeExt::ExtMap.Find(pThis->GetTechnoType())->IsSecondary(WeaponIndex);
+	FiringAITemp::WeaponType = pWeapon;
+	FiringAITemp::fireError = pThis->GetFireError(pTarget, WeaponIndex, true);
+	FiringAITemp::canFire = true;
+
+	return 0;
+}
+
+// avoid repeatedly calling GetFireError().
+DEFINE_HOOK_AGAIN(0x5209D2, InfantryClass_FiringAI_SetFireError, 0x6)
+DEFINE_HOOK(0x5206E4, InfantryClass_FiringAI_SetFireError, 0x6)
+{
+	R->EAX(FiringAITemp::fireError);
+	return R->Origin() == 0x5206E4 ? 0x5206F9 : 0x5209E4;
+}
+
+// determine if it is the second.
+DEFINE_HOOK_AGAIN(0x520968, InfantryClass_UpdateFiring_IsSecondary, 0x6)
+DEFINE_HOOK(0x520888, InfantryClass_UpdateFiring_IsSecondary, 0x8)
+{
+	GET(InfantryClass*, pThis, EBP);
+	const bool isSecondary = FiringAITemp::isSecondary;
+
+	if (R->Origin() == 0x520888)
+	{
+		R->AL(pThis->Crawling);
+		return isSecondary ? 0x520890 : 0x5208DC;
+	}
+	else if (isSecondary)
+	{
+		return pThis->Crawling ? 0x520970 : 0x52098A;
+	}
+	else
+	{
+		return 0x5209A0;
+	}
+}
+
+DEFINE_HOOK(0x5209AF, InfantryClass_FiringAI_BurstDelays, 0x6)
+{
+	GET(InfantryClass*, pThis, EBP);
+	GET(int, firingFrame, EDX);
+	enum { Continue = 0x5209CD, ReturnFromFunction = 0x520AD9 };
+
+	int cumulativeDelay = 0;
+	int projectedDelay = 0;
+	const int weaponIndex = FiringAITemp::weaponIndex;
+	const auto pWeaponExt = WeaponTypeExt::ExtMap.Find(FiringAITemp::WeaponType);
+	const bool allowBurst = pWeaponExt->Burst_FireWithinSequence;
+
+	// Calculate cumulative burst delay as well cumulative delay after next shot (projected delay).
+	if (allowBurst)
+	{
+		for (int i = 0; i <= pThis->CurrentBurstIndex; i++)
+		{
+			const int burstDelay = pWeaponExt->GetBurstDelay(i);
+			int delay = 0;
+
+			if (burstDelay > -1)
+				delay = burstDelay;
+			else
+				delay = ScenarioClass::Instance->Random.RandomRanged(3, 5);
+
+			// Other than initial delay, treat 0 frame delays as 1 frame delay due to per-frame processing.
+			if (i != 0)
+				delay = Math::max(delay, 1);
+
+			cumulativeDelay += delay;
+
+			if (i == pThis->CurrentBurstIndex)
+				projectedDelay = cumulativeDelay + delay;
+		}
+	}
+
+	if (pThis->Animation.Value == firingFrame + cumulativeDelay)
+	{
+		if (allowBurst)
+		{
+			const int frameCount = pThis->Type->Sequence->GetSequence(pThis->SequenceAnim).CountFrames;
+
+			// If projected frame for firing next shot goes beyond the sequence frame count, cease firing after this shot and start rearm timer.
+			if (firingFrame + projectedDelay > frameCount)
+			{
+				auto const pExt = TechnoExt::ExtMap.Find(pThis);
+				pExt->ForceFullRearmDelay = true;
+			}
+		}
+
+		R->EAX(weaponIndex); // Reuse the weapon index to save some time.
+		return Continue;
+	}
+
+	return ReturnFromFunction;
+}
+
+DEFINE_HOOK(0x520AD9, InfantryClass_FiringAI_IsGattling, 0x5)
+{
+	GET(InfantryClass*, pThis, EBP);
+
+	if (FiringAITemp::canFire)
+	{
+		if (pThis->Type->IsGattling)
+		{
+			const FireError fireError = FiringAITemp::fireError;
+
+			switch (fireError)
+			{
+			case FireError::OK:
+			case FireError::REARM:
+			case FireError::FACING:
+			case FireError::ROTATING:
+				pThis->GattlingRateUp(1);
+				break;
+			default:
+				pThis->GattlingRateDown(1);
+				break;
+			}
+		}
+
+		FiringAITemp::canFire = false;
+	}
+
+	return 0;
+}

src/Ext/Techno/Body.Update.cpp

@@ -1234,11 +1234,17 @@ void TechnoExt::ExtData::UpdateGattlingRateDownReset()
 
 		if (pTypeExt->RateDown_Reset && (!pThis->Target || this->LastTargetID != pThis->Target->UniqueID))
 		{
+			int oldStage = pThis->CurrentGattlingStage;
 			this->LastTargetID = pThis->Target ? pThis->Target->UniqueID : 0xFFFFFFFF;
 			pThis->GattlingValue = 0;
 			pThis->CurrentGattlingStage = 0;
 			this->AccumulatedGattlingValue = 0;
 			this->ShouldUpdateGattlingValue = false;
+
+			if (oldStage != 0)
+			{
+				pThis->GattlingRateDown(0);
+			}
 		}
 	}
 }

src/Ext/Techno/Hooks.Firing.cpp

@@ -229,12 +229,13 @@ DEFINE_HOOK(0x6F3432, TechnoClass_WhatWeaponShouldIUse_Gattling, 0xA)
 
 DEFINE_HOOK(0x5218F3, InfantryClass_WhatWeaponShouldIUse_DeployFireWeapon, 0x6)
 {
+	GET(InfantryClass*, pThis, ESI);
 	GET(TechnoTypeClass*, pType, ECX);
 
 	if (pType->DeployFireWeapon == -1)
 		return 0x52194E;
 
-	return 0;
+	return pType->IsGattling && !pThis->IsDeployed() ? 0x52194E : 0;
 }
 
 #pragma endregion
@@ -836,78 +837,6 @@ DEFINE_HOOK(0x6FB086, TechnoClass_Reload_ReloadAmount, 0x8)
 	return 0;
 }
 
-namespace FiringAITemp
-{
-	int weaponIndex;
-}
-
-DEFINE_HOOK(0x5206D2, InfantryClass_FiringAI_SetContext, 0x6)
-{
-	GET(int, weaponIndex, EDI);
-
-	FiringAITemp::weaponIndex = weaponIndex;
-
-	return 0;
-}
-
-DEFINE_HOOK(0x5209AF, InfantryClass_FiringAI_BurstDelays, 0x6)
-{
-	enum { Continue = 0x5209CD, ReturnFromFunction = 0x520AD9 };
-
-	GET(InfantryClass*, pThis, EBP);
-	GET(int, firingFrame, EDX);
-
-	int cumulativeDelay = 0;
-	int projectedDelay = 0;
-	const int weaponIndex = FiringAITemp::weaponIndex;
-	auto const pWeapon = pThis->GetWeapon(weaponIndex)->WeaponType;
-	auto const pWeaponExt = WeaponTypeExt::ExtMap.Find(pWeapon);
-
-	// Calculate cumulative burst delay as well cumulative delay after next shot (projected delay).
-	if (pWeaponExt && pWeaponExt->Burst_FireWithinSequence)
-	{
-		for (int i = 0; i <= pThis->CurrentBurstIndex; i++)
-		{
-			const int burstDelay = pWeaponExt->GetBurstDelay(i);
-			int delay = 0;
-
-			if (burstDelay > -1)
-				delay = burstDelay;
-			else
-				delay = ScenarioClass::Instance->Random.RandomRanged(3, 5);
-
-			// Other than initial delay, treat 0 frame delays as 1 frame delay due to per-frame processing.
-			if (i != 0)
-				delay = Math::max(delay, 1);
-
-			cumulativeDelay += delay;
-
-			if (i == pThis->CurrentBurstIndex)
-				projectedDelay = cumulativeDelay + delay;
-		}
-	}
-
-	if (pThis->Animation.Value == firingFrame + cumulativeDelay)
-	{
-		if (pWeaponExt && pWeaponExt->Burst_FireWithinSequence)
-		{
-			const int frameCount = pThis->Type->Sequence->GetSequence(pThis->SequenceAnim).CountFrames;
-
-			// If projected frame for firing next shot goes beyond the sequence frame count, cease firing after this shot and start rearm timer.
-			if (firingFrame + projectedDelay > frameCount)
-			{
-				auto const pExt = TechnoExt::ExtMap.Find(pThis);
-				pExt->ForceFullRearmDelay = true;
-			}
-		}
-
-		R->EAX(weaponIndex); // Reuse the weapon index to save some time.
-		return Continue;
-	}
-
-	return ReturnFromFunction;
-}
-
 // Author: Otamaa
 DEFINE_HOOK(0x5223B3, InfantryClass_Approach_Target_DeployFireWeapon, 0x6)
 {