Merge branch 'develop' into DisableStupidTargetScanningOptimization

Author: TaranDahl

CREDITS.md

@@ -688,6 +688,8 @@ This page lists all the individual contributions to the project by their author.
   - `AllowBerzerkOnAllies`
   - Fixed an issue that retaliation will make the unit keep switching among multiple targets with the same amount of threat
   - Fix an issue where units recruited by a team with `AreTeamMembersRecruitable=false` cannot be recruited even if they have been liberated by that team
+  - Global default value for `DefaultToGuardArea`
+  - Weapon range finding in cylinder
   - Allow disable an over-optimization in targeting
 - **solar-III (凤九歌)**
   - Target scanning delay customization (documentation)

YRpp

@@ -151,7 +151,7 @@ This page describes all ingame logics that are fixed or improved in Phobos witho
 - Fixed disguised units not using the correct palette if target has custom palette.
 - Building upgrades now consistently use building's `PowerUpN` animation settings corresponding to the upgrade's `PowersUpToLevel` where possible.
 - Subterranean units are no longer allowed to perform deploy functions like firing weapons or `IsSimpleDeployer` while burrowed or burrowing, they will instead emerge first like they do for transport unloading.
-- The otherwise unused setting `[AI] -> PowerSurplus` (defaults to 50) which determines how much surplus power AI players will strive to have can be restored by setting `[AI] -> EnablePowerSurplus` to true.
+- The otherwise unused setting `[AI] -> PowerSurplus` (defaults to 50) which determines how much surplus power AI players will strive to have can be restored by setting `[AI] -> EnablePowerSurplus` to true. Additional option `[AI] -> PowerSurplus.ScaleToDrainAmount` if set to value higher than 0 makes it so that power surplus multiplied by current power drain / `PowerSurplus.ScaleToDrainAmount`.
 - Planning paths are now shown for all units under player control or when `[GlobalControls] -> DebugPlanningPaths=yes` in singleplayer game modes.
 - Fixed `Temporal=true` Warheads potentially crashing game if used to attack `Slaved=true` infantry.
 - Fixed some locomotors (Tunnel, Walk, Mech) getting stuck when moving too fast.
@@ -294,6 +294,7 @@ This page describes all ingame logics that are fixed or improved in Phobos witho
 - `ProductionAnim` is now available for `Factory=InfantryType` as well as non-`ConstructionYard=true` `Factory=BuildingType` buildings. `IdleAnim` will cease to play for its duration normally as well.
 - Fixed the bug where selected technos would lose their selection if their regular mind control was replaced with permanent mind control or with the control from the Psychic Dominator superweapon.
 - Fixed the issue where units recruited by a team with `AreTeamMembersRecruitable=false` cannot be recruited even if they have been liberated by that team.
+- Allow the default value of `DefaultToGuardArea` to be defined by `[General] -> DefaultToGuardArea`.
 
 ## Fixes / interactions with other extensions
 
@@ -1425,6 +1426,21 @@ OreGathering.FramesPerDir=15     ; List of integers
 OreGathering.Tiberiums=0         ; List of Tiberium IDs
 ```
 
+### Customizable paradrop missions
+
+- By default paradropped infantry default to `Guard` for human players and `Hunt` for AI players. This has now been changed to be the default for vehicles as well which defaulted to `Guard` for all players and customizable globally and per TechnoType which default to the global settings under `[General]`.
+
+In `rulesmd.ini`:
+```ini
+[General]
+ParadropMission=Guard   ; MissionType
+AIParadropMission=Hunt  ; MissionType
+
+[SOMETECHNO]            ; TechnoType
+ParadropMission=        ; MissionType
+AIParadropMission=      ; MissionType
+```
+
 ### Customizable target evaluation map zone check behaviour
 
 - By default, any non-AircraftType units seeking targets via ScriptType team mission (action) `0 Attack Target Type` or any [attack team missions introduced in Phobos](AI-Scripting-and-Mapping.md#attack-actions) check if the potential target is in same map zone as the attacking unit to be able to pick it as a target. This can now be customized to allow objects from any map zone with no constraints (`TargetZoneScanType=any`) or only if they are within weapon range (`TargetZoneScanType=inrange`).

docs/Fixed-or-Improved-Logics.md

@@ -3016,6 +3016,21 @@ OmniFire.TurnToTarget=no  ; boolean
 
 - In addition to allowing custom radiation types, several enhancements are also available to the default radiation type defined in `[Radiation]`, such as ability to set owner & invoker or deal damage against buildings. See [Custom Radiation Types](#custom-radiation-types) for more details.
 
+### Range finding in cylinder
+
+- In vanilla, technos in air will ignore the distance in Z axis when checking if the target is in range. Now you can use the following flags to make technos always range finding like that.
+- `[General]->CylinderRangefinding` controls this globally, and can be customized per weapon type.
+- Mind that set the flags to `false` meaning "use default" rather than "disable". Technos in air will always range finding in cylinder like vanilla, despite what you set.
+
+In `rulesmd.ini`:
+```ini
+[General]                         ; WeaponType
+CylinderRangefinding=false  ; boolean
+
+[SOMEWEAPON]                      ; WeaponType
+CylinderRangefinding=       ; boolean
+```
+
 ### Strafing aircraft weapon customization
 
 ![image](_static/images/strafing-01.gif)

docs/New-or-Enhanced-Logics.md

@@ -10,6 +10,7 @@ You can use the migration utility (can be found on [Phobos supplementaries repo]
 
 ### From vanilla
 
+- Vehicles paradropped by AI players now default to `Hunt` mission instead of `Guard`, matching what infantry do. This can be customized by setting `AIParadropMission` on the VehicleType, defaults to `[General]` -> `AIParadropMission`.
 - `IsSimpleDeployer` units now obey deploying facing constraint even without deploying animation if `DeployDir` is explicitly set on the unit.
 - `Vertical=true` projectiles now default to completely downwards initial trajectory/facing regardless of if their projectile image has `Voxel=true` or not. This behavior can be reverted by setting `VerticalInitialFacing=false` on projectile in `rulesmd.ini`.
 - `Vertical=true` projectiles no longer move horizontally if fired by aircraft by default. To re-enable this behaviour set `Vertical.AircraftFix=false` on the projectile.
@@ -530,6 +531,10 @@ New:
 - [`AllowBerzerkOnAllies`](Fixed-or-Improved-Logics.md#berzerk-on-allies) (by TaranDahl)
 - [Customize whether weapon can be used to targeting ironcurtained technos or not](New-or-Enhanced-Logics.md#customize-whether-weapon-can-target-iron-curtained-technos) (by NetsuNegi)
 - Customizable disk drain logic (by NetsuNegi)
+- [Customizable paradropped unit missions](Fixed-or-Improved-Logics.md#customizable-paradrop-missions) (by Starkku)
+- Option to scale `PowerSurplus` setting if enabled to current power drain with `PowerSurplus.ScaleToDrainAmount` (by Starkku)
+- Global default value for `DefaultToGuardArea` (by TaranDahl)
+- [Weapon range finding in cylinder](New-or-Enhanced-Logics.md#range-finding-in-cylinder) (by TaranDahl)
 
 Vanilla fixes:
 - Fixed sidebar not updating queued unit numbers when adding or removing units when the production is on hold (by CrimRecya)

docs/Whats-New.md

@@ -652,6 +652,26 @@ void HouseExt::ExtData::SetForceEnemyIndex(int EnemyIndex)
 		this->ForceEnemyIndex = EnemyIndex;
 }
 
+void HouseExt::CalculatePowerSurplus(HouseClass* pThis)
+{
+	auto const pRulesExt = RulesExt::Global();
+
+	if (!pRulesExt->EnablePowerSurplus)
+		return;
+
+	int scaleToDrainAmount = pRulesExt->PowerSurplus_ScaleToDrainAmount;
+
+	if (scaleToDrainAmount <= 0)
+	{
+		pThis->PowerSurplus = RulesClass::Instance->PowerSurplus;
+	}
+	else
+	{
+		double factor = pThis->PowerDrain / static_cast<double>(scaleToDrainAmount);
+		pThis->PowerSurplus = static_cast<int>(RulesClass::Instance->PowerSurplus * factor);
+	}
+}
+
 // =============================
 // load / save
 
@@ -759,9 +779,7 @@ DEFINE_HOOK(0x4F6532, HouseClass_CTOR, 0x5)
 	GET(HouseClass*, pItem, EAX);
 
 	HouseExt::ExtMap.TryAllocate(pItem);
-
-	if (RulesExt::Global()->EnablePowerSurplus)
-		pItem->PowerSurplus = RulesClass::Instance->PowerSurplus;
+	HouseExt::CalculatePowerSurplus(pItem);
 
 	return 0;
 }

src/Ext/House/Body.cpp

@@ -200,4 +200,6 @@ class HouseExt
 
 	static CanBuildResult BuildLimitGroupCheck(const HouseClass* pThis, const TechnoTypeClass* pItem, bool buildLimitOnly, bool includeQueued);
 	static bool ReachedBuildLimit(const HouseClass* pHouse, const TechnoTypeClass* pType, bool ignoreQueued);
+
+	static void CalculatePowerSurplus(HouseClass* pThis);
 };

src/Ext/House/Body.h

@@ -57,32 +57,34 @@ DEFINE_HOOK(0x502A80, HouseClass_RegisterGain, 0x8)
 	return 0;
 }
 
-DEFINE_HOOK(0x508D8D, HouseClass_UpdatePower_Techno, 0x6)
+DEFINE_HOOK(0x508D8D, HouseClass_UpdatePower_AfterBuildings, 0x6)
 {
-	if (!Phobos::Config::UnitPowerDrain)
-		return 0;
-
 	GET(HouseClass*, pThis, ESI);
 
-	auto updateDrainForThisType = [pThis](const TechnoTypeClass* pType)
+	if (Phobos::Config::UnitPowerDrain)
 	{
-			const int count = pThis->CountOwnedAndPresent(pType);
-			if (count == 0)
-				return;
-			const auto pExt = TechnoTypeExt::ExtMap.Find(pType);
-			if (pExt->Power > 0)
-				pThis->PowerOutput += pExt->Power * count;
-			else
-				pThis->PowerDrain -= pExt->Power * count;
-	};
-
-	for (const auto pType : InfantryTypeClass::Array)
-		updateDrainForThisType(pType);
-	for (const auto pType : UnitTypeClass::Array)
-		updateDrainForThisType(pType);
-	for (const auto pType : AircraftTypeClass::Array)
-		updateDrainForThisType(pType);
-	// Don't do this for buildings, they've already been counted.
+		auto updateDrainForThisType = [pThis](const TechnoTypeClass* pType)
+			{
+				const int count = pThis->CountOwnedAndPresent(pType);
+				if (count == 0)
+					return;
+				const auto pExt = TechnoTypeExt::ExtMap.Find(pType);
+				if (pExt->Power > 0)
+					pThis->PowerOutput += pExt->Power * count;
+				else
+					pThis->PowerDrain -= pExt->Power * count;
+			};
+
+		for (const auto pType : InfantryTypeClass::Array)
+			updateDrainForThisType(pType);
+		for (const auto pType : UnitTypeClass::Array)
+			updateDrainForThisType(pType);
+		for (const auto pType : AircraftTypeClass::Array)
+			updateDrainForThisType(pType);
+		// Don't do this for buildings, they've already been counted.
+	}
+
+	HouseExt::CalculatePowerSurplus(pThis);
 
 	return 0;
 }

src/Ext/House/Hooks.cpp

@@ -69,7 +69,9 @@ void RulesExt::ExtData::InitializeConstants()
 // earliest loader - can't really do much because nothing else is initialized yet, so lookups won't work
 void RulesExt::ExtData::LoadFromINIFile(CCINIClass* pINI)
 {
+	INI_EX exINI(pINI);
 
+	this->DefaultToGuardArea.Read(exINI, GameStrings::General, "DefaultToGuardArea");
 }
 
 void RulesExt::ExtData::LoadBeforeTypeData(RulesClass* pThis, CCINIClass* pINI)
@@ -171,6 +173,7 @@ void RulesExt::ExtData::LoadBeforeTypeData(RulesClass* pThis, CCINIClass* pINI)
 	this->ForbidParallelAIQueues_Vehicle.Read(exINI, "GlobalControls", "ForbidParallelAIQueues.Vehicle");
 
 	this->EnablePowerSurplus.Read(exINI, GameStrings::AI, "EnablePowerSurplus");
+	this->PowerSurplus_ScaleToDrainAmount.Read(exINI, GameStrings::AI, "PowerSurplus.ScaleToDrainAmount");
 
 	this->AllowDeployControlledMCV.Read(exINI, GameStrings::General, "AllowDeployControlledMCV");
 
@@ -356,6 +359,11 @@ void RulesExt::ExtData::LoadBeforeTypeData(RulesClass* pThis, CCINIClass* pINI)
 	this->AutoTarget_NoThreatBuildings.Read(exINI, GameStrings::General, "AutoTarget.NoThreatBuildings");
 	this->AutoTargetAI_NoThreatBuildings.Read(exINI, GameStrings::General, "AutoTargetAI.NoThreatBuildings");
 
+	this->ParadropMission.Read(exINI, GameStrings::General, "ParadropMission");
+	this->AIParadropMission.Read(exINI, GameStrings::General, "AIParadropMission");
+
+	this->CylinderRangefinding.Read(exINI, GameStrings::General, "CylinderRangefinding");
+	
 	this->DisableOveroptimizationInTargeting.Read(exINI, GameStrings::General, "DisableOveroptimizationInTargeting");
 
 	// Section AITargetTypes
@@ -506,6 +514,7 @@ void RulesExt::ExtData::Serialize(T& Stm)
 		.Process(this->ForbidParallelAIQueues_Navy)
 		.Process(this->ForbidParallelAIQueues_Vehicle)
 		.Process(this->EnablePowerSurplus)
+		.Process(this->PowerSurplus_ScaleToDrainAmount)
 		.Process(this->AllowDeployControlledMCV)
 		.Process(this->TypeSelectUseIFVMode)
 		.Process(this->IronCurtain_KeptOnDeploy)
@@ -652,6 +661,10 @@ void RulesExt::ExtData::Serialize(T& Stm)
 		.Process(this->ExtraRange_Prefiring_IncludeBurst)
 		.Process(this->AutoTarget_NoThreatBuildings)
 		.Process(this->AutoTargetAI_NoThreatBuildings)
+		.Process(this->ParadropMission)
+		.Process(this->AIParadropMission)
+		.Process(this->DefaultToGuardArea)
+		.Process(this->CylinderRangefinding)
 		.Process(this->DisableOveroptimizationInTargeting)
 		;
 }

src/Ext/Rules/Body.cpp

@@ -1,4 +1,4 @@
-#pragma once
+#pragma once
 
 #include <RulesClass.h>
 #include <Utilities/Container.h>
@@ -111,6 +111,7 @@ class RulesExt
 		Valueable<bool> ForbidParallelAIQueues_Vehicle;
 
 		Valueable<bool> EnablePowerSurplus;
+		Valueable<int> PowerSurplus_ScaleToDrainAmount;
 
 		Valueable<bool> DisplayIncome;
 		Valueable<bool> DisplayIncome_AllowAI;
@@ -306,8 +307,15 @@ class RulesExt
 		Valueable<bool> AutoTarget_NoThreatBuildings;
 		Valueable<bool> AutoTargetAI_NoThreatBuildings;
 
-		Valueable<bool> DisableOveroptimizationInTargeting;
+		Valueable<Mission> ParadropMission;
+		Valueable<Mission> AIParadropMission;
+
+		Valueable<bool> DefaultToGuardArea;
 
+		Valueable<bool> CylinderRangefinding;
+
+		Valueable<bool> DisableOveroptimizationInTargeting;
+
 		ExtData(RulesClass* OwnerObject) : Extension<RulesClass>(OwnerObject)
 			, Storage_TiberiumIndex { -1 }
 			, HarvesterDumpAmount { 0.0f }
@@ -390,6 +398,7 @@ class RulesExt
 			, ForbidParallelAIQueues_Vehicle { false }
 
 			, EnablePowerSurplus { false }
+			, PowerSurplus_ScaleToDrainAmount { 0 }
 
 			, AllowDeployControlledMCV { false }
 
@@ -557,6 +566,13 @@ class RulesExt
 			, AutoTarget_NoThreatBuildings { false }
 			, AutoTargetAI_NoThreatBuildings { true }
 
+			, ParadropMission { Mission::Guard }
+			, AIParadropMission { Mission::Hunt }
+
+			, DefaultToGuardArea { false }
+			
+			, CylinderRangefinding { false }
+			
 			, DisableOveroptimizationInTargeting { false }
 		{ }