reimplement OpenSHC::AI::AICState

src/OpenSHC/AI/AICState/Constructor_AICState.cpp

@@ -0,0 +1,14 @@
+#include "OpenSHC/AI/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,24 @@
+#include "../AICState.func.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 _player = DAT_BuildingsState::instance.buildings[buildingID].owner;
+        if (DAT_GameSynchronyState::instance.DAT_CurrentGameMode != Game::GM_SOLITARY) {
+            int* piVar1 = &DAT_GameState::instance.playerDataArray[_player].top100TargetableBuildingsTracker;
+            if ((*piVar1 < 100) && (DAT_BuildingsState::instance.buildings[buildingID].fireDuration == 0)) {
+                DAT_GameState::instance.playerDataArray[_player].top100TargetableBuildings[*piVar1] = (short)buildingID;
+                *piVar1 = *piVar1 + 1;
+            }
+        }
+    }
+
+}
+}

src/OpenSHC/AI/AICState/addEngineersToSelection.cpp

@@ -0,0 +1,45 @@
+#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/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;
+        uint unitID;
+
+        tribeID = MACRO_CALL_MEMBER(Map::Units::TribesState_Func::createTribeForPlayer, DAT_TribesState::ptr)(playerID);
+        unitID = 1;
+        if (1 < (int)DAT_UnitsState::instance.maxUnitCount) {
+            /* Unit offset 150 */
+            Map::Units::Unit* _ptrUnit = &DAT_UnitsState::instance.units[1];
+            do {
+                if (unitCount <= 0) {
+                    return tribeID;
+                }
+                if ((((_ptrUnit->logicalState == Map::Units::ULS_NORMAL) && (_ptrUnit->owner == playerID))
+                        && (_ptrUnit->dying == 0))
+                    && (((_ptrUnit->unitType == Map::Units::UT_E_ENGINEER) && (_ptrUnit->aiUnitBehaviourType == 10))
+                        && ((_ptrUnit->tribeID == 0)
+                            && ((_ptrUnit->state).generic != Map::Units::States::US_STAND_UPUnk)))) {
+                    MACRO_CALL_MEMBER(Map::Units::TribesState_Func::addUnitToTribe, DAT_TribesState::ptr)(
+                        unitID, tribeID);
+                    unitCount = unitCount + -1;
+                }
+                unitID = unitID + 1;
+                _ptrUnit = _ptrUnit + 1;
+            } while ((int)unitID < (int)DAT_UnitsState::instance.maxUnitCount);
+        }
+        return tribeID;
+    }
+
+}
+}

src/OpenSHC/AI/AICState/addEngineersToTribe.cpp

@@ -0,0 +1,35 @@
+#include "../AICState.func.hpp"
+
+#include "OpenSHC/Map/Units/UnitLogicState.hpp"
+
+#include "OpenSHC/Globals/DAT_UnitsState.hpp"
+
+namespace OpenSHC {
+namespace AI {
+
+    // FUNCTION: STRONGHOLDCRUSADER 0x004D4040
+    void AICState::addEngineersToTribe(int playerID)
+    {
+        int unitID;
+
+        unitID = 1;
+        if (1 < (int)DAT_UnitsState::instance.maxUnitCount) {
+            /* Unit offset 150 */
+            Map::Units::Unit* psVar1 = &DAT_UnitsState::instance.units[1];
+            do {
+                /* if logicalState == normal && owner == playerID && unitType == 0x1e (engineer)
+                   && aiUnitBehaviourType == 10 */
+                if ((((psVar1->logicalState == Map::Units::ULS_NORMAL) && (psVar1->owner == playerID))
+                        && (psVar1->dying == 0))
+                    && (((psVar1->unitType == Map::Units::UT_E_ENGINEER) && (psVar1->aiUnitBehaviourType == 10))
+                        && (psVar1->tribeID == 0))) {
+                    MACRO_CALL_MEMBER(AICState_Func::addUnitToItsTribe, this)(unitID, 10);
+                }
+                unitID = unitID + 1;
+                psVar1 = psVar1 + 1;
+            } while (unitID < (int)DAT_UnitsState::instance.maxUnitCount);
+        }
+    }
+
+}
+}

src/OpenSHC/AI/AICState/addUnitToItsTribe.cpp

@@ -0,0 +1,26 @@
+#include "OpenSHC/AI/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 iVar1 = (int)DAT_UnitsState::instance.units[unitID].owner;
+        if (DAT_GameState::instance.playerDataArray[iVar1].aiType != AITA_NULL) {
+            DAT_UnitsState::instance.units[unitID].aiUnitBehaviourType = (short)aiUnitBehaviourType;
+            iVar1 = MACRO_CALL_MEMBER(AICState_Func::addUnitToSmallestBehaviourTypeTribe, this)(
+                iVar1, unitID, aiUnitBehaviourType);
+            if (iVar1 != 0) {
+                MACRO_CALL_MEMBER(Map::Units::TribesState_Func::addUnitToTribe, DAT_TribesState::ptr)(unitID, iVar1);
+            }
+        }
+    }
+}
+}

src/OpenSHC/AI/AICState/addUnitToSmallestBehaviourTypeTribe.cpp

@@ -0,0 +1,94 @@
+#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 param_2, undefined4 aiUnitBehaviourType)
+    {
+        int _playerID = (int)playerID;
+        int AVar1 = DAT_GameState::instance.playerDataArray[_playerID].aiType;
+        if (AVar1 == AITA_NULL) {
+            return 0;
+        }
+        int _tribeTypeOffset
+            = DAT_SkirmishDefinedData::instance.DAT_AIUnitBehaviourTypeMapping[(int)aiUnitBehaviourType + -10];
+        int _smallestTribe = 0;
+        int _smallestTribeOffset = 0;
+        short _smallestTribeSize = 1000;
+        dword _groupsCount;
+        switch (_tribeTypeOffset) {
+        case 0xf:
+            _groupsCount = this->aics[AVar1 - 1].AttUnitPatrolGroupsCount;
+            break;
+        default:
+            goto switchD_004ccd78_caseD_10;
+        case 0xba:
+            _groupsCount = this->aics[AVar1 - 1].AttUnitBackupGroupsCount;
+            break;
+        case 0xbe:
+            _groupsCount = this->aics[AVar1 - 1].AttUnitSiegeDefGroupsCount;
+            break;
+        case 0xc0:
+            _groupsCount = this->aics[AVar1 - 1].AttMainGroupsCount;
+        }
+        int _selectedTribe;
+        int _selectedSlot;
+        if (((int)_groupsCount < 1) || (_groupsCount == 1)) {
+        switchD_004ccd78_caseD_10:
+            int _tribeID_groupsCount1
+                = (int)DAT_GameState::instance.playerDataArray[_playerID].aiTribeIDs[_tribeTypeOffset];
+            if ((_tribeID_groupsCount1 != 0)
+                && (DAT_TribesState::instance.tribes[_tribeID_groupsCount1].uid
+                    == DAT_GameState::instance.playerDataArray[_playerID].aiTribeUIDs[_tribeTypeOffset])) {
+                return _tribeID_groupsCount1;
+            }
+            _selectedTribe = MACRO_CALL_MEMBER(
+                Map::Units::TribesState_Func::createTribeForPlayer, DAT_TribesState::ptr)(_playerID);
+            _selectedSlot = _tribeTypeOffset;
+        } else {
+            int _maxOffset = _groupsCount + _tribeTypeOffset;
+            _selectedTribe = 0;
+            _selectedSlot = 0;
+            short* _pTribeIDs = DAT_GameState::instance.playerDataArray[_playerID].aiTribeIDs + _tribeTypeOffset;
+            if (_tribeTypeOffset < _maxOffset) {
+                do {
+                    int _tribeID_2 = (int)*_pTribeIDs;
+                    if ((_tribeID_2 == 0)
+                        || (DAT_TribesState::instance.tribes[_tribeID_2].uid
+                            != DAT_GameState::instance.playerDataArray[_playerID].aiTribeUIDs[_tribeTypeOffset])) {
+                        _selectedTribe = MACRO_CALL_MEMBER(
+                            Map::Units::TribesState_Func::createTribeForPlayer, DAT_TribesState::ptr)(_playerID);
+                        _selectedSlot = _tribeTypeOffset;
+                        break;
+                    }
+                    short _tribeSize = DAT_TribesState::instance.tribes[_tribeID_2].size;
+                    if (_tribeSize < _smallestTribeSize) {
+                        _smallestTribeOffset = _tribeTypeOffset;
+                        _smallestTribe = _tribeID_2;
+                        _smallestTribeSize = _tribeSize;
+                    }
+                    _pTribeIDs = _pTribeIDs + 1;
+                    _tribeTypeOffset = _tribeTypeOffset + 1;
+                    _selectedTribe = _smallestTribe;
+                    _selectedSlot = _smallestTribeOffset;
+                } while (_tribeTypeOffset < _maxOffset);
+            }
+        }
+        if (0 < _selectedTribe) {
+            DAT_GameState::instance.playerDataArray[_playerID].aiTribeIDs[_selectedSlot] = (short)_selectedTribe;
+            DAT_GameState::instance.playerDataArray[_playerID].aiTribeUIDs[_selectedSlot]
+                = DAT_TribesState::instance.tribes[_selectedTribe].uid;
+            return _selectedTribe;
+        }
+        return 0;
+    }
+}
+}

src/OpenSHC/AI/AICState/addUnitToSmallestPatrolTribe.cpp

@@ -0,0 +1,25 @@
+#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_TribesState.hpp"
+#include "OpenSHC/Globals/DAT_UnitsState.hpp"
+
+namespace OpenSHC {
+namespace AI {
+
+    // FUNCTION: STRONGHOLDCRUSADER 0x004D2730
+    void AICState::addUnitToSmallestPatrolTribe(int unitID)
+    {
+        int iVar1 = (int)DAT_UnitsState::instance.units[unitID].owner;
+        int _aiType = DAT_GameState::instance.playerDataArray[iVar1].aiType;
+        if (_aiType != AITA_NULL) {
+            DAT_UnitsState::instance.units[unitID].aiUnitBehaviourType = 4;
+            iVar1 = MACRO_CALL_MEMBER(Map::Units::TribesState_Func::getSmallestPatrolTribe, DAT_TribesState::ptr)(
+                iVar1, (int)this->aics[_aiType - 1].OuterPatrolGroupsCount);
+            MACRO_CALL_MEMBER(Map::Units::TribesState_Func::addUnitToTribe, DAT_TribesState::ptr)(unitID, iVar1);
+        }
+    }
+}
+}

src/OpenSHC/AI/AICState/addUnitsToTribe166.cpp

@@ -0,0 +1,37 @@
+#include "OpenSHC/Map/Units/TribesState.func.hpp"
+#include "OpenSHC/AI/AICState.hpp"
+#include "OpenSHC/Map/Units/UnitLogicState.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 0x004CC720
+    void AICState::addUnitsToTribe166(int playerID)
+    {
+        int tribeID;
+        uint unitID = 1;
+        if (1 < (int)DAT_UnitsState::instance.maxUnitCount) {
+            Map::Units::Unit* pUVar1 = &DAT_UnitsState::instance.units[1];
+            do {
+                if ((((pUVar1->owner == playerID) && (pUVar1->logicalState == Map::Units::ULS_NORMAL))
+                        && (pUVar1->dying == 0))
+                    && (pUVar1->aiUnitBehaviourType == 6)) {
+                    tribeID = (int)DAT_GameState::instance.playerDataArray[playerID].aiTribeIDs[166];
+                    if (pUVar1->tribeID != tribeID) {
+                        MACRO_CALL_MEMBER(Map::Units::TribesState_Func::removeUnitFromTribe, DAT_TribesState::ptr)(
+                            unitID, (int)pUVar1->tribeID);
+                        MACRO_CALL_MEMBER(Map::Units::TribesState_Func::addUnitToTribe, DAT_TribesState::ptr)(
+                            unitID, tribeID);
+                    }
+                }
+                unitID = unitID + 1;
+                pUVar1 = pUVar1 + 1;
+            } while ((int)unitID < (int)DAT_UnitsState::instance.maxUnitCount);
+        }
+    }
+}
+}

src/OpenSHC/AI/AICState/aiAddUnitToMoatDiggerTribe.cpp

@@ -0,0 +1,31 @@
+#include "OpenSHC/Map/Units/TribesState.func.hpp"
+#include "OpenSHC/AI/AICState.hpp"
+#include "OpenSHC/Map/Units/Behavior/UnitStanceEnum.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 0x004CC840
+    void AICState::aiAddUnitToMoatDiggerTribe(int unitID)
+    {
+        int _owner = (int)DAT_UnitsState::instance.units[unitID].owner;
+        DAT_UnitsState::instance.units[unitID].aiUnitBehaviourType = 5;
+        int _tribe = (int)DAT_GameState::instance.playerDataArray[_owner].aiTribeIDs[10];
+        if ((_tribe == 0)
+            || (DAT_TribesState::instance.tribes[_tribe].uid
+                != DAT_GameState::instance.playerDataArray[_owner].aiTribeUIDs[10])) {
+            _tribe
+                = MACRO_CALL_MEMBER(Map::Units::TribesState_Func::createTribeForPlayer, DAT_TribesState::ptr)(_owner);
+            int _uid = DAT_TribesState::instance.tribes[_tribe].uid;
+            DAT_GameState::instance.playerDataArray[_owner].aiTribeIDs[10] = (short)_tribe;
+            DAT_GameState::instance.playerDataArray[_owner].aiTribeUIDs[10] = _uid;
+        }
+        MACRO_CALL_MEMBER(Map::Units::TribesState_Func::addUnitToTribe, DAT_TribesState::ptr)(unitID, _tribe);
+        DAT_TribesState::instance.tribes[_tribe].unitStance = Map::Units::Behavior::USE_DEFENSIVE;
+    }
+}
+}