New AI Teams Selector

CREDITS.md

@@ -149,6 +149,7 @@ This page lists all the individual contributions to the project by their author.
   - Warhead activation target health thresholds enhancements
   - Event 606: AttachEffect is attaching to a Techno
   - Linked superweapons
+  - New AI teams selector
 - **Starkku**:
   - Misc. minor bugfixes & improvements
   - AI script actions:

Phobos.vcxproj

@@ -61,13 +61,16 @@
     <ClCompile Include="src\Ext\Bullet\Trajectories\PhobosTrajectory.cpp" />
     <ClCompile Include="src\Ext\Bullet\Trajectories\StraightTrajectory.cpp" />
     <ClCompile Include="src\Ext\Bullet\Trajectories\ParabolaTrajectory.cpp" />
+    <ClCompile Include="src\Ext\HouseType\Body.cpp" />
     <ClCompile Include="src\Ext\CaptureManager\Hooks.cpp" />
     <ClCompile Include="src\Ext\CaptureManager\Body.cpp" />
+    <ClCompile Include="src\Ext\House\Body.Prerequisites.cpp" />
     <ClCompile Include="src\Ext\OverlayType\Body.cpp" />
     <ClCompile Include="src\Ext\OverlayType\Hooks.cpp" />
     <ClCompile Include="src\Ext\ParticleType\Body.cpp" />
     <ClCompile Include="src\Ext\ParticleType\Hooks.cpp" />
     <ClCompile Include="src\Ext\Scenario\Hooks.cpp" />
+    <ClCompile Include="src\Ext\Scenario\Hooks.NewTeamsSelector.cpp" />
     <ClCompile Include="src\Ext\Scenario\Hooks.Variables.cpp" />
     <ClCompile Include="src\Ext\Sidebar\Body.cpp" />
     <ClCompile Include="src\Ext\Sidebar\Hooks.cpp" />
@@ -79,6 +82,7 @@
     <ClCompile Include="src\Ext\TAction\Body.cpp" />
     <ClCompile Include="src\Ext\TAction\Hooks.cpp" />
     <ClCompile Include="src\Ext\Team\Body.cpp" />
+    <ClCompile Include="src\Ext\Team\Body.NewTeamsSelector.cpp" />
     <ClCompile Include="src\Ext\Team\Hooks.cpp" />
     <ClCompile Include="src\Ext\Techno\Hooks.Pips.cpp" />
     <ClCompile Include="src\Ext\Techno\Body.Visuals.cpp" />
@@ -240,6 +244,7 @@
     <ClInclude Include="src\Ext\Bullet\Trajectories\ParabolaTrajectory.h" />
     <ClInclude Include="src\Ext\OverlayType\Body.h" />
     <ClInclude Include="src\Ext\ParticleType\Body.h" />
+    <ClInclude Include="src\Ext\HouseType\Body.h" />
     <ClInclude Include="src\Ext\Sidebar\Body.h" />
     <ClInclude Include="src\Ext\Anim\Body.h" />
     <ClInclude Include="src\Ext\Surface\Body.h" />

docs/AI-Scripting-and-Mapping.md

@@ -132,6 +132,75 @@ In `RA2MD.INI`:
 ShowBriefing=true  ; boolean
 ```
 
+## New AI Teams Selector
+
+- New AI system for selecting valid triggers in multiplayer randomly. Unlike the original method this one checks prerequisites and take care of other details.
+- It can split the valid triggers into 4 categories: ground, air, naval & mixed categories. If set, AI picks a random trigger in a random category.
+- Categories can have different chance probabilities. It can be set globally or customized per house. by default each category has a 25% chance to be selected.
+- `NewTeamsSelector.MergeUnclassifiedCategoryWith` can be used for merging the mixed category (units are from different categories) into one of the main categories.
+- In case of picking a category without valid triggers exist a fallback mode that allow picking a trigger from all valid triggers like if categories were disabled.
+- if `Autocreate=yes` AI will care about all units prerequisites so if the house's tech tree is incomplete for the trigger it gets discarded. It understand Ares tags like  `Prerequisite.RequiredTheaters`, `Prerequisite.Negative`, `Prerequisite.Lists` & `Generic prerequisites` section.
+- If it finds a trigger with 5000 current probability weight then discard valid triggers all and start searching all valid triggers with weight 5000. AI will pick 1 randomly and decrease by 1 the current weight of the selected trigger (so if nothing happens in the next teams selection loop it won't appear in this special list). Under this scenario categories are disabled.
+- Units can override the category using `ConsideredVehicle` and `ConsideredNaval` boolean tags.
+- AI is be able to use unlocked units in captured Secret Labs.
+
+In `rulesmd.ini`:
+```ini
+[AI]
+NewTeamsSelector=false                               ; boolean
+NewTeamsSelector.SplitTriggersByCategory=true        ; boolean
+NewTeamsSelector.EnableFallback=false                ; boolean
+NewTeamsSelector.GroundCategoryPercentage=0.25       ; floating point value, percents or absolute
+NewTeamsSelector.NavalCategoryPercentage=0.25        ; floating point value, percents or absolute
+NewTeamsSelector.AirCategoryPercentage=0.25          ; floating point value, percents or absolute
+NewTeamsSelector.UnclassifiedCategoryPercentage=0.25 ; floating point value, percents or absolute
+NewTeamsSelector.MergeUnclassifiedCategoryWith=-1    ; Integer - Ground: 1, Air: 2, Naval: 3
+
+[SOMEHOUSE]                                       ; HouseType
+NewTeamsSelector.MergeUnclassifiedCategoryWith=   ; boolean
+NewTeamsSelector.UnclassifiedCategoryPercentage=  ; floating point value, percents or absolute
+NewTeamsSelector.GroundCategoryPercentage=        ; floating point value, percents or absolute
+NewTeamsSelector.AirCategoryPercentage            ; floating point value, percents or absolute
+NewTeamsSelector.NavalCategoryPercentage          ; floating point value, percents or absolute
+
+[SOMETECHNO]        ; TechnoType
+ConsideredNaval=    ; boolean
+ConsideredVehicle=  ; boolean
+```
+
+- Modified slightly AI Trigger conditions 0 (enemy owns ...), 1 (house owns ...) and 7 (civilian owns ...) and added 10 new conditions (from 8 to 17) that check lists of objects instead of only 1 unit. The first 3 were modified because the objects counters weren't updated in real-time. The possible modified and new cases are:
+
+| *Condition* | *List of objects* | *Description*                                   |
+| :---------: | :---------------: | :---------------------------------------------: |
+| 0 (changed) | No                | Count objects of the main enemy. If AI house doesn't have a main enemy It will search in all enemies. In vanilla YR if house doesn't have a main enemy this condition fail |
+| 1 (changed) | No                | Count own objects |
+| 7 (changed) | No                | Count civilian objects |
+| 8           | No                | Count enemy objects. It will search in all enemies |
+| 9           | Yes               | Count enemy objects. If AI house doesn't have a main enemy It will search in all enemies. |
+| 10          | Yes               | Count own objects |
+| 11          | Yes               | Count civilian objects |
+| 12          | Yes               | Count enemy objects. It will search in all enemies |
+| 13          | Yes               | Count objects from allies |
+| 14          | Yes               | Count enemy objects. If AI house doesn't have a main enemy It will search in all enemies. It uses `AND` comparator so each object must obey the same comparations |
+| 15          | Yes               | Count own objects. It uses `AND` comparator so each object must obey the same comparations |
+| 16          | Yes               | Count civilian objects. It uses `AND` comparator so each object must obey the same comparations |
+| 17          | Yes               | Count enemy objects. It will search in all enemies. It uses `AND` comparator so each object must obey the same comparations |
+| 18          | No                | Count structures with `BridgeRepairHut=yes` linked with destroyed bridges |
+| 19          | No                | Count structures with `BridgeRepairHut=yes` linked with undamaged bridges |
+
+- Some trigger conditions need to specify a 0-based list from `[AITargetTypes]`. The index of the list is written in hexadecimal and in little endian format. The value must be written at the end of the trigger:
+`00000000000000000000000000000000000000000000000000000000AABBCCDD`
+For example: list 0 is written 00 (put it in AA), list 1 is written 01 (put it in AA), list 10 is written 0A (put it in AA), 255 is 0xFF (put it in AA) and 256 is 0x0001 (put it in AABB), etc.
+- The *`AITargetTypes` index#* values are obtained in the new `AITargetTypes` section that must be declared in `rulesmd.ini`:
+
+In `rulesmd.ini`:
+```ini
+[AITargetTypes]  ; List of TechnoType lists
+0=SOMETECHNOTYPE,SOMEOTHERTECHNOTYPE,SAMPLETECHNOTYPE
+1=ANOTHERTECHNOTYPE,YETANOTHERTECHNOTYPE
+; ...
+```
+
 ## Script Actions
 
 ### `10000-10999` Ingame Actions

docs/Whats-New.md

@@ -462,6 +462,7 @@ New:
 - Customizable ROF random delay (by Starkku)
 - Animation with `Tiled=yes` now supports `CustomPalette` (by ststl)
 - Toggleable `DieSound` when grinding (by Trsdy)
+- New AI teams selector (by FS-21)
 - Shields can inherit Techno ArmorType (by Starkku)
 - Income money flying-string display when harvesters or slaves are docking to refineries or when spies steal credits (by Trsdy)
 - Allow random crates to be generated only on lands (by Trsdy)

src/Ext/Building/Body.cpp

@@ -3,6 +3,7 @@
 #include <BitFont.h>
 
 #include <Utilities/EnumFunctions.h>
+#include <Ext/House/Body.h>
 
 BuildingExt::ExtContainer BuildingExt::ExtMap;
 
@@ -451,6 +452,125 @@ const std::vector<CellStruct> BuildingExt::GetFoundationCells(BuildingClass* con
 	return foundationCells;
 }
 
+// Assigns a secret production option to the AI building (Ares doesn't handle the AI case).
+void BuildingExt::ExtData::UpdateSecretLabAI()
+{
+	auto pThis = this->OwnerObject();
+	auto pOwner = pThis->Owner;
+
+	if (!pOwner || pOwner->Type->MultiplayPassive || pOwner->IsControlledByHuman())
+		return;
+
+	auto pType = pThis->Type;
+
+	// Fixed item, no need to randomize
+	if (pType->SecretInfantry || pType->SecretUnit || pType->SecretBuilding)
+		return;
+
+	auto pDataType = BuildingTypeExt::ExtMap.Find(pType);
+
+	// If Secret Lab already picked a techno and isn't allowed to recalculate it again the function ends
+	if (this->SecretLab_Placed && !pDataType->Secret_RecalcOnCapture)
+		return;
+
+	DynamicVectorClass<TechnoTypeClass*> validCandidates;
+	DynamicVectorClass<TechnoTypeClass*> possibleCandidates;
+
+	if (pDataType->PossibleBoons.size() > 0)
+	{
+		for (const auto& boon : pDataType->PossibleBoons)
+		{
+			possibleCandidates.AddItem(boon);
+		}
+	}
+	else
+	{
+		for (const auto& boon : RulesClass::Instance->SecretInfantry)
+		{
+			possibleCandidates.AddItem(boon);
+		}
+
+		for (const auto& boon : RulesClass::Instance->SecretUnits)
+		{
+			possibleCandidates.AddItem(boon);
+		}
+
+		for (const auto& boon : RulesClass::Instance->SecretBuildings)
+		{
+			possibleCandidates.AddItem(boon);
+		}
+	}
+
+	if (possibleCandidates.Count > 0)
+	{
+		std::map<BuildingTypeClass*, int> ownedBuildings;
+
+		for (auto building : pOwner->Buildings)
+		{
+			++ownedBuildings[building->Type];
+		}
+
+		for (const auto& boon : possibleCandidates)
+		{
+			auto pExt = TechnoTypeExt::ExtMap.Find(boon);
+			bool isRequiredHouse = true; // Default value if Secret.RequiredHouses isn't declared
+
+			if (pExt->Secret_RequiredHouses.size() > 0)
+				isRequiredHouse = false;
+
+			for (const auto houseId : pExt->Secret_RequiredHouses)
+			{
+				int houseIdx = HouseTypeClass::FindIndex(houseId.c_str());
+				if (houseIdx < 0)
+					continue;
+
+				if (pOwner->Type->ArrayIndex == houseIdx)
+				{
+					bool canBeBuilt = HouseExt::PrerequisitesMet(pOwner, boon, ownedBuildings, true);
+
+					if (canBeBuilt)
+					{
+						isRequiredHouse = true;
+						break;
+					}
+				}
+			}
+
+			bool isForbiddenHouse = false; // Default value if Secret.ForbiddenHouses isn't declared
+
+			for (const auto houseId : pExt->Secret_ForbiddenHouses)
+			{
+				int houseIdx = HouseTypeClass::FindIndex(houseId.c_str());
+				if (houseIdx < 0)
+					continue;
+
+				if (pOwner->Type->ArrayIndex == houseIdx)
+				{
+					isForbiddenHouse = true;
+					break;
+				}
+			}
+
+			if (isRequiredHouse && !isForbiddenHouse)
+				validCandidates.AddItem(boon);
+		}
+	}
+
+	// pick one of all eligible items
+	if (validCandidates.Count > 0)
+	{
+		auto result = validCandidates[ScenarioClass::Instance->Random.RandomRanged(0, validCandidates.Count - 1)];
+		Debug::Log("[Secret Lab AI] rolled %s for %s\n", result->ID, pType->ID);
+		pThis->SecretProduction = result;
+		this->SecretLab_Placed = true;
+	}
+	else
+	{
+		Debug::Log("[Secret Lab AI] %s has no boons applicable to country [%s]!\n",
+			pType->ID, pOwner->Type->ID);
+	}
+}
+
 // =============================
 // load / save
 
@@ -466,6 +586,7 @@ void BuildingExt::ExtData::Serialize(T& Stm)
 		.Process(this->GrindingWeapon_LastFiredFrame)
 		.Process(this->GrindingWeapon_AccumulatedCredits)
 		.Process(this->CurrentAirFactory)
+		.Process(this->SecretLab_Placed)
 		.Process(this->AccumulatedIncome)
 		.Process(this->CurrentLaserWeaponIndex)
 		.Process(this->PoweredUpToLevel)

src/Ext/Building/Body.h

@@ -34,6 +34,7 @@ class BuildingExt
 		int GrindingWeapon_LastFiredFrame;
 		int GrindingWeapon_AccumulatedCredits;
 		BuildingClass* CurrentAirFactory;
+		bool SecretLab_Placed;
 		int AccumulatedIncome;
 		std::optional<int> CurrentLaserWeaponIndex;
 		int PoweredUpToLevel; // Distinct from UpgradeLevel, and set to highest PowersUpToLevel out of applied upgrades regardless of how many are currently applied to this building.
@@ -48,6 +49,7 @@ class BuildingExt
 			, GrindingWeapon_LastFiredFrame { 0 }
 			, GrindingWeapon_AccumulatedCredits { 0 }
 			, CurrentAirFactory { nullptr }
+			, SecretLab_Placed { false }
 			, AccumulatedIncome { 0 }
 			, CurrentLaserWeaponIndex {}
 			, PoweredUpToLevel { 0 }
@@ -58,6 +60,8 @@ class BuildingExt
 		void ApplyPoweredKillSpawns();
 		bool HasSuperWeapon(int index, bool withUpgrades) const;
 		bool HandleInfiltrate(HouseClass* pInfiltratorHouse, int moneybefore);
+		void UpdateSecretLabAI();
+
 		void UpdatePrimaryFactoryAI();
 		virtual ~ExtData() = default;
 

src/Ext/Building/Hooks.cpp

@@ -794,6 +794,19 @@ DEFINE_HOOK(0x4AE95E, DisplayClass_sub_4AE750_DisallowBuildingNonAttackPlanning,
 
 #pragma endregion
 
+DEFINE_HOOK(0x445F80, BuildingClass_GrandOpening_UpdateSecretLabAI, 0x5)
+{
+	GET(BuildingClass*, pThis, ECX);
+
+	if (pThis->Type->SecretLab && !pThis->Owner->IsControlledByHuman())
+	{
+		auto pExt = BuildingExt::ExtMap.Find(pThis);
+		pExt->UpdateSecretLabAI();
+	}
+
+	return 0;
+}
+
 DEFINE_HOOK(0x4400F9, BuildingClass_AI_UpdateOverpower, 0x6)
 {
 	enum { SkipGameCode = 0x44019D };

src/Ext/BuildingType/Body.cpp

@@ -195,6 +195,22 @@ void BuildingTypeExt::ExtData::LoadFromINIFile(CCINIClass* const pINI)
 	this->BunkerWallsDownSound.Read(exINI, pSection, "BunkerWallsDownSound");
 	this->BuildingRepairedSound.Read(exINI, pSection, "BuildingRepairedSound");
 
+	this->Secret_RecalcOnCapture.Read(exINI, pSection, "SecretLab.GenerateOnCapture");
+
+	// Secret.Boons contains a list of TechnoTypeClass IDs
+	const char* key = "SecretLab.PossibleBoons";
+	char* context = nullptr;
+	pINI->ReadString(pSection, key, "", Phobos::readBuffer);
+
+	for (char* cur = strtok_s(Phobos::readBuffer, Phobos::readDelims, &context); cur; cur = strtok_s(nullptr, Phobos::readDelims, &context))
+	{
+		int index = TechnoTypeClass::FindIndex(cur);
+		if (index != -1)
+			this->PossibleBoons.push_back(TechnoTypeClass::Array.GetItem(index));
+	}
+
+	key = nullptr;
+
 	if (pThis->NumberOfDocks > 0)
 	{
 		this->AircraftDockingDirs.clear();
@@ -309,6 +325,8 @@ void BuildingTypeExt::ExtData::Serialize(T& Stm)
 		.Process(this->ConsideredVehicle)
 		.Process(this->ZShapePointMove_OnBuildup)
 		.Process(this->SellBuildupLength)
+		.Process(this->Secret_RecalcOnCapture)
+		.Process(this->PossibleBoons)
 		.Process(this->AircraftDockingDirs)
 		.Process(this->FactoryPlant_AllowTypes)
 		.Process(this->FactoryPlant_DisallowTypes)

src/Ext/BuildingType/Body.h

@@ -66,6 +66,9 @@ class BuildingTypeExt
 
 		Valueable<bool> IsAnimDelayedBurst;
 
+		Valueable<bool> Secret_RecalcOnCapture;
+		NullableVector<TechnoTypeClass*> PossibleBoons;
+
 		std::vector<std::optional<DirType>> AircraftDockingDirs;
 
 		ValueableVector<TechnoTypeClass*> FactoryPlant_AllowTypes;
@@ -136,6 +139,8 @@ class BuildingTypeExt
 			, ConsideredVehicle {}
 			, ZShapePointMove_OnBuildup { false }
 			, SellBuildupLength { 23 }
+			, Secret_RecalcOnCapture { false }
+			, PossibleBoons {}
 			, AircraftDockingDirs {}
 			, FactoryPlant_AllowTypes {}
 			, FactoryPlant_DisallowTypes {}