reimplement OpenSHC::AI::AICState

cmake/compiler-flags-gl.txt

@@ -16,4 +16,5 @@ src/OpenSHC/Audio/SFX/SFXState/playUnitSpeech.cpp
 src/OpenSHC/Game/GameStateStructures/getSellResourceAmount.cpp
 src/OpenSHC/Map/TileMapState/determineBuildingPlacementRotation.cpp
 src/OpenSHC/Map/Navigation/DirectionAlgorithmState/getMouseVectorLengthBasedOnDirection.cpp
-src/OpenSHC/Input/MouseState/updateRightDragCameraControl.cpp
+src/OpenSHC/Input/MouseState/updateRightDragCameraControl.cpp
+src/OpenSHC/AI/AICState/planToBuyWhenLowOnResourceAndSnoozeBuildings.cpp

src/OpenSHC/AI/AICState.func.hpp

@@ -631,7 +631,7 @@ namespace AI {
         decideOnTribeAttackLocation;
 
         MACRO_FUNCTION_RESOLVER(
-            void (AICState::*)(int), false, Address::SHC_3BB0A8C1_0x004D1D60, &AICState::sellExcessGoods)
+            void (AICState::*)(int), true, Address::SHC_3BB0A8C1_0x004D1D60, &AICState::sellExcessGoods)
         sellExcessGoods;
 
         MACRO_FUNCTION_RESOLVER(void (AICState::*)(int, ResourceType, int), false, Address::SHC_3BB0A8C1_0x004D1F00,
@@ -715,7 +715,7 @@ namespace AI {
         makeOutpostTribesAttack;
 
         MACRO_FUNCTION_RESOLVER(
-            void (AICState::*)(int), false, Address::SHC_3BB0A8C1_0x004D39B0, &AICState::buyRequiredGoods)
+            void (AICState::*)(int), true, Address::SHC_3BB0A8C1_0x004D39B0, &AICState::buyRequiredGoods)
         buyRequiredGoods;
 
         MACRO_FUNCTION_RESOLVER(

src/OpenSHC/AI/AICState/Constructor_AICState.cpp

@@ -0,0 +1,14 @@
+#include "../AICState.func.hpp"
+
+namespace OpenSHC {
+namespace AI {
+
+    // FUNCTION: STRONGHOLDCRUSADER 0x004D3940
+    AICState* AICState::Constructor_AICState()
+    {
+        MACRO_CALL_MEMBER(AICState_Func::setInitialAIC, this)();
+        this->aiTauntResponseTimeWindow = 0;
+        return this;
+    }
+}
+}

src/OpenSHC/AI/AICState/abortAttackAndGoIdle.cpp

@@ -0,0 +1,23 @@
+#include "../AICState.func.hpp"
+
+#include "OpenSHC/Map/Buildings/BuildingsState.func.hpp"
+
+#include "OpenSHC/Globals/DAT_BuildingsState.hpp"
+#include "OpenSHC/Globals/DAT_GameState.hpp"
+
+namespace OpenSHC {
+namespace AI {
+
+    // FUNCTION: STRONGHOLDCRUSADER 0x004D45E0
+    void AICState::abortAttackAndGoIdle(int playerID)
+    {
+        MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::removeSiegeBuildings, DAT_BuildingsState::ptr)(
+            DAT_GameState::instance.playerDataArray[playerID].currentAttackWave, playerID);
+        MACRO_CALL_MEMBER(AICState_Func::disbandAIPlayerSiegeUnits, this)(playerID);
+        MACRO_CALL_MEMBER(AICState_Func::addEngineersToTribe, this)(playerID);
+        MACRO_CALL_MEMBER(AICState_Func::aiReassignTunnelersToTribe, this)(playerID);
+        DAT_GameState::instance.playerDataArray[playerID].aiPlayerState = 0;
+    }
+
+}
+}

src/OpenSHC/AI/AICState/addBuildingToTargetableBuildings.cpp

@@ -0,0 +1,30 @@
+#include "../AICState.func.hpp"
+
+#include "OpenSHC/Game/GameMode.hpp"
+
+#include "OpenSHC/Globals/DAT_BuildingsState.hpp"
+#include "OpenSHC/Globals/DAT_GameState.hpp"
+#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp"
+
+namespace OpenSHC {
+namespace AI {
+
+    // FUNCTION: STRONGHOLDCRUSADER 0x004CDA50
+    void AICState::addBuildingToTargetableBuildings(int buildingID)
+    {
+        int owner = DAT_BuildingsState::instance.buildings[buildingID].owner;
+        if (DAT_GameSynchronyState::instance.currentGameMode == Game::GM_SOLITARY)
+            return;
+        if (DAT_GameState::instance.playerDataArray[owner].top100TargetableBuildingsTracker >= 100)
+            return;
+        if (DAT_BuildingsState::instance.buildings[buildingID].fireDuration != 0)
+            return;
+
+        DAT_GameState::instance.playerDataArray[owner]
+            .top100TargetableBuildings[DAT_GameState::instance.playerDataArray[owner].top100TargetableBuildingsTracker]
+            = buildingID;
+        DAT_GameState::instance.playerDataArray[owner].top100TargetableBuildingsTracker++;
+    }
+
+}
+}

src/OpenSHC/AI/AICState/addEngineersToSelection.cpp

@@ -0,0 +1,44 @@
+#include "../AICState.func.hpp"
+
+#include "OpenSHC/Map/Units/TribesState.func.hpp"
+#include "OpenSHC/Map/Units/States/UnitState.hpp"
+#include "OpenSHC/Map/Units/UnitLogicState.hpp"
+#include "OpenSHC/Map/Units/UnitType.hpp"
+
+#include "OpenSHC/Globals/DAT_TribesState.hpp"
+#include "OpenSHC/Globals/DAT_UnitsState.hpp"
+
+namespace OpenSHC {
+namespace AI {
+
+    // FUNCTION: STRONGHOLDCRUSADER 0x004CC680
+    int AICState::addEngineersToSelection(int playerID, int unitCount)
+    {
+        int tribeID
+            = MACRO_CALL_MEMBER(Map::Units::TribesState_Func::createTribeForPlayer, DAT_TribesState::ptr)(playerID);
+        for (int unitID = 1; unitID < (int)DAT_UnitsState::instance.maxUnitCount; unitID++) {
+            if (unitCount <= 0)
+                break;
+            if (DAT_UnitsState::instance.units[unitID].logicalState != Map::Units::ULS_NORMAL)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].owner != playerID)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].dying != 0)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].unitType != Map::Units::UT_E_ENGINEER)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].aiUnitBehaviourType != 10)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].tribeID != 0)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].state.generic == Map::Units::States::US_STAND_UPUnk)
+                continue;
+
+            MACRO_CALL_MEMBER(Map::Units::TribesState_Func::addUnitToTribe, DAT_TribesState::ptr)(unitID, tribeID);
+            unitCount--;
+        }
+        return tribeID;
+    }
+
+}
+}

src/OpenSHC/AI/AICState/addEngineersToTribe.cpp

@@ -0,0 +1,33 @@
+#include "../AICState.func.hpp"
+
+#include "OpenSHC/Map/Units/UnitLogicState.hpp"
+#include "OpenSHC/Map/Units/UnitType.hpp"
+
+#include "OpenSHC/Globals/DAT_UnitsState.hpp"
+
+namespace OpenSHC {
+namespace AI {
+
+    // FUNCTION: STRONGHOLDCRUSADER 0x004D4040
+    void AICState::addEngineersToTribe(int playerID)
+    {
+        for (int unitID = 1; unitID < (int)DAT_UnitsState::instance.maxUnitCount; unitID++) {
+            if (DAT_UnitsState::instance.units[unitID].logicalState != Map::Units::ULS_NORMAL)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].owner != playerID)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].dying != 0)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].unitType != Map::Units::UT_E_ENGINEER)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].aiUnitBehaviourType != 10)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].tribeID != 0)
+                continue;
+
+            MACRO_CALL_MEMBER(AICState_Func::addUnitToItsTribe, this)(unitID, 10);
+        }
+    }
+
+}
+}

src/OpenSHC/AI/AICState/addRallyPointForTribe.cpp

@@ -0,0 +1,57 @@
+#include "../AICState.func.hpp"
+
+#include "OpenSHC/Game/GameStateStructures.func.hpp"
+#include "OpenSHC/Map/Navigation/PathFindingState.func.hpp"
+#include "OpenSHC/Map/Units/UnitLogicState.hpp"
+#include "OpenSHC/Map/Units/UnitType.hpp"
+#include "OpenSHC/WindowsHelper/Enums/BOOLEnum.hpp"
+
+#include "OpenSHC/Globals/DAT_GameState.hpp"
+#include "OpenSHC/Globals/DAT_PathFindingState.hpp"
+#include "OpenSHC/Globals/DAT_TribesState.hpp"
+#include "OpenSHC/Globals/DAT_UnitsState.hpp"
+
+namespace OpenSHC {
+namespace AI {
+
+    // FUNCTION: STRONGHOLDCRUSADER 0x004CFA10
+    void AICState::addRallyPointForTribe(int tribeID)
+    {
+        DAT_TribesState::instance.tribes[tribeID].rallyPointCount = 0;
+        for (int unitID = 1; unitID < 2500; unitID++) {
+            if (DAT_UnitsState::instance.units[unitID].logicalState == OpenSHC::Map::Units::ULS_INVISIBLE)
+                continue;
+            if (MACRO_CALL_MEMBER(OpenSHC::Game::GameStateStructures_Func::getTeamsDifferent, DAT_GameState::ptr)(
+                    DAT_TribesState::instance.tribes[tribeID].owner, DAT_UnitsState::instance.units[unitID].owner)
+                != FALSE)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].unitType != OpenSHC::Map::Units::UT_S_CATAPULT
+                && DAT_UnitsState::instance.units[unitID].unitType != OpenSHC::Map::Units::UT_S_TREBUCHET
+                && DAT_UnitsState::instance.units[unitID].unitType != OpenSHC::Map::Units::UT_S_FBALLISTA)
+                continue;
+            if (DAT_UnitsState::instance.units[unitID].unknownSiegeTentRelated02 != 3)
+                continue;
+
+            MACRO_CALL_MEMBER(OpenSHC::Map::Navigation::PathFindingState_Func::computeNextRallyPointDestination,
+                DAT_PathFindingState::ptr)(
+                -1, DAT_UnitsState::instance.units[unitID].x, DAT_UnitsState::instance.units[unitID].y);
+            DAT_TribesState::instance.tribes[tribeID]
+                .rallyPointArray[DAT_TribesState::instance.tribes[tribeID].rallyPointCount][0]
+                = DAT_PathFindingState::instance.ALG_ResultX;
+            DAT_TribesState::instance.tribes[tribeID]
+                .rallyPointArray[DAT_TribesState::instance.tribes[tribeID].rallyPointCount][1]
+                = DAT_PathFindingState::instance.ALG_ResultY;
+            DAT_TribesState::instance.tribes[tribeID].rallyPointCount++;
+            if (DAT_TribesState::instance.tribes[tribeID].rallyPointCount >= 9)
+                break;
+        }
+
+        if (DAT_TribesState::instance.tribes[tribeID].currentRallyPointIndex < 0)
+            DAT_TribesState::instance.tribes[tribeID].currentRallyPointIndex = 0;
+        if (DAT_TribesState::instance.tribes[tribeID].currentRallyPointIndex
+            >= DAT_TribesState::instance.tribes[tribeID].rallyPointCount)
+            DAT_TribesState::instance.tribes[tribeID].currentRallyPointIndex = 0;
+    }
+
+}
+}

src/OpenSHC/AI/AICState/addUnitToItsTribe.cpp

@@ -0,0 +1,27 @@
+#include "../AICState.func.hpp"
+
+#include "OpenSHC/Map/Units/TribesState.func.hpp"
+#include "OpenSHC/AI/AITypeA.hpp"
+
+#include "OpenSHC/Globals/DAT_GameState.hpp"
+#include "OpenSHC/Globals/DAT_TribesState.hpp"
+#include "OpenSHC/Globals/DAT_UnitsState.hpp"
+
+namespace OpenSHC {
+namespace AI {
+
+    // FUNCTION: STRONGHOLDCRUSADER 0x004D27E0
+    void AICState::addUnitToItsTribe(int unitID, int aiUnitBehaviourType)
+    {
+        int owner = DAT_UnitsState::instance.units[unitID].owner;
+        if (DAT_GameState::instance.playerDataArray[owner].aiType == AITA_NULL)
+            return;
+
+        DAT_UnitsState::instance.units[unitID].aiUnitBehaviourType = aiUnitBehaviourType;
+        int tribeID = MACRO_CALL_MEMBER(AICState_Func::addUnitToSmallestBehaviourTypeTribe, this)(
+            owner, unitID, aiUnitBehaviourType);
+        if (tribeID != 0)
+            MACRO_CALL_MEMBER(Map::Units::TribesState_Func::addUnitToTribe, DAT_TribesState::ptr)(unitID, tribeID);
+    }
+}
+}

src/OpenSHC/AI/AICState/addUnitToSmallestBehaviourTypeTribe.cpp

@@ -0,0 +1,82 @@
+#include "OpenSHC/Map/Units/TribesState.func.hpp"
+#include "OpenSHC/AI/AICState.hpp"
+#include "OpenSHC/AI/AITypeA.hpp"
+
+#include "OpenSHC/Globals/DAT_GameState.hpp"
+#include "OpenSHC/Globals/DAT_SkirmishDefinedData.hpp"
+#include "OpenSHC/Globals/DAT_TribesState.hpp"
+
+namespace OpenSHC {
+namespace AI {
+
+    // FUNCTION: STRONGHOLDCRUSADER 0x004CCD20
+    int AICState::addUnitToSmallestBehaviourTypeTribe(
+        undefined4 playerID, undefined4 unitID, undefined4 aiUnitBehaviourType)
+    {
+        int aiType = DAT_GameState::instance.playerDataArray[playerID].aiType;
+        if (aiType == AITA_NULL)
+            return 0;
+
+        int aicIndex = aiType - 1;
+        int groupsCount;
+        switch (DAT_SkirmishDefinedData::instance.AIUnitBehaviourTypeMapping[aiUnitBehaviourType - 10]) {
+        case 15:
+            groupsCount = this->aics[aicIndex].AttUnitPatrolGroupsCount;
+            break;
+        case 186:
+            groupsCount = this->aics[aicIndex].AttUnitBackupGroupsCount;
+            break;
+        case 190:
+            groupsCount = this->aics[aicIndex].AttUnitSiegeDefGroupsCount;
+            break;
+        case 192:
+            groupsCount = this->aics[aicIndex].AttMainGroupsCount;
+            break;
+        default:
+            groupsCount = 1;
+            break;
+        }
+
+        int selectedTribeID = 0;
+        int selectedSlot = 0;
+        if (groupsCount <= 1) {
+            int tribeID = DAT_GameState::instance.playerDataArray[playerID].aiTribeIDs[DAT_SkirmishDefinedData::instance
+                    .AIUnitBehaviourTypeMapping[aiUnitBehaviourType - 10]];
+            if (tribeID != 0
+                && DAT_TribesState::instance.tribes[tribeID].uid
+                    == DAT_GameState::instance.playerDataArray[playerID].aiTribeUIDs[DAT_SkirmishDefinedData::instance
+                            .AIUnitBehaviourTypeMapping[aiUnitBehaviourType - 10]])
+                return tribeID;
+            selectedTribeID
+                = MACRO_CALL_MEMBER(Map::Units::TribesState_Func::createTribeForPlayer, DAT_TribesState::ptr)(playerID);
+            selectedSlot = DAT_SkirmishDefinedData::instance.AIUnitBehaviourTypeMapping[aiUnitBehaviourType - 10];
+        } else {
+            int smallestSize = 1000;
+            for (int slot = DAT_SkirmishDefinedData::instance.AIUnitBehaviourTypeMapping[aiUnitBehaviourType - 10]; slot
+                < DAT_SkirmishDefinedData::instance.AIUnitBehaviourTypeMapping[aiUnitBehaviourType - 10] + groupsCount;
+                slot++) {
+                int tribeID = DAT_GameState::instance.playerDataArray[playerID].aiTribeIDs[slot];
+                if (tribeID == 0
+                    || DAT_TribesState::instance.tribes[tribeID].uid
+                        != DAT_GameState::instance.playerDataArray[playerID].aiTribeUIDs[slot]) {
+                    selectedTribeID = MACRO_CALL_MEMBER(
+                        Map::Units::TribesState_Func::createTribeForPlayer, DAT_TribesState::ptr)(playerID);
+                    selectedSlot = slot;
+                    break;
+                }
+                if (DAT_TribesState::instance.tribes[tribeID].size < smallestSize) {
+                    smallestSize = DAT_TribesState::instance.tribes[tribeID].size;
+                    selectedTribeID = tribeID;
+                    selectedSlot = slot;
+                }
+            }
+        }
+        if (selectedTribeID <= 0)
+            return 0;
+        DAT_GameState::instance.playerDataArray[playerID].aiTribeIDs[selectedSlot] = selectedTribeID;
+        DAT_GameState::instance.playerDataArray[playerID].aiTribeUIDs[selectedSlot]
+            = DAT_TribesState::instance.tribes[selectedTribeID].uid;
+        return selectedTribeID;
+    }
+}
+}

src/OpenSHC/AI/AICState/addUnitToSmallestPatrolTribe.cpp

@@ -0,0 +1,27 @@
+#include "../AICState.func.hpp"
+
+#include "OpenSHC/Map/Units/TribesState.func.hpp"
+#include "OpenSHC/AI/AITypeA.hpp"
+
+#include "OpenSHC/Globals/DAT_GameState.hpp"
+#include "OpenSHC/Globals/DAT_TribesState.hpp"
+#include "OpenSHC/Globals/DAT_UnitsState.hpp"
+
+namespace OpenSHC {
+namespace AI {
+
+    // FUNCTION: STRONGHOLDCRUSADER 0x004D2730
+    void AICState::addUnitToSmallestPatrolTribe(int unitID)
+    {
+        int owner = DAT_UnitsState::instance.units[unitID].owner;
+        if (DAT_GameState::instance.playerDataArray[owner].aiType == AITA_NULL)
+            return;
+        int aicIndex = DAT_GameState::instance.playerDataArray[owner].aiType - 1;
+
+        DAT_UnitsState::instance.units[unitID].aiUnitBehaviourType = 4;
+        int tribeID = MACRO_CALL_MEMBER(AICState_Func::getSmallestPatrolTribe, this)(
+            owner, this->aics[aicIndex].OuterPatrolGroupsCount);
+        MACRO_CALL_MEMBER(Map::Units::TribesState_Func::addUnitToTribe, DAT_TribesState::ptr)(unitID, tribeID);
+    }
+}
+}