Burst projectile retargeting

CREDITS.md

@@ -128,6 +128,7 @@ This page lists all the individual contributions to the project by their author.
   - Shared ammo logic
   - Customizable FLH when infantry is prone or deployed
   - Initial strength for cloned infantry
+  - `Burst.Retarget` for projectile retargeting
 - **Starkku**:
   - Misc. minor bugfixes & improvements
   - AI script actions:

docs/New-or-Enhanced-Logics.md

@@ -1245,6 +1245,22 @@ ExtraWarheads=                  ; list of WarheadTypes
 ExtraWarheads.DamageOverrides=  ; list of integers
 ```
 
+### Projectile's random target
+- The firer will pick targets randomly.
+- Works with missiles (no splits, airbusts, etc), cannons, lasers & spawners.
+- A valid techno is required for trigger the logic.
+- `OmniFire=yes` will make selectable any targets around the firer, limited by the weapon range.
+- `OmniFire=no` will force the firer to pick targets in an area composed by the firer's weapon range around the original target intersected with the firer's weapon range around the firer.
+- `RandomTarget.Spawners.MultipleTargets=true` gives each spawner it's own target.
+- This logic should be used only in one weapon of the object.
+
+In `rulesmd.ini`:
+```ini
+[SOMEWEAPON]                                ; WeaponType
+RandomTarget=0.0                            ; double or percentage
+RandomTarget.Spawners.MultipleTargets=false ; boolean
+```
+
 ### Feedback weapon
 
 ![image](_static/images/feedbackweapon.gif)

docs/Whats-New.md

@@ -348,6 +348,7 @@ New:
 - Customizable straight trajectory detonation & snap distance and pass-through option (by Starkku)
 - Airstrike & spy plane fixed spawn distance & height (by Starkku)
 - Allow enabling application of `Verses` and `PercentAtMax` for negative damage (by Starkku)
+- `Burst.Retarget` for assigning a new target in each projectile (by FS-21)
 
 Vanilla fixes:
 - Allow AI to repair structures built from base nodes/trigger action 125/SW delivery in single player missions (by Trsdy)

src/Ext/Techno/Body.Update.cpp

@@ -6,6 +6,7 @@
 #include <Ext/Anim/Body.h>
 #include <Ext/Bullet/Body.h>
 #include <Ext/House/Body.h>
+#include <Ext/Script/Body.h>
 #include <Utilities/EnumFunctions.h>
 #include <Utilities/AresFunctions.h>
 
@@ -719,3 +720,49 @@ void TechnoExt::UpdateSharedAmmo(TechnoClass* pThis)
 		}
 	}
 }
+
+void TechnoExt::ExtData::RefreshRandomTargets()
+{
+	auto const pThis = this->OwnerObject();
+	if (!pThis)
+		return;
+
+	const auto pExt = TechnoExt::ExtMap.Find(pThis);
+	if (!pExt)
+		return;
+
+	if (pThis->Target && pThis->SpawnManager && pExt->CurrentRandomTarget && ScriptExt::IsUnitAvailable(static_cast<TechnoClass*>(pExt->CurrentRandomTarget), true))
+	{
+		if (pThis->SpawnManager)
+		{
+			for (auto pSpawn : pThis->SpawnManager->SpawnedNodes)
+			{
+				if (!pSpawn->Unit)
+					continue;
+
+				auto pSpawnExt = TechnoExt::ExtMap.Find(pSpawn->Unit);
+				if (!pSpawnExt)
+					continue;
+
+				if (!pSpawnExt->CurrentRandomTarget)
+				{
+					pSpawnExt->CurrentRandomTarget = TechnoExt::GetRandomTarget(pThis);
+					pSpawn->Unit->Target = pSpawnExt->CurrentRandomTarget;
+				}
+				else if (pSpawn->Status == SpawnNodeStatus::Preparing && pSpawn->Unit->IsInAir())
+				{
+					if (!pSpawn->Unit->Target && pSpawnExt->CurrentRandomTarget)
+						pSpawn->Unit->Target = pSpawnExt->CurrentRandomTarget;
+				}
+			}
+		}
+	}
+
+	if (pExt->OriginalTarget && !pThis->Target && ScriptExt::IsUnitAvailable(static_cast<TechnoClass*>(pExt->OriginalTarget), true) && !pThis->IsInAir())
+	{
+		if (pExt->CurrentRandomTarget && ScriptExt::IsUnitAvailable(pExt->CurrentRandomTarget, true))
+			pThis->SetTarget(pExt->CurrentRandomTarget);
+		else
+			pThis->SetTarget(pExt->OriginalTarget);
+	}
+}

src/Ext/Techno/Body.cpp

@@ -7,6 +7,8 @@
 #include <TacticalClass.h>
 
 #include <Ext/House/Body.h>
+#include <Ext/WeaponType/Body.h>
+#include <Ext/Script/Body.h>
 
 #include <Utilities/AresFunctions.h>
 #include <Utilities/EnumFunctions.h>
@@ -637,6 +639,213 @@ bool TechnoExt::IsTypeImmune(TechnoClass* pThis, TechnoClass* pSource)
 	return false;
 }
 
+bool TechnoExt::UpdateRandomTarget(TechnoClass* pThis)
+{
+	if (!pThis)
+		return false;
+
+	int weaponIndex = pThis->SelectWeapon(pThis->Target);
+	auto pWeapon = pThis->GetWeapon(weaponIndex)->WeaponType;
+	if (!pWeapon)
+		return false;
+
+	const auto pWeaponExt = WeaponTypeExt::ExtMap.Find(pWeapon);
+	if (!pWeaponExt || pWeaponExt->RandomTarget <= 0.0)
+		return false;
+
+	const auto pExt = TechnoExt::ExtMap.Find(pThis);
+	if (!pExt)
+		return false;
+
+	if (pThis->GetCurrentMission() == Mission::Move)
+	{
+		pExt->CurrentRandomTarget = nullptr;
+		pExt->OriginalTarget = nullptr;
+
+		return false;
+	}
+
+	if (pExt->CurrentRandomTarget && ScriptExt::IsUnitAvailable(pExt->CurrentRandomTarget, false) && pThis->SpawnManager)
+		return false;
+
+	if (!pThis->Target && !ScriptExt::IsUnitAvailable(abstract_cast<TechnoClass*>(pExt->OriginalTarget), false))
+	{
+		pExt->OriginalTarget = nullptr;
+		return false;
+	}
+
+	if (pExt->OriginalTarget && !ScriptExt::IsUnitAvailable(abstract_cast<TechnoClass*>(pExt->OriginalTarget), false))
+	{
+		pExt->CurrentRandomTarget = nullptr;
+		pExt->OriginalTarget = nullptr;
+	}
+
+	if (pThis->GetCurrentMission() != Mission::Attack)
+	{
+		pExt->OriginalTarget = nullptr;
+		return false;
+	}
+
+	if (!pThis->Target)
+		return false;
+
+	if (pThis->DistanceFrom(pExt->OriginalTarget) > pWeapon->Range)
+	{
+		if (pThis->WhatAmI() == AbstractType::Building)
+		{
+			pThis->SetTarget(nullptr);
+			pExt->CurrentRandomTarget = nullptr;
+			pExt->OriginalTarget = nullptr;
+
+			return false;
+		}
+
+		pThis->SetTarget(pExt->OriginalTarget);
+	}
+
+	if (pThis->DistanceFrom(pThis->Target) > pWeapon->Range)
+	{
+		pThis->SetTarget(pExt->OriginalTarget);
+		return false;
+	}
+
+	auto pRandomTarget = GetRandomTarget(pThis);
+
+	if (!pRandomTarget)
+		return false;
+
+	pExt->OriginalTarget = !pExt->OriginalTarget ? pThis->Target : pExt->OriginalTarget;
+	pExt->CurrentRandomTarget = pRandomTarget;
+	pThis->Target = pRandomTarget;
+
+	if (pThis->SpawnManager)
+	{
+		bool isFirstSpawn = true;
+
+		for (auto pSpawn : pThis->SpawnManager->SpawnedNodes)
+		{
+			if (!pSpawn->Unit)
+				continue;
+
+			TechnoClass* pSpawnTarget = nullptr;
+
+			auto pSpawnExt = TechnoExt::ExtMap.Find(pSpawn->Unit);
+			if (!pSpawnExt)
+				continue;
+
+			if (isFirstSpawn)
+			{
+				pSpawnTarget = pExt->CurrentRandomTarget;
+
+				if (pWeaponExt->RandomTarget_Spawners_MultipleTargets)
+					isFirstSpawn = false;
+			}
+			else
+			{
+				pSpawnTarget = GetRandomTarget(pThis);
+
+				if (!pSpawnTarget)
+					pSpawnTarget = abstract_cast<TechnoClass*>(pExt->OriginalTarget);
+			}
+
+			pSpawnExt->CurrentRandomTarget = pSpawnTarget;
+			pSpawnExt->OriginalTarget = pExt->OriginalTarget;
+		}
+	}
+
+	return true;
+}
+
+TechnoClass* TechnoExt::GetRandomTarget(TechnoClass* pThis)
+{
+	TechnoClass* selection = nullptr;
+
+	if (!pThis && !pThis->Target)
+		return selection;
+
+	int weaponIndex = pThis->SelectWeapon(pThis->Target);
+	auto pWeapon = pThis->GetWeapon(weaponIndex)->WeaponType;
+	if (!pWeapon)
+		return selection;
+
+	const auto pWeaponExt = WeaponTypeExt::ExtMap.Find(pWeapon);
+	if (!pWeaponExt || pWeaponExt->RandomTarget <= 0.0)
+		return selection;
+
+	const auto pExt = TechnoExt::ExtMap.Find(pThis);
+	if (!pExt)
+		return selection;
+
+	int retargetProbability = std::min((int)round(pWeaponExt->RandomTarget * 100), 100);
+	int dice = ScenarioClass::Instance->Random.RandomRanged(1, 100);
+
+	if (retargetProbability < dice)
+		return selection;
+
+	auto pThisType = pThis->GetTechnoType();
+	int minimumRange = pWeapon->MinimumRange;
+	int range = pWeapon->Range;
+	int airRange = pWeapon->Range + pThisType->AirRangeBonus;
+	bool omniFire = pWeapon->OmniFire;
+	std::vector<TechnoClass*> candidates;
+	auto originalTarget = abstract_cast<TechnoClass*>(!pExt->OriginalTarget ? pThis->Target : pExt->OriginalTarget);
+	bool friendlyFire = pThis->Owner->IsAlliedWith(originalTarget);
+
+	// Looking for all valid targeting candidates
+	for (auto pCandidate : *TechnoClass::Array)
+	{
+		if (pCandidate == pThis
+			|| !ScriptExt::IsUnitAvailable(pCandidate, true)
+			|| pThisType->Immune
+			|| !EnumFunctions::IsTechnoEligible(pCandidate, pWeaponExt->CanTarget, true)
+			|| (!pWeapon->Projectile->AA && pCandidate->IsInAir())
+			|| (!pWeapon->Projectile->AG && !pCandidate->IsInAir())
+			|| (!friendlyFire && (pThis->Owner->IsAlliedWith(pCandidate) || ScriptExt::IsUnitMindControlledFriendly(pThis->Owner, pCandidate)))
+			|| pCandidate->TemporalTargetingMe
+			|| pCandidate->BeingWarpedOut
+			|| (pCandidate->GetTechnoType()->Underwater && pCandidate->GetTechnoType()->NavalTargeting == NavalTargetingType::Underwater_Never)
+			|| (pCandidate->GetTechnoType()->Naval && pCandidate->GetTechnoType()->NavalTargeting == NavalTargetingType::Naval_None)
+			|| (pCandidate->CloakState == CloakState::Cloaked && !pThisType->Naval)
+			|| (pCandidate->InWhichLayer() == Layer::Underground))
+		{
+			continue;
+		}
+
+		int distanceFromAttacker = pThis->DistanceFrom(pCandidate);
+		if (distanceFromAttacker < minimumRange)
+			continue;
+
+		if (omniFire)
+		{
+			if (pCandidate->IsInAir())
+				range = airRange;
+
+			if (distanceFromAttacker <= range)
+				candidates.push_back(pCandidate);
+		}
+		else
+		{
+			int distanceFromOriginalTargetToCandidate = pCandidate->DistanceFrom(pThis->Target);
+			int distanceFromOriginalTarget = pThis->DistanceFrom(pThis->Target);
+
+			if (pCandidate->IsInAir())
+				range = airRange;
+
+			if (distanceFromAttacker <= range && distanceFromOriginalTargetToCandidate <= distanceFromOriginalTarget)
+				candidates.push_back(pCandidate);
+		}
+	}
+
+	if (candidates.size() == 0)
+		return selection;
+
+	// Pick one new target from the list of targets inside the weapon range
+	dice = ScenarioClass::Instance->Random.RandomRanged(0, candidates.size() - 1);
+	selection = candidates.at(dice);
+
+	return selection;
+}
+
 // =============================
 // load / save
 
@@ -659,6 +868,8 @@ void TechnoExt::ExtData::Serialize(T& Stm)
 		.Process(this->DeployFireTimer)
 		.Process(this->ForceFullRearmDelay)
 		.Process(this->WHAnimRemainingCreationInterval)
+		.Process(this->OriginalTarget)
+		.Process(this->CurrentRandomTarget)
 		;
 }
 

src/Ext/Techno/Body.h

@@ -6,6 +6,7 @@
 #include <Utilities/Container.h>
 #include <Utilities/TemplateDef.h>
 #include <Utilities/Macro.h>
+#include <Utilities/EnumFunctions.h>
 #include <New/Entity/ShieldClass.h>
 #include <New/Entity/LaserTrailClass.h>
 
@@ -38,6 +39,8 @@ class TechnoExt
 		CDTimerClass DeployFireTimer;
 		bool ForceFullRearmDelay;
 		int WHAnimRemainingCreationInterval;
+		AbstractClass* OriginalTarget;
+		TechnoClass* CurrentRandomTarget;
 
 		// 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.
@@ -61,6 +64,8 @@ class TechnoExt
 			, DeployFireTimer {}
 			, ForceFullRearmDelay { false }
 			, WHAnimRemainingCreationInterval { 0 }
+			, OriginalTarget { nullptr }
+			, CurrentRandomTarget { nullptr }
 		{ }
 
 		void ApplyInterceptor();
@@ -74,12 +79,15 @@ class TechnoExt
 		void UpdateLaserTrails();
 		void InitializeLaserTrails();
 		void UpdateMindControlAnim();
+		void RefreshRandomTargets();
 
 		virtual ~ExtData() override;
 
 		virtual void InvalidatePointer(void* ptr, bool bRemoved) override
 		{
 			AnnounceInvalidPointer(OriginalPassengerOwner, ptr);
+			AnnounceInvalidPointer(CurrentRandomTarget, ptr);
+			AnnounceInvalidPointer(OriginalTarget, ptr);
 		}
 
 		virtual void LoadFromStream(PhobosStreamReader& Stm) override;
@@ -143,6 +151,8 @@ class TechnoExt
 	static bool ConvertToType(FootClass* pThis, TechnoTypeClass* toType);
 	static bool CanDeployIntoBuilding(UnitClass* pThis, bool noDeploysIntoDefaultValue = false);
 	static bool IsTypeImmune(TechnoClass* pThis, TechnoClass* pSource);
+	static bool UpdateRandomTarget(TechnoClass* pThis = nullptr);
+	static TechnoClass* GetRandomTarget(TechnoClass* pThis = nullptr);
 
 	// WeaponHelpers.cpp
 	static int PickWeaponIndex(TechnoClass* pThis, TechnoClass* pTargetTechno, AbstractClass* pTarget, int weaponIndexOne, int weaponIndexTwo, bool allowFallback = true, bool allowAAFallback = true);