Several attack move enhancement (#1730)

### Attack move - behavior when target acquired

- Now you can make attacking moving units stop moving when they spot an
enemy using `AttackMove.StopWhenTargetAcquired`. This is more like the
attack move behavior in starcraft and warcraft.
- This function is used to prevent units from charging forward and
taking on more damage.
- You can also make them move towards the spotted target using
`AttackMove.PursuitTarget`.
  - This function is used for close range units like ZEP.


In `rulesmd.ini`:
```ini
[General]
AttackMove.StopWhenTargetAcquired=         ; boolean

[SOMETECHNO]                               ; TechnoType
AttackMove.StopWhenTargetAcquired=         ; boolean, default to [General] -> AttackMove.StopWhenTargetAcquired if set, inverse of OpportunityFire otherwise.
AttackMove.PursuitTarget=                  ; boolean
```

```{note}
1. Many units would have stopped when they found an enemy. This behavior is independent of `AttackMove.StopWhenTargetAcquired`.
2. Some units (f.ex. jumpjets) will not fire correctly under the vanilla attack move. The exact reason is not clear, but this feature can fix this problem.
3. Jumpjets with `AttackMove.StopWhenTargetAcquired=true` will stop immediatly and not scatter to a cell. This is designed for practical reason.
```

### Attack move - follow

- Now you can have some units follow surrounding units when executing an
attack move. The following behavior is equivalent to the behavior when
using `ctrl + alt`.
- Use `AttackMove.Follow.IncludeAir` to determine whether the follower
will choose an air unit as a follow target.
- This function should be useful for auxiliary units such as medics and
repair drones.
- We have made additional optimizations to the followed target selection
algorithm to make this function more practical.

In `rulesmd.ini`:
```ini
[SOMETECHNO]                               ; TechnoType
AttackMove.Follow=false                    ; boolean
AttackMove.Follow.IncludeAir=false         ; boolean
```

### Attack move - without weapon

- In vanilla, a unit without weapon is not allowed to attack move. Now
you can disable this hardcoded behavior using
`AttackMove.IgnoreWeaponCheck=true`.
- Unarmed units of course cannot actually execute attack moves. This
feature is to prevent the attack move pointer from being disabled when
you select unarmed units and other units at the same time.

In `rulesmd.ini`:
```ini
[General]
AttackMove.IgnoreWeaponCheck=false    ; boolean
```

---------

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

Author: 3 people

CREDITS.md

@@ -549,6 +549,7 @@ This page lists all the individual contributions to the project by their author.
   - Customize whether `Crater=yes` animation would destroy tiberium
   - Targeting limitation for berzerk technos
   - Allows refineries to use multiple ActiveAnim simultaneously
+  - Several attackmove related enhancement
 - **tyuah8**:
   - Drive/Jumpjet/Ship/Teleport locomotor did not power on when it is un-piggybacked bugfix
   - Destroyed unit leaves sensors bugfix

docs/New-or-Enhanced-Logics.md

@@ -1171,6 +1171,54 @@ AttackMove.Aggressive=         ; boolean, default to [General] -> AttackMove.Agg
 AttackMove.UpdateTarget=       ; boolean, default to [General] -> AttackMove.UpdateTarget
 ```
 
+### Attack move - behavior when target acquired
+
+- Now you can make attack-moving units stop moving when they spot an enemy using `AttackMove.StopWhenTargetAcquired`. This is more like the attack move behavior in Starcraft and Warcraft.
+  - This feature is used to prevent units from charging forward and taking more damage during an attack move command.
+- You can also make them keep chasing on the spotted target using `AttackMove.PursuitTarget`.
+  - This feature should be useful for close range units like ZEP.
+
+
+In `rulesmd.ini`:
+```ini
+[General]
+AttackMove.StopWhenTargetAcquired=         ; boolean
+
+[SOMETECHNO]                               ; TechnoType
+AttackMove.StopWhenTargetAcquired=         ; boolean, default to [General] -> AttackMove.StopWhenTargetAcquired if set, inverse of OpportunityFire otherwise.
+AttackMove.PursuitTarget=                  ; boolean
+```
+
+```{note}
+1. Many units would have stopped when they found an enemy during an attack move command already. This behavior is independent from `AttackMove.StopWhenTargetAcquired`.
+2. Some units (f.ex. jumpjets) will not fire correctly under the vanilla attack move command. The exact reason is not clear, but this feature can fix this problem.
+3. Jumpjets with `AttackMove.StopWhenTargetAcquired=true` will stop immediatly and not scatter to a cell. This is designed for practical reason.
+```
+
+### Attack move - follow
+
+- Now you can have some units following surrounding units when executing an attack move command. The follow behavior is equivalent to the behavior of follow command (`ctrl + alt`).
+  - Use `AttackMove.Follow.IncludeAir` to determine whether the follower will follow an air unit.
+- This feature should be useful for supportive units such as medics and repairers.
+
+In `rulesmd.ini`:
+```ini
+[SOMETECHNO]                               ; TechnoType
+AttackMove.Follow=false                    ; boolean
+AttackMove.Follow.IncludeAir=false         ; boolean
+```
+
+### Attack move - without weapon
+
+- In vanilla, attack move command is not allowed to be given to units without weapons. Now you can disable this hardcoded behavior using `AttackMove.IgnoreWeaponCheck=true`.
+  - Unarmed units cannot actually execute attack move commands. This feature is to prevent the attack move pointer from being disabled when you select unarmed units and other units at the same time.
+
+In `rulesmd.ini`:
+```ini
+[General]
+AttackMove.IgnoreWeaponCheck=false    ; boolean
+```
+
 ### Aircraft spawner customizations
 
 ![image](_static/images/spawnrange-01.gif)

docs/Whats-New.md

@@ -407,6 +407,7 @@ New:
 - [Allows refineries to use multiple ActiveAnim simultaneously](Fixed-or-Improved-Logics.md#allows-refineries-to-use-multiple-activeanim-simultaneously) (by TaranDahl)
 - Electric/RadBeam trail for laser tails (by NetsuNegi)
 - Add `DebrisMinimums` to keep the count of debris within a certain range (by CrimRecya)
+- Several attackmove related enhancement (by TaranDahl)
 
 Vanilla fixes:
 - Fixed sidebar not updating queued unit numbers when adding or removing units when the production is on hold (by CrimRecya)

src/Ext/Rules/Body.cpp

@@ -269,7 +269,6 @@ void RulesExt::ExtData::LoadBeforeTypeData(RulesClass* pThis, CCINIClass* pINI)
 	this->WarheadParticleAlphaImageIsLightFlash.Read(exINI, GameStrings::AudioVisual, "WarheadParticleAlphaImageIsLightFlash");
 	this->CombatLightDetailLevel.Read(exINI, GameStrings::AudioVisual, "CombatLightDetailLevel");
 	this->LightFlashAlphaImageDetailLevel.Read(exINI, GameStrings::AudioVisual, "LightFlashAlphaImageDetailLevel");
-
 	this->BuildingTypeSelectable.Read(exINI, GameStrings::General, "BuildingTypeSelectable");
 
 	this->ProneSpeed_Crawls.Read(exINI, GameStrings::General, "ProneSpeed.Crawls");
@@ -283,6 +282,9 @@ void RulesExt::ExtData::LoadBeforeTypeData(RulesClass* pThis, CCINIClass* pINI)
 
 	this->BerzerkTargeting.Read(exINI, GameStrings::CombatDamage, "BerzerkTargeting");
 
+	this->AttackMove_IgnoreWeaponCheck.Read(exINI, GameStrings::General, "AttackMove.IgnoreWeaponCheck");
+	this->AttackMove_StopWhenTargetAcquired.Read(exINI, GameStrings::General, "AttackMove.StopWhenTargetAcquired");
+
 	// Section AITargetTypes
 	int itemsCount = pINI->GetKeyCount("AITargetTypes");
 	for (int i = 0; i < itemsCount; ++i)
@@ -521,6 +523,8 @@ void RulesExt::ExtData::Serialize(T& Stm)
 		.Process(this->TintColorIronCurtain)
 		.Process(this->TintColorForceShield)
 		.Process(this->TintColorBerserk)
+		.Process(this->AttackMove_IgnoreWeaponCheck)
+		.Process(this->AttackMove_StopWhenTargetAcquired)
 		;
 }
 

src/Ext/Rules/Body.h

@@ -230,6 +230,9 @@ class RulesExt
 
 		Valueable<AffectedHouse> BerzerkTargeting;
 
+		Valueable<bool> AttackMove_IgnoreWeaponCheck;
+		Nullable<bool> AttackMove_StopWhenTargetAcquired;
+		
 		// cache tint color
 		int TintColorIronCurtain;
 		int TintColorForceShield;
@@ -414,6 +417,9 @@ class RulesExt
 			, TintColorIronCurtain { 0 }
 			, TintColorForceShield { 0 }
 			, TintColorBerserk { 0 }
+
+			, AttackMove_IgnoreWeaponCheck { false }
+			, AttackMove_StopWhenTargetAcquired { }
 		{ }
 
 		virtual ~ExtData() = default;

src/Ext/Techno/Body.Update.cpp

@@ -43,6 +43,11 @@ void TechnoExt::ExtData::OnEarlyUpdate()
 	this->ApplyMindControlRangeLimit();
 	this->UpdateRecountBurst();
 	this->UpdateRearmInEMPState();
+	
+	if (this->AttackMoveFollowerTempCount)
+	{
+		this->AttackMoveFollowerTempCount--;
+	}
 }
 
 void TechnoExt::ExtData::ApplyInterceptor()

src/Ext/Techno/Body.cpp

@@ -652,6 +652,7 @@ void TechnoExt::ExtData::Serialize(T& Stm)
 		.Process(this->TintIntensityOwner)
 		.Process(this->TintIntensityAllies)
 		.Process(this->TintIntensityEnemies)
+		.Process(this->AttackMoveFollowerTempCount)
 		;
 }
 

src/Ext/Techno/Body.h

@@ -82,6 +82,8 @@ class TechnoExt
 		int TintIntensityAllies;
 		int TintIntensityEnemies;
 
+		int AttackMoveFollowerTempCount;
+
 		ExtData(TechnoClass* OwnerObject) : Extension<TechnoClass>(OwnerObject)
 			, TypeExtData { nullptr }
 			, Shield {}
@@ -134,6 +136,7 @@ class TechnoExt
 			, TintIntensityOwner { 0 }
 			, TintIntensityAllies { 0 }
 			, TintIntensityEnemies { 0 }
+			, AttackMoveFollowerTempCount { 0 }
 		{ }
 
 		void OnEarlyUpdate();

src/Ext/Techno/Hooks.Firing.cpp

@@ -1,4 +1,4 @@
-#include "Body.h"
+#include "Body.h"
 
 #include <OverlayTypeClass.h>
 #include <ScenarioClass.h>

src/Ext/Techno/Hooks.TargetEvaluation.cpp

@@ -187,10 +187,12 @@ DEFINE_HOOK(0x4DF3A0, FootClass_UpdateAttackMove_SelectNewTarget, 0x6)
 
 	const auto pExt = TechnoExt::ExtMap.Find(pThis);
 
-	if (pExt->TypeExtData->AttackMove_UpdateTarget.Get(RulesExt::Global()->AttackMove_UpdateTarget) && CheckAttackMoveCanResetTarget(pThis))
+	if (pExt->TypeExtData->AttackMove_UpdateTarget.Get(RulesExt::Global()->AttackMove_UpdateTarget)
+		&& CheckAttackMoveCanResetTarget(pThis))
 	{
 		pThis->Target = nullptr;
 		pThis->HaveAttackMoveTarget = false;
+		pExt->UpdateGattlingRateDownReset();
 	}
 
 	return 0;