From 2934f4d1d66a5b83c3705323c759189aee3ee705 Mon Sep 17 00:00:00 2001 From: Jake Vawter Date: Fri, 13 Nov 2026 06:30:08 -0500 Subject: [PATCH 01/12] headers: StoreLocalTime returns void, DirectPlay address callback takes 4 arguments The original ends StoreLocalTime with a plain ret and no return value, and the callback with ret 0x10. Co-Authored-By: Claude Opus 5.5 --- src/OpenSHC/Game/Skirmish.func.hpp | 2 +- src/OpenSHC/Game/Skirmish.hpp | 2 +- src/OpenSHC/Synchrony.func.hpp | 4 ++-- src/OpenSHC/Synchrony.hpp | 3 ++- 4 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/OpenSHC/Game/Skirmish.func.hpp b/src/OpenSHC/Game/Skirmish.func.hpp index 853d1f1820..efc73fc2b8 100644 --- a/src/OpenSHC/Game/Skirmish.func.hpp +++ b/src/OpenSHC/Game/Skirmish.func.hpp @@ -29,7 +29,7 @@ namespace Game { SetupSkirmishMode; MACRO_FUNCTION_RESOLVER( - int(__cdecl*)(), false, Address::SHC_3BB0A8C1_0x004C6CD0, &OpenSHC::Game::Skirmish::StoreLocalTime) + void(__cdecl*)(), false, Address::SHC_3BB0A8C1_0x004C6CD0, &OpenSHC::Game::Skirmish::StoreLocalTime) StoreLocalTime; MACRO_FUNCTION_RESOLVER(BOOLEnum(__cdecl*)(int score), false, Address::SHC_3BB0A8C1_0x004D1700, diff --git a/src/OpenSHC/Game/Skirmish.hpp b/src/OpenSHC/Game/Skirmish.hpp index 38ff1ac32f..c85fcd86d3 100644 --- a/src/OpenSHC/Game/Skirmish.hpp +++ b/src/OpenSHC/Game/Skirmish.hpp @@ -21,7 +21,7 @@ namespace Game { void __cdecl SetupSkirmishMode(int skirmishTrailMission); - int __cdecl StoreLocalTime(); + void __cdecl StoreLocalTime(); BOOLEnum __cdecl StoreCurrentGameIntoTemporarySKMasterEntry(int score); diff --git a/src/OpenSHC/Synchrony.func.hpp b/src/OpenSHC/Synchrony.func.hpp index adf9cb8c03..93eddbe6dd 100644 --- a/src/OpenSHC/Synchrony.func.hpp +++ b/src/OpenSHC/Synchrony.func.hpp @@ -55,8 +55,8 @@ namespace Synchrony_Func { Address::SHC_3BB0A8C1_0x0047DF40, &OpenSHC::Synchrony::EnumSessionsCallback_addSession_async) EnumSessionsCallback_addSession_async; - MACRO_FUNCTION_RESOLVER(BOOLEnum(__stdcall*)(int* param_1, undefined4 param_2, char* param_3), false, - Address::SHC_3BB0A8C1_0x0047E160, &OpenSHC::Synchrony::DirectPlayModemRelated_MemoryAllocationCallback) + MACRO_FUNCTION_RESOLVER(BOOLEnum(__stdcall*)(int* param_1, undefined4 param_2, char* param_3, undefined4 param_4), + false, Address::SHC_3BB0A8C1_0x0047E160, &OpenSHC::Synchrony::DirectPlayModemRelated_MemoryAllocationCallback) DirectPlayModemRelated_MemoryAllocationCallback; MACRO_FUNCTION_RESOLVER(void(__cdecl*)(char* dest, size_t size, undefined4 playerID), false, diff --git a/src/OpenSHC/Synchrony.hpp b/src/OpenSHC/Synchrony.hpp index 5aa5f99157..e4f62e6b2b 100644 --- a/src/OpenSHC/Synchrony.hpp +++ b/src/OpenSHC/Synchrony.hpp @@ -38,7 +38,8 @@ namespace Synchrony { BOOLEnum __stdcall EnumSessionsCallback_addSession_async( LPCDPSESSIONDESC2 lpThisSD, LPDWORD lpdwTimeOut, DWORD dwFlags, LPVOID lpContext); - BOOLEnum __stdcall DirectPlayModemRelated_MemoryAllocationCallback(int* param_1, undefined4 param_2, char* param_3); + BOOLEnum __stdcall DirectPlayModemRelated_MemoryAllocationCallback( + int* param_1, undefined4 param_2, char* param_3, undefined4 param_4); void __cdecl MemCopyFromParameter(char* dest, size_t size, undefined4 playerID); From a302fe5719c5dcf225940fb249c0e7fa4076c5e6 Mon Sep 17 00:00:00 2001 From: Jake Vawter Date: Fri, 13 Nov 2026 06:33:17 -0500 Subject: [PATCH 02/12] Reimplement 29 Synchrony and Game functions at 100% Co-Authored-By: Claude Opus 5.5 --- .../initializeScenarioEvent.cpp | 29 ++++ .../InGameEventUnionVersion/resetEvent.cpp | 25 ++++ .../Game/Skirmish/RecalculateAllies.cpp | 62 +++++++++ .../SetupSkirmishBalanceAndOrIntensity.cpp | 118 +++++++++++++++++ .../commitSkirmishSettings.cpp | 48 +++++++ ...eCurrentGameIntoTemporarySKMasterEntry.cpp | 48 +++++++ src/OpenSHC/Game/Skirmish/StoreLocalTime.cpp | 24 ++++ .../Synchrony/Actions/GateOpenOrClose.cpp | 28 ++++ .../Actions/OpenOrCloseDrawbridge.cpp | 25 ++++ .../Actions/ProcessAllyAcceptsRequest.cpp | 39 ++++++ .../Actions/ProcessAllyDeniesRequest.cpp | 27 ++++ .../Actions/ProcessAllyDeniesRequest2.cpp | 39 ++++++ .../Actions/ProcessAllyGoodsRequest.cpp | 110 ++++++++++++++++ .../ProcessAllyRequestAttackDefense.cpp | 69 ++++++++++ .../Actions/ProcessAllyRequestingGoods.cpp | 65 +++++++++ .../Actions/ProcessBuildingSleepUpdate.cpp | 37 ++++++ .../Synchrony/Actions/ProcessBuyOrSell.cpp | 40 ++++++ .../Synchrony/Actions/ProcessRecruitUnit.cpp | 74 +++++++++++ .../Synchrony/Actions/ProcessReleaseDogs.cpp | 74 +++++++++++ .../Synchrony/Actions/ProcessTowerRepair.cpp | 47 +++++++ .../TryAcquireAmmunitionOrPlanToBuyStone.cpp | 27 ++++ .../Commands/ClickDestroyBuilding.cpp | 124 ++++++++++++++++++ ...yModemRelated_MemoryAllocationCallback.cpp | 38 ++++++ .../Synchrony/EnumDisplayModesCallback.cpp | 49 +++++++ .../Synchrony/MemCopyFromParameter.cpp | 28 ++++ .../Synchrony/PutPlayerIntoRandomSlot.cpp | 46 +++++++ .../Synchrony/ResetAiVariationArrayValue.cpp | 31 +++++ .../Synchrony/SetAIPlayerNickNames.cpp | 120 +++++++++++++++++ .../Synchrony/SyncPlayerGroupArrays.cpp | 22 ++++ status/addresses-SHC-3BB0A8C1.txt | 58 ++++---- 30 files changed, 1542 insertions(+), 29 deletions(-) create mode 100644 src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/initializeScenarioEvent.cpp create mode 100644 src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/resetEvent.cpp create mode 100644 src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp create mode 100644 src/OpenSHC/Game/Skirmish/SetupSkirmishBalanceAndOrIntensity.cpp create mode 100644 src/OpenSHC/Game/Skirmish/SkirmishLobbySetupStructure/commitSkirmishSettings.cpp create mode 100644 src/OpenSHC/Game/Skirmish/StoreCurrentGameIntoTemporarySKMasterEntry.cpp create mode 100644 src/OpenSHC/Game/Skirmish/StoreLocalTime.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/GateOpenOrClose.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/OpenOrCloseDrawbridge.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/ProcessAllyAcceptsRequest.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest2.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/ProcessAllyRequestAttackDefense.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/ProcessBuildingSleepUpdate.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/ProcessBuyOrSell.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/ProcessRecruitUnit.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/ProcessReleaseDogs.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/ProcessTowerRepair.cpp create mode 100644 src/OpenSHC/Synchrony/Actions/TryAcquireAmmunitionOrPlanToBuyStone.cpp create mode 100644 src/OpenSHC/Synchrony/Commands/ClickDestroyBuilding.cpp create mode 100644 src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp create mode 100644 src/OpenSHC/Synchrony/EnumDisplayModesCallback.cpp create mode 100644 src/OpenSHC/Synchrony/MemCopyFromParameter.cpp create mode 100644 src/OpenSHC/Synchrony/PutPlayerIntoRandomSlot.cpp create mode 100644 src/OpenSHC/Synchrony/ResetAiVariationArrayValue.cpp create mode 100644 src/OpenSHC/Synchrony/SetAIPlayerNickNames.cpp create mode 100644 src/OpenSHC/Synchrony/SyncPlayerGroupArrays.cpp diff --git a/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/initializeScenarioEvent.cpp b/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/initializeScenarioEvent.cpp new file mode 100644 index 0000000000..4aa997a21b --- /dev/null +++ b/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/initializeScenarioEvent.cpp @@ -0,0 +1,29 @@ +#include "OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion.func.hpp" + +namespace OpenSHC { +namespace Game { + namespace ScenarioEvents { + + // FUNCTION: STRONGHOLDCRUSADER 0x004B77A0 + ScenarioEventCondition* InGameEventUnionVersion::initializeScenarioEvent() + { + this->header.month = 0; + this->header.year = 1181; + this->header.tl_type = 3; + this->data.scenario.ScenarioEventType = 0; + this->data.scenario.actionData = 0; + *(short*)&this->data.scenario.allOrAnyCondition = 1; + this->data.scenario.repeat = 0; + ScenarioEventCondition* condition = this->data.scenario.conditions; + for (int i = 0; i < 40; ++i) { + condition->enabled = 0; + condition->value = 0; + condition->subType = 0; + ++condition; + } + return condition; + } + + } +} +} diff --git a/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/resetEvent.cpp b/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/resetEvent.cpp new file mode 100644 index 0000000000..cd062f159b --- /dev/null +++ b/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/resetEvent.cpp @@ -0,0 +1,25 @@ +#include "OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion.func.hpp" + +namespace OpenSHC { +namespace Game { + namespace ScenarioEvents { + + // FUNCTION: STRONGHOLDCRUSADER 0x004B7730 + BOOLEnum InGameEventUnionVersion::resetEvent() + { + this->header.month = 0; + this->header.year = 1181; + this->data.invasion.repeatMonths = 0; + this->header.tl_type = 1; + this->data.invasion.crusaderArabian = 0; + this->data.invasion.totalUnitCount = 0; + for (int i = 0; i < 24; ++i) { + this->data.invasion.unitCountsPerUnitType[i] = 0; + } + this->data.invasion.invasionPoint = 0; + return FALSE; + } + + } +} +} diff --git a/src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp b/src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp new file mode 100644 index 0000000000..51c38a9dae --- /dev/null +++ b/src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp @@ -0,0 +1,62 @@ +#include "OpenSHC/Game/Skirmish.func.hpp" +#include "OpenSHC/Map/Units/UnitsState.func.hpp" + +#include "OpenSHC/Globals/DAT_AlliesCount.hpp" +#include "OpenSHC/Globals/DAT_GameCore.hpp" +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_LastTeamMemberIndex.hpp" +#include "OpenSHC/Globals/DAT_SomeTeamMemberPlayerIDArray.hpp" +#include "OpenSHC/Globals/DAT_UnitsState.hpp" + +namespace OpenSHC { +namespace Game { + namespace Skirmish { + + // FUNCTION: STRONGHOLDCRUSADER 0x004AC570 + void RecalculateAllies() + { + if ((int)DAT_GameCore::instance.mapTimeInTicks - (int)DAT_GameCore::instance.section1127 > 400 + && MACRO_CALL_MEMBER(Map::Units::UnitsState_Func::getAliveLordForPlayer, DAT_UnitsState::ptr)( + DAT_GameSynchronyState::instance.currentPlayerSlotID) + == 0) { + DAT_AlliesCount::instance = 0; + return; + } + int const team + = DAT_GameState::instance.mapAndTime.playerTeams[DAT_GameSynchronyState::instance.currentPlayerSlotID]; + DAT_AlliesCount::instance = 0; + for (int player = 1; player < 9; ++player) { + if (player == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + continue; + } + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[player] == -1 + && DAT_GameSynchronyState::instance.currentAIArray[player] == 0) { + continue; + } + if ((int)DAT_GameCore::instance.mapTimeInTicks - (int)DAT_GameCore::instance.section1127 > 400 + && MACRO_CALL_MEMBER(Map::Units::UnitsState_Func::getAliveLordForPlayer, DAT_UnitsState::ptr)( + player) + == 0) { + continue; + } + if (team != DAT_GameState::instance.mapAndTime.playerTeams[player]) { + continue; + } + DAT_SomeTeamMemberPlayerIDArray::instance[DAT_AlliesCount::instance] = player; + DAT_AlliesCount::instance += 1; + if ((int)DAT_AlliesCount::instance >= 6) { + break; + } + } + if ((int)DAT_LastTeamMemberIndex::instance >= (int)DAT_AlliesCount::instance) { + DAT_LastTeamMemberIndex::instance = DAT_AlliesCount::instance - 1; + } + if ((int)DAT_LastTeamMemberIndex::instance < 0) { + DAT_LastTeamMemberIndex::instance = 0; + } + } + + } +} +} diff --git a/src/OpenSHC/Game/Skirmish/SetupSkirmishBalanceAndOrIntensity.cpp b/src/OpenSHC/Game/Skirmish/SetupSkirmishBalanceAndOrIntensity.cpp new file mode 100644 index 0000000000..fde82e7b2a --- /dev/null +++ b/src/OpenSHC/Game/Skirmish/SetupSkirmishBalanceAndOrIntensity.cpp @@ -0,0 +1,118 @@ +#include "OpenSHC/Game/Skirmish.func.hpp" +#include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" + +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_RenderingDefinedData.hpp" + +namespace OpenSHC { +namespace Game { + namespace Skirmish { + + // FUNCTION: STRONGHOLDCRUSADER 0x00429710 + void SetupSkirmishBalanceAndOrIntensity() + { + switch (DAT_GameSynchronyState::instance.skirmishTechLevel) { + case 0: + DAT_GameSynchronyState::instance.skirmishGameIntensityType = 1; + DAT_GameSynchronyState::instance.skirmishGameIntensityType2 = 0; + DAT_GameSynchronyState::instance.skirmishDefaultPopularity = 80; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[0] = 1; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[1] = 1; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[3] = 1; + break; + case 1: + DAT_GameSynchronyState::instance.skirmishGameIntensityType = 1; + DAT_GameSynchronyState::instance.skirmishGameIntensityType2 = 1; + DAT_GameSynchronyState::instance.skirmishDefaultPopularity = 80; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[0] = 1; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[1] = 1; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[3] = 1; + break; + case 2: + DAT_GameSynchronyState::instance.skirmishGameIntensityType = 2; + DAT_GameSynchronyState::instance.skirmishGameIntensityType2 = 1; + DAT_GameSynchronyState::instance.skirmishDefaultPopularity = 80; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[0] = 1; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[1] = 1; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[3] = 1; + break; + case 3: + DAT_GameSynchronyState::instance.skirmishGameIntensityType = 2; + DAT_GameSynchronyState::instance.skirmishGameIntensityType2 = 2; + DAT_GameSynchronyState::instance.skirmishDefaultPopularity = 80; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[0] = 1; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[1] = 1; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[3] = 1; + break; + case 4: + DAT_GameSynchronyState::instance.skirmishGameIntensityType = 3; + DAT_GameSynchronyState::instance.skirmishGameIntensityType2 = 3; + DAT_GameSynchronyState::instance.skirmishDefaultPopularity = 80; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[0] = 1; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[1] = 1; + DAT_GameSynchronyState::instance.skirmishUnknownSetting1[3] = 1; + break; + } + + switch (DAT_GameSynchronyState::instance.skirmishGameIntensityType) { + case 1: + for (int i = 0; i < 20; ++i) { + DAT_GameSynchronyState::instance.skirmishIntensityRelatedArray[i] + = DAT_RenderingDefinedData::instance + .SkirmishIntensityRelatedArray[0][DAT_GameSynchronyState::instance.skirmishTechLevel][i]; + } + break; + case 2: + for (int i = 0; i < 20; ++i) { + DAT_GameSynchronyState::instance.skirmishIntensityRelatedArray[i] + = DAT_RenderingDefinedData::instance + .SkirmishIntensityRelatedArray[1][DAT_GameSynchronyState::instance.skirmishTechLevel][i]; + } + break; + case 3: + for (int i = 0; i < 20; ++i) { + DAT_GameSynchronyState::instance.skirmishIntensityRelatedArray[i] + = DAT_RenderingDefinedData::instance + .SkirmishIntensityRelatedArray[2][DAT_GameSynchronyState::instance.skirmishTechLevel][i]; + } + break; + } + + switch (DAT_GameSynchronyState::instance.skirmishGameIntensityType2) { + case 0: + for (int i = 0; i < 10; ++i) { + DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1[i] = 0; + } + break; + case 1: + for (int i = 0; i < 10; ++i) { + DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1[i] + = DAT_RenderingDefinedData::instance + .SkirmishIntensityRelatedArray2[DAT_GameSynchronyState::instance.skirmishTechLevel][i]; + } + break; + case 2: + for (int i = 0; i < 10; ++i) { + DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1[i] + = DAT_RenderingDefinedData::instance.SkirmishIntensityRelatedArray2[5 + + DAT_GameSynchronyState::instance.skirmishTechLevel][i]; + } + break; + case 3: + for (int i = 0; i < 10; ++i) { + DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1[i] + = DAT_RenderingDefinedData::instance.SkirmishIntensityRelatedArray2[10 + + DAT_GameSynchronyState::instance.skirmishTechLevel][i]; + } + break; + } + + MACRO_CALL_MEMBER(Synchrony::GameSynchronyState_Func::queueCommand, DAT_GameSynchronyState::ptr)( + Commands::GCT_CHANGE_GAME_INTENSITY_OR_BALANCE); + DAT_GameSynchronyState::instance.field_0x1072e8 = -1; + DAT_GameSynchronyState::instance.field_0x1072ec = -1; + } + + } +} +} diff --git a/src/OpenSHC/Game/Skirmish/SkirmishLobbySetupStructure/commitSkirmishSettings.cpp b/src/OpenSHC/Game/Skirmish/SkirmishLobbySetupStructure/commitSkirmishSettings.cpp new file mode 100644 index 0000000000..ee7bf3d412 --- /dev/null +++ b/src/OpenSHC/Game/Skirmish/SkirmishLobbySetupStructure/commitSkirmishSettings.cpp @@ -0,0 +1,48 @@ +#include "../SkirmishLobbySetupStructure.func.hpp" + +#include "OpenSHC/Globals/DAT_GameCore.hpp" +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" + +namespace OpenSHC { +namespace Game { + namespace Skirmish { + + // FUNCTION: STRONGHOLDCRUSADER 0x00486C40 + void SkirmishLobbySetupStructure::commitSkirmishSettings() + { + this->mapu4int2 = DAT_GameSynchronyState::instance.skirmishAutoSaveEveryMinutes; + this->mbr_0x4 = DAT_GameState::instance.mapAndTime.skirmishFogOfWar; + strcpy(this->mapName, DAT_GameSynchronyState::instance.mapName); + for (int player = 0; player < 9; ++player) { + this->roundTableOrderArray[player] = DAT_GameSynchronyState::instance.DAT_RoundTableOrderArray[player]; + this->playerGroupArray[player] = DAT_GameSynchronyState::instance.DAT_PlayerGroupArray[player]; + this->currentAIArray[player] = DAT_GameSynchronyState::instance.currentAIArray[player]; + this->aiVariationArray[player] = DAT_GameSynchronyState::instance.aiVariationArray[player]; + } + this->slot1Position = DAT_GameSynchronyState::instance.playerPositionsArray[0]; + this->slot2Position = DAT_GameSynchronyState::instance.playerPositionsArray[1]; + this->slot3Position = DAT_GameSynchronyState::instance.playerPositionsArray[2]; + this->slot4Position = DAT_GameSynchronyState::instance.playerPositionsArray[3]; + this->slot5Position = DAT_GameSynchronyState::instance.playerPositionsArray[4]; + this->slot6Position = DAT_GameSynchronyState::instance.playerPositionsArray[5]; + this->slot7Position = DAT_GameSynchronyState::instance.playerPositionsArray[6]; + this->slot8Position = DAT_GameSynchronyState::instance.playerPositionsArray[7]; + this->currentPlayerSlotID = DAT_GameSynchronyState::instance.currentPlayerSlotID; + this->currentAdvantageBalance = DAT_GameSynchronyState::instance.skirmishCurrentAdvantageBalance; + this->currentAdvantageGroup = DAT_GameSynchronyState::instance.skirmishGameIntensityType; + this->mbr_0x80 = DAT_GameSynchronyState::instance.skirmishTechLevel; + for (int player = 0; player < 9; ++player) { + this->playerLordTypeArray[player] = DAT_GameCore::instance.selectedLordTypes[player]; + } + this->mbr_0xf0 = DAT_GameCore::instance.field_0x2340; + this->selectedLordType = DAT_GameCore::instance.selectedLordTypeUnk; + this->popularity = DAT_GameSynchronyState::instance.skirmishDefaultPopularity; + this->mapSelectionRelativeSelected = DAT_GameSynchronyState::instance.DAT_MapSelectionRelativeSelected; + this->mapSelectionScrollOffset = DAT_GameSynchronyState::instance.DAT_MapSelectionScrollOffset; + this->mbr_0xfc = DAT_GameSynchronyState::instance.lobbyMapSortOrder; + } + + } +} +} diff --git a/src/OpenSHC/Game/Skirmish/StoreCurrentGameIntoTemporarySKMasterEntry.cpp b/src/OpenSHC/Game/Skirmish/StoreCurrentGameIntoTemporarySKMasterEntry.cpp new file mode 100644 index 0000000000..21f77dff5f --- /dev/null +++ b/src/OpenSHC/Game/Skirmish/StoreCurrentGameIntoTemporarySKMasterEntry.cpp @@ -0,0 +1,48 @@ +#include "OpenSHC/Game/Skirmish.func.hpp" +#include "OpenSHC/UI/GreatestLord.func.hpp" + +#include "OpenSHC/Globals/DAT_GameCore.hpp" +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_SkMasterDataEntry.hpp" + +namespace OpenSHC { +namespace Game { + namespace Skirmish { + + // FUNCTION: STRONGHOLDCRUSADER 0x004D1700 + BOOLEnum StoreCurrentGameIntoTemporarySKMasterEntry(int score) + { + DAT_SkMasterDataEntry::instance.score = score; + strcpy(DAT_SkMasterDataEntry::instance.mapName, DAT_GameSynchronyState::instance.mapName); + DAT_SkMasterDataEntry::instance.skMasterScore = MACRO_CALL(UI::GreatestLord_Func::ComputeSkMasterScore)( + DAT_GameSynchronyState::instance.currentPlayerSlotID); + int activePlayerCount = 0; + for (int player = 1; player < 9; ++player) { + if (DAT_GameSynchronyState::instance.finalResults.active[player] == 0) { + break; + } + ++activePlayerCount; + } + DAT_SkMasterDataEntry::instance.activePlayerCount = activePlayerCount; + for (int player = 1; player < 9; ++player) { + DAT_SkMasterDataEntry::instance.array1[player] + = DAT_GameState::instance.mapAndTime.playerGroupArray[player]; + } + for (int player = 1; player < 9; ++player) { + DAT_SkMasterDataEntry::instance.aiArray[player] + = DAT_GameSynchronyState::instance.currentAIArray[player]; + } + for (int player = 1; player < 9; ++player) { + DAT_SkMasterDataEntry::instance.aliveArray[player] + = DAT_GameState::instance.mapAndTime.playerIsAlive[player]; + } + DAT_SkMasterDataEntry::instance.lordType = DAT_GameCore::instance.selectedLordTypeUnk; + MACRO_CALL(Skirmish_Func::StoreLocalTime)(); + DAT_SkMasterDataEntry::instance.results = DAT_GameSynchronyState::instance.finalResults; + return TRUE; + } + + } +} +} diff --git a/src/OpenSHC/Game/Skirmish/StoreLocalTime.cpp b/src/OpenSHC/Game/Skirmish/StoreLocalTime.cpp new file mode 100644 index 0000000000..a08e01bb8c --- /dev/null +++ b/src/OpenSHC/Game/Skirmish/StoreLocalTime.cpp @@ -0,0 +1,24 @@ +#include "OpenSHC/Game/Skirmish.func.hpp" + +#include "OpenSHC/Globals/DAT_GameCore.hpp" +#include "OpenSHC/Globals/DAT_SkMasterDataEntry.hpp" + +namespace OpenSHC { +namespace Game { + namespace Skirmish { + + // FUNCTION: STRONGHOLDCRUSADER 0x004C6CD0 + void StoreLocalTime() + { + SYSTEMTIME localTime; + GetLocalTime(&localTime); + DAT_SkMasterDataEntry::instance.localTimeDay = localTime.wDay; + DAT_SkMasterDataEntry::instance.localTimeMonth = localTime.wMonth; + DAT_SkMasterDataEntry::instance.localTimeYear = localTime.wYear; + DAT_SkMasterDataEntry::instance.gameDurationInMinutes = (int)DAT_GameCore::instance.gameDuration / 60000; + DAT_SkMasterDataEntry::instance.mapTimeInTicks = DAT_GameCore::instance.mapTimeInTicks; + } + + } +} +} diff --git a/src/OpenSHC/Synchrony/Actions/GateOpenOrClose.cpp b/src/OpenSHC/Synchrony/Actions/GateOpenOrClose.cpp new file mode 100644 index 0000000000..39f80d5722 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/GateOpenOrClose.cpp @@ -0,0 +1,28 @@ +#include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" +#include "OpenSHC/Synchrony/Actions.func.hpp" + +#include "OpenSHC/Globals/DAT_BuildingsState.hpp" + +namespace OpenSHC { +namespace Synchrony { + + // FUNCTION: STRONGHOLDCRUSADER 0x004654F0 + void Actions::GateOpenOrClose(undefined4 playerID, int buildingID, int newGateState, int buildingUID) + { + if (DAT_BuildingsState::instance.buildings[buildingID].uid == buildingUID) { + DAT_BuildingsState::instance.buildings[buildingID].gateState = (byte)newGateState; + DAT_BuildingsState::instance.buildings[buildingID].gateState2 = 0; + if (newGateState == 10) { + DAT_BuildingsState::instance.buildings[buildingID].gateCloseOpenTimer = -1; + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::applyGateOrDrawbridgeOpenCloseChange, + DAT_BuildingsState::ptr)(buildingID, FALSE, FALSE); + } else if (newGateState == 11) { + DAT_BuildingsState::instance.buildings[buildingID].gateCloseOpenTimer = 600; + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::applyGateOrDrawbridgeOpenCloseChange, + DAT_BuildingsState::ptr)(buildingID, TRUE, FALSE); + } + } + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/OpenOrCloseDrawbridge.cpp b/src/OpenSHC/Synchrony/Actions/OpenOrCloseDrawbridge.cpp new file mode 100644 index 0000000000..b2a0675394 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/OpenOrCloseDrawbridge.cpp @@ -0,0 +1,25 @@ +#include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" +#include "OpenSHC/Synchrony/Actions.func.hpp" + +#include "OpenSHC/Globals/DAT_BuildingsState.hpp" + +namespace OpenSHC { +namespace Synchrony { + + // FUNCTION: STRONGHOLDCRUSADER 0x004653B0 + void Actions::OpenOrCloseDrawbridge(undefined4 param_1, int buildingID, int value, int buildingUID) + { + if (DAT_BuildingsState::instance.buildings[buildingID].uid == buildingUID) { + DAT_BuildingsState::instance.buildings[buildingID].drawbridgeState2 = (byte)value; + if (value == 10) { + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::applyGateOrDrawbridgeOpenCloseChange, + DAT_BuildingsState::ptr)(buildingID, FALSE, TRUE); + } else { + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::applyGateOrDrawbridgeOpenCloseChange, + DAT_BuildingsState::ptr)(buildingID, TRUE, TRUE); + } + } + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyAcceptsRequest.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyAcceptsRequest.cpp new file mode 100644 index 0000000000..617844b9ad --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyAcceptsRequest.cpp @@ -0,0 +1,39 @@ +#include "OpenSHC/Synchrony/Actions.func.hpp" +#include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" +#include "OpenSHC/Text/TextManager.func.hpp" + +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_TextManagerObject.hpp" + +namespace OpenSHC { +namespace Synchrony { + + // FUNCTION: STRONGHOLDCRUSADER 0x004AD110 + void Actions::ProcessAllyAcceptsRequest(int receiverID, int requesterID) + { + if (DAT_GameState::instance.playerDataArray[requesterID].requestStateUnk == 2) { + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[receiverID] != -1 + && receiverID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_ALLIES2, 4)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + requesterID, 0); + } + } else if (DAT_GameState::instance.playerDataArray[requesterID].requestStateUnk == 1) { + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[receiverID] != -1 + && receiverID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_ALLIES2, 3)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + requesterID, DAT_GameState::instance.playerDataArray[requesterID].requestedAttackTargetUnk); + } + } + DAT_GameState::instance.playerDataArray[requesterID].requestStateUnk = 0; + DAT_GameState::instance.playerDataArray[receiverID].isNotNervousByEnemyTroopValue = FALSE; + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp new file mode 100644 index 0000000000..4397e9140e --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp @@ -0,0 +1,27 @@ +#include "OpenSHC/Synchrony/Actions.func.hpp" +#include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" +#include "OpenSHC/Text/TextManager.func.hpp" + +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_TextManagerObject.hpp" + +namespace OpenSHC { +namespace Synchrony { + + // FUNCTION: STRONGHOLDCRUSADER 0x004AE010 + void Actions::ProcessAllyDeniesRequest(int fromPlayerID, int toPlayerID) + { + DAT_GameState::instance.playerDataArray[toPlayerID].requestedGoodsArray1Unk[fromPlayerID] = 0; + DAT_GameState::instance.playerDataArray[toPlayerID].requestedGoodsArray2Unk[fromPlayerID] = 0; + if (fromPlayerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_ALLIES2, 0)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + fromPlayerID, 0); + } + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest2.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest2.cpp new file mode 100644 index 0000000000..7c63cf2101 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest2.cpp @@ -0,0 +1,39 @@ +#include "OpenSHC/Synchrony/Actions.func.hpp" +#include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" +#include "OpenSHC/Text/TextManager.func.hpp" + +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_TextManagerObject.hpp" + +namespace OpenSHC { +namespace Synchrony { + + // FUNCTION: STRONGHOLDCRUSADER 0x004AD1E0 + void Actions::ProcessAllyDeniesRequest2(int receiverID, int requesterID) + { + if (DAT_GameState::instance.playerDataArray[requesterID].requestStateUnk == 2) { + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[receiverID] != -1 + && receiverID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_ALLIES2, 6)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + requesterID, 0); + } + } else if (DAT_GameState::instance.playerDataArray[requesterID].requestStateUnk == 1) { + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[receiverID] != -1 + && receiverID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_ALLIES2, 5)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + requesterID, DAT_GameState::instance.playerDataArray[requesterID].requestedAttackTargetUnk); + } + } + DAT_GameState::instance.playerDataArray[requesterID].requestStateUnk = 0; + DAT_GameState::instance.playerDataArray[receiverID].isNotNervousByEnemyTroopValue = FALSE; + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp new file mode 100644 index 0000000000..fc90f2f706 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp @@ -0,0 +1,110 @@ +#include "../Actions.func.hpp" + +#include "OpenSHC/AI/AICState.func.hpp" +#include "OpenSHC/Audio/SFX/SFXState.func.hpp" +#include "OpenSHC/Game/GameStateStructures.func.hpp" +#include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" +#include "OpenSHC/OS.func.hpp" +#include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" +#include "OpenSHC/Text/TextManager.func.hpp" +#include "OpenSHC/string-literals.hpp" + +#include "OpenSHC/Globals/DAT_AICState.hpp" +#include "OpenSHC/Globals/DAT_BuildingsState.hpp" +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_SFXState.hpp" +#include "OpenSHC/Globals/DAT_TextManagerObject.hpp" + +namespace OpenSHC { +namespace Synchrony { + + using namespace OpenSHC::Game::Resources; + + // FUNCTION: STRONGHOLDCRUSADER 0x004ADDD0 + void Actions::ProcessAllyGoodsRequest(int param_1, ResourceType param_2, int param_3, int param_4) + { + ResourceType resourceType = param_2; + if (resourceType == RT_GOLD) { + if (DAT_GameState::instance.playerDataArray[param_4].currentResources[RT_GOLD] < param_3) { + param_3 = DAT_GameState::instance.playerDataArray[param_4].currentResources[RT_GOLD]; + } + DAT_GameSynchronyState::instance.finalResults.finalGoodsRecieved[param_1] += param_3; + DAT_GameState::instance.playerDataArray[param_1].currentResources[RT_GOLD] += param_3; + DAT_GameState::instance.playerDataArray[param_4].currentResources[RT_GOLD] -= param_3; + DAT_GameSynchronyState::instance.finalResults.finalGoodsSent[param_4] += param_3; + } else { + if (resourceType == RT_PARTIALPITCH) { + resourceType = RT_PITCH; + } + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceGain, DAT_BuildingsState::ptr)( + param_1, resourceType, param_3); + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceLoss, DAT_BuildingsState::ptr)( + param_4, resourceType, param_3, 0); + DAT_GameSynchronyState::instance.finalResults.finalGoodsRecieved[param_1] += MACRO_CALL_MEMBER( + Game::GameStateStructures_Func::getSellPrice, DAT_GameState::ptr)(param_1, resourceType, param_3); + DAT_GameSynchronyState::instance.finalResults.finalGoodsSent[param_4] += MACRO_CALL_MEMBER( + Game::GameStateStructures_Func::getSellPrice, DAT_GameState::ptr)(param_1, resourceType, param_3); + } + if (param_1 == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + switch (param_2) { + case RT_IRON: + case RT_GOLD: + MACRO_CALL_MEMBER(Audio::SFX::SFXState_Func::setUpSFXToPlayUnk, DAT_SFXState::ptr)( + Audio::SFX::SEID_IRON_DEPOSIT); + break; + case RT_BOW: + case RT_CROSSBOW: + case RT_SPEAR: + case RT_PIKE: + case RT_MACE: + case RT_SWORD: + case RT_LEATHERARMOR: + case RT_IRONARMOR: + MACRO_CALL_MEMBER(Audio::SFX::SFXState_Func::setUpSFXToPlayUnk, DAT_SFXState::ptr)( + Audio::SFX::SEID_SWORD_DEPOSIT); + break; + default: + MACRO_CALL_MEMBER(Audio::SFX::SFXState_Func::setUpSFXToPlayUnk, DAT_SFXState::ptr)( + Audio::SFX::SEID_FLOUR_DEPOSIT); + break; + } + } + if (DAT_GameSynchronyState::instance.currentGameMode != Game::GM_SOLITARY + && DAT_GameSynchronyState::instance.currentGameMode != Game::GM_SKIRMISH_SINGLE_PLAYER) { + if (param_1 == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_ALLIES2, 1)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + param_4, 0); + MACRO_CALL(OS_Func::_sprintf)(DAT_GameSynchronyState::instance.receivedChatMessage, s__d__s___005a7674, + param_3, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_GOODS, param_2)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + param_4, param_1); + } + if (param_4 == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_ALLIES2, 2)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + param_4, 0); + MACRO_CALL(OS_Func::_sprintf)(DAT_GameSynchronyState::instance.receivedChatMessage, s__d__s_005a766c, + param_3, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_GOODS, param_2)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + param_4, 0); + } + } + if (param_2 == DAT_GameState::instance.playerDataArray[param_4].requestedGoodsArray1Unk[param_1]) { + DAT_GameState::instance.playerDataArray[param_4].requestedGoodsArray1Unk[param_1] = 0; + DAT_GameState::instance.playerDataArray[param_4].requestedGoodsArray2Unk[param_1] = 0; + } + MACRO_CALL_MEMBER(AI::AICState_Func::playThanksBikFromPlayerToPlayer, DAT_AICState::ptr)(param_1, param_4); + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestAttackDefense.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestAttackDefense.cpp new file mode 100644 index 0000000000..58903bc997 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestAttackDefense.cpp @@ -0,0 +1,69 @@ +#include "../Actions.func.hpp" + +#include "OpenSHC/AI/AICState.func.hpp" +#include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" +#include "OpenSHC/Text/TextManager.func.hpp" + +#include "OpenSHC/Globals/DAT_AICState.hpp" +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_TextManagerObject.hpp" + +namespace OpenSHC { +namespace Synchrony { + + // FUNCTION: STRONGHOLDCRUSADER 0x004AD2F0 + void Actions::ProcessAllyRequestAttackDefense( + int targetPlayerID, int playerID, int requestedByPlayerID, int param_4) + { + if (param_4 == 10) { + DAT_GameState::instance.playerDataArray[playerID].requestStateUnk = 0; + DAT_GameState::instance.playerDataArray[requestedByPlayerID].isNotNervousByEnemyTroopValue = FALSE; + return; + } + if (param_4 == 11) { + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[playerID] != -1) { + if (playerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, + DAT_TextManagerObject::ptr)(DE::SHCDE::TEXT_MULTIPLAYER_CONNECTION, 70)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, + DAT_GameSynchronyState::ptr)(requestedByPlayerID, 0); + } + DAT_GameState::instance.playerDataArray[playerID].playerID_askerUnk = requestedByPlayerID; + DAT_GameState::instance.playerDataArray[playerID].requestStateUnk = 2; + DAT_GameState::instance.playerDataArray[requestedByPlayerID].isNotNervousByEnemyTroopValue = TRUE; + return; + } + if (MACRO_CALL_MEMBER(AI::AICState_Func::determineAIPlayerHelp, DAT_AICState::ptr)( + playerID, requestedByPlayerID)) { + DAT_GameState::instance.playerDataArray[playerID].playerID_askerUnk = requestedByPlayerID; + DAT_GameState::instance.playerDataArray[playerID].requestStateUnk = 2; + } + return; + } + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[playerID] != -1) { + if (playerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_MULTIPLAYER_CONNECTION, 71)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + requestedByPlayerID, targetPlayerID); + } + DAT_GameState::instance.playerDataArray[playerID].playerID_askerUnk = requestedByPlayerID; + DAT_GameState::instance.playerDataArray[playerID].requestedAttackTargetUnk = targetPlayerID; + DAT_GameState::instance.playerDataArray[playerID].requestStateUnk = 1; + DAT_GameState::instance.playerDataArray[requestedByPlayerID].isNotNervousByEnemyTroopValue = FALSE; + return; + } + if (MACRO_CALL_MEMBER(AI::AICState_Func::determineAIPlayerAttackRequestResponse, DAT_AICState::ptr)( + playerID, targetPlayerID, requestedByPlayerID)) { + DAT_GameState::instance.playerDataArray[playerID].requestStateUnk = 1; + DAT_GameState::instance.playerDataArray[playerID].requestedAttackTargetUnk = targetPlayerID; + DAT_GameState::instance.playerDataArray[playerID].playerID_askerUnk = requestedByPlayerID; + MACRO_CALL_MEMBER(AI::AICState_Func::abortAttackAndGoIdle, DAT_AICState::ptr)(playerID); + } + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp new file mode 100644 index 0000000000..2daac481e9 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp @@ -0,0 +1,65 @@ +#include "../Actions.func.hpp" + +#include "OpenSHC/AI/AICState.func.hpp" +#include "OpenSHC/Game/GameStateStructures.func.hpp" +#include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" +#include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" +#include "OpenSHC/Text/TextManager.func.hpp" + +#include "OpenSHC/Globals/DAT_AICState.hpp" +#include "OpenSHC/Globals/DAT_BuildingsState.hpp" +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_TextManagerObject.hpp" + +namespace OpenSHC { +namespace Synchrony { + + using OpenSHC::Game::Resources::ResourceType; + + // FUNCTION: STRONGHOLDCRUSADER 0x004AD7C0 + void Actions::ProcessAllyRequestingGoods(int askedPlayerID, int param_2, int amount, int askee) + { + if (param_2 + 1 == Game::Resources::RT_GOLD) { + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[askedPlayerID] == -1) { + return; + } + DAT_GameState::instance.playerDataArray[askedPlayerID].requestedGoodsArray1Unk[askee] + = (short)(param_2 + 1); + DAT_GameState::instance.playerDataArray[askedPlayerID].requestedGoodsArray2Unk[askee] = (short)amount; + if (askedPlayerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_MULTIPLAYER_CONNECTION, 72)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + askee, 0); + } + return; + } + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[askedPlayerID] != -1) { + DAT_GameState::instance.playerDataArray[askedPlayerID].requestedGoodsArray1Unk[askee] + = (short)(param_2 + 1); + DAT_GameState::instance.playerDataArray[askedPlayerID].requestedGoodsArray2Unk[askee] = (short)amount; + if (askedPlayerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_MULTIPLAYER_CONNECTION, 72)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + askee, 0); + } + return; + } + MACRO_CALL_MEMBER(AI::AICState_Func::playGoodsSentBikFromPlayerToPlayer, DAT_AICState::ptr)( + askedPlayerID, askee); + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceGain, DAT_BuildingsState::ptr)( + askee, (ResourceType)(param_2 + 1), amount); + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceLoss, DAT_BuildingsState::ptr)( + askedPlayerID, (ResourceType)(param_2 + 1), amount, 0); + DAT_GameSynchronyState::instance.finalResults.finalGoodsRecieved[askee] += MACRO_CALL_MEMBER( + Game::GameStateStructures_Func::getSellPrice, DAT_GameState::ptr)(askedPlayerID, param_2 + 1, amount); + DAT_GameSynchronyState::instance.finalResults.finalGoodsSent[askedPlayerID] += MACRO_CALL_MEMBER( + Game::GameStateStructures_Func::getSellPrice, DAT_GameState::ptr)(askedPlayerID, param_2 + 1, amount); + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/ProcessBuildingSleepUpdate.cpp b/src/OpenSHC/Synchrony/Actions/ProcessBuildingSleepUpdate.cpp new file mode 100644 index 0000000000..ad88fb27cd --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessBuildingSleepUpdate.cpp @@ -0,0 +1,37 @@ +#include "OpenSHC/Audio/SFX/SFXState.func.hpp" +#include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" +#include "OpenSHC/Synchrony/Actions.func.hpp" +#include "OpenSHC/string-literals.hpp" + +#include "OpenSHC/Globals/DAT_BuildingsState.hpp" +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_SFXState.hpp" + +namespace OpenSHC { +namespace Synchrony { + + // FUNCTION: STRONGHOLDCRUSADER 0x004660F0 + void Actions::ProcessBuildingSleepUpdate(int playerID, int buildingType) + { + if (buildingType >= 91) { + return; + } + if (DAT_GameState::instance.playerDataArray[playerID].snoozedBuildings[buildingType]) { + DAT_GameState::instance.playerDataArray[playerID].snoozedBuildings[buildingType] = false; + if (playerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + MACRO_CALL_MEMBER(Audio::SFX::SFXState_Func::playWAVSFX, DAT_SFXState::ptr)( + s_other_warning7_wav_005a58b0); + } + } else { + DAT_GameState::instance.playerDataArray[playerID].snoozedBuildings[buildingType] = true; + if (playerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + MACRO_CALL_MEMBER(Audio::SFX::SFXState_Func::playWAVSFX, DAT_SFXState::ptr)(SFX_WorkHaltedMyLord); + } + } + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::updateAllBuildingsSnoozedState, DAT_BuildingsState::ptr)( + playerID, buildingType); + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/ProcessBuyOrSell.cpp b/src/OpenSHC/Synchrony/Actions/ProcessBuyOrSell.cpp new file mode 100644 index 0000000000..306f13a152 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessBuyOrSell.cpp @@ -0,0 +1,40 @@ +#include "OpenSHC/Game/GameStateStructures.func.hpp" +#include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" +#include "OpenSHC/Synchrony/Actions.func.hpp" + +#include "OpenSHC/Globals/DAT_BuildingsState.hpp" +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" + +namespace OpenSHC { +namespace Synchrony { + + // FUNCTION: STRONGHOLDCRUSADER 0x00465E60 + void Actions::ProcessBuyOrSell(int playerID, int buyOrSell, ResourceType resourceType) + { + if (buyOrSell == 0) { + int const price = MACRO_CALL_MEMBER(Game::GameStateStructures_Func::getBatchBuyPrice, DAT_GameState::ptr)( + playerID, resourceType); + if (price <= DAT_GameState::instance.playerDataArray[playerID].currentResources[Game::Resources::RT_GOLD] + && MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceGain, DAT_BuildingsState::ptr)( + playerID, resourceType, 5)) { + DAT_GameState::instance.playerDataArray[playerID].currentResources[Game::Resources::RT_GOLD] -= price; + DAT_GameState::instance.playerDataArray[playerID].marketGold -= price; + } + } else if (buyOrSell == 1) { + if (DAT_GameState::instance.playerDataArray[playerID].currentResources[resourceType] >= 0) { + int const amount = MACRO_CALL_MEMBER( + Game::GameStateStructures_Func::getSellResourceAmount, DAT_GameState::ptr)(playerID, resourceType); + int const price = MACRO_CALL_MEMBER(Game::GameStateStructures_Func::getSalesPrice, DAT_GameState::ptr)( + playerID, resourceType); + DAT_GameSynchronyState::instance.finalResults.finalGold[playerID] += price; + DAT_GameState::instance.playerDataArray[playerID].currentResources[Game::Resources::RT_GOLD] += price; + DAT_GameState::instance.playerDataArray[playerID].marketGold += price; + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceLoss, DAT_BuildingsState::ptr)( + playerID, resourceType, amount, 0); + } + } + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/ProcessRecruitUnit.cpp b/src/OpenSHC/Synchrony/Actions/ProcessRecruitUnit.cpp new file mode 100644 index 0000000000..7bc0056eb5 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessRecruitUnit.cpp @@ -0,0 +1,74 @@ +#include "../Actions.func.hpp" + +#include "OpenSHC/Map/Units/UnitsState.func.hpp" +#include "OpenSHC/Game/Player/Enums/BuildingEntryInfoEnum.hpp" +#include "OpenSHC/Map/Units/UnitType.hpp" + +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_UnitsState.hpp" + +namespace OpenSHC { +namespace Synchrony { + + using namespace OpenSHC::Game::Player::Enums; + using namespace OpenSHC::Map::Units; + + // FUNCTION: STRONGHOLDCRUSADER 0x00464EF0 + void Actions::ProcessRecruitUnit(int playerID, int unitType, undefined4 recruitmentBuildingID) + { + if (DAT_GameState::instance.playerDataArray[playerID].armySize + + DAT_GameState::instance.playerDataArray[playerID].count_2 + >= DAT_GameState::instance.mapAndTime.armySizeLimit) { + return; + } + if (unitType == UT_E_ENGINEER) { + MACRO_CALL_MEMBER(UnitsState_Func::nonEuroRecruit, DAT_UnitsState::ptr)((UnitType)unitType, + DAT_GameState::instance.playerDataArray[playerID].buildingEntryInfos[BEIE_ENGINEERSGUILD].id, playerID, + 0); + } else if (unitType == UT_TUNNELER) { + MACRO_CALL_MEMBER(UnitsState_Func::nonEuroRecruit, DAT_UnitsState::ptr)((UnitType)unitType, + DAT_GameState::instance.playerDataArray[playerID].buildingEntryInfos[BEIE_TUNNELERSGUILD].id, playerID, + 0); + } else if (unitType == UT_E_LADDER) { + MACRO_CALL_MEMBER(UnitsState_Func::nonEuroRecruit, DAT_UnitsState::ptr)((UnitType)unitType, + DAT_GameState::instance.playerDataArray[playerID].buildingEntryInfos[BEIE_ENGINEERSGUILD].id, playerID, + 0); + } else if (unitType == UT_E_MONK) { + MACRO_CALL_MEMBER(UnitsState_Func::nonEuroRecruit, DAT_UnitsState::ptr)( + (UnitType)unitType, recruitmentBuildingID, playerID, 0); + } else if (unitType == UT_A_ARCHER) { + MACRO_CALL_MEMBER(UnitsState_Func::nonEuroRecruit, DAT_UnitsState::ptr)((UnitType)unitType, + DAT_GameState::instance.playerDataArray[playerID].buildingEntryInfos[BEIE_MERCENARYPOST].id, playerID, + 0); + } else if (unitType == UT_A_SLAVE) { + MACRO_CALL_MEMBER(UnitsState_Func::nonEuroRecruit, DAT_UnitsState::ptr)((UnitType)unitType, + DAT_GameState::instance.playerDataArray[playerID].buildingEntryInfos[BEIE_MERCENARYPOST].id, playerID, + 0); + } else if (unitType == UT_A_SLINGER) { + MACRO_CALL_MEMBER(UnitsState_Func::nonEuroRecruit, DAT_UnitsState::ptr)((UnitType)unitType, + DAT_GameState::instance.playerDataArray[playerID].buildingEntryInfos[BEIE_MERCENARYPOST].id, playerID, + 0); + } else if (unitType == UT_A_ASSASSIN) { + MACRO_CALL_MEMBER(UnitsState_Func::nonEuroRecruit, DAT_UnitsState::ptr)((UnitType)unitType, + DAT_GameState::instance.playerDataArray[playerID].buildingEntryInfos[BEIE_MERCENARYPOST].id, playerID, + 0); + } else if (unitType == UT_A_HARCHER) { + MACRO_CALL_MEMBER(UnitsState_Func::nonEuroRecruit, DAT_UnitsState::ptr)((UnitType)unitType, + DAT_GameState::instance.playerDataArray[playerID].buildingEntryInfos[BEIE_MERCENARYPOST].id, playerID, + 0); + } else if (unitType == UT_A_SWORDSMAN) { + MACRO_CALL_MEMBER(UnitsState_Func::nonEuroRecruit, DAT_UnitsState::ptr)((UnitType)unitType, + DAT_GameState::instance.playerDataArray[playerID].buildingEntryInfos[BEIE_MERCENARYPOST].id, playerID, + 0); + } else if (unitType == UT_A_FIRETHROWER) { + MACRO_CALL_MEMBER(UnitsState_Func::nonEuroRecruit, DAT_UnitsState::ptr)((UnitType)unitType, + DAT_GameState::instance.playerDataArray[playerID].buildingEntryInfos[BEIE_MERCENARYPOST].id, playerID, + 0); + } else { + MACRO_CALL_MEMBER(UnitsState_Func::euroRecruit, DAT_UnitsState::ptr)(unitType, + DAT_GameState::instance.playerDataArray[playerID].buildingEntryInfos[BEIE_BARRACKS].id, playerID, 0); + } + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/ProcessReleaseDogs.cpp b/src/OpenSHC/Synchrony/Actions/ProcessReleaseDogs.cpp new file mode 100644 index 0000000000..317a8255ac --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessReleaseDogs.cpp @@ -0,0 +1,74 @@ +#include "../Actions.func.hpp" + +#include "OpenSHC/Audio/SFX/SFXState.func.hpp" +#include "OpenSHC/Map/Units/UnitsState.func.hpp" + +#include "OpenSHC/Globals/DAT_BuildingsState.hpp" +#include "OpenSHC/Globals/DAT_SFXState.hpp" +#include "OpenSHC/Globals/DAT_UnitsState.hpp" + +namespace OpenSHC { +namespace Synchrony { + + using namespace OpenSHC::Map::Units; + + // FUNCTION: STRONGHOLDCRUSADER 0x00466430 + void Actions::ProcessReleaseDogs(int param_1, int buildingID, int buildingUID) + { + int const x = DAT_BuildingsState::instance.buildings[buildingID].x; + int const y = DAT_BuildingsState::instance.buildings[buildingID].y; + if (DAT_BuildingsState::instance.buildings[buildingID].uid != buildingUID) { + return; + } + DAT_BuildingsState::instance.buildings[buildingID].flagonsOfAleOrCheeseOrReleaseDogs = 1; + for (int i = 0; i < 4; ++i) { + DAT_BuildingsState::instance.buildings[buildingID].insideUnitID[i] = 0; + DAT_BuildingsState::instance.buildings[buildingID].insideUnitUID[i] = 0; + } + int const dog0ID = MACRO_CALL_MEMBER(UnitsState_Func::spawnUnit, DAT_UnitsState::ptr)( + 0, param_1, x * 8, y * 8, DAT_BuildingsState::instance.buildings[buildingID].terrainHeightUnk, UT_CAGEDOG); + if (dog0ID != 0) { + DAT_UnitsState::instance.units[dog0ID].workplaceBuildingID_1 = (short)buildingID; + DAT_UnitsState::instance.units[dog0ID].workplaceBuildingUID + = DAT_BuildingsState::instance.buildings[buildingID].uid; + DAT_BuildingsState::instance.buildings[buildingID].insideUnitID[0] = (short)dog0ID; + DAT_BuildingsState::instance.buildings[buildingID].insideUnitUID[0] + = DAT_UnitsState::instance.units[dog0ID].uid; + } + int const dog1ID = MACRO_CALL_MEMBER(UnitsState_Func::spawnUnit, DAT_UnitsState::ptr)(0, param_1, x * 8 + 8, + y * 8, DAT_BuildingsState::instance.buildings[buildingID].terrainHeightUnk, UT_CAGEDOG); + if (dog1ID != 0) { + DAT_UnitsState::instance.units[dog1ID].workplaceBuildingID_1 = (short)buildingID; + DAT_UnitsState::instance.units[dog1ID].workplaceBuildingUID + = DAT_BuildingsState::instance.buildings[buildingID].uid; + DAT_BuildingsState::instance.buildings[buildingID].insideUnitID[1] = (short)dog1ID; + DAT_BuildingsState::instance.buildings[buildingID].insideUnitUID[1] + = DAT_UnitsState::instance.units[dog1ID].uid; + } + int const dog2ID = MACRO_CALL_MEMBER(UnitsState_Func::spawnUnit, DAT_UnitsState::ptr)(0, param_1, x * 8, + y * 8 + 8, DAT_BuildingsState::instance.buildings[buildingID].terrainHeightUnk, UT_CAGEDOG); + if (dog2ID != 0) { + DAT_UnitsState::instance.units[dog2ID].workplaceBuildingID_1 = (short)buildingID; + DAT_UnitsState::instance.units[dog2ID].workplaceBuildingUID + = DAT_BuildingsState::instance.buildings[buildingID].uid; + DAT_BuildingsState::instance.buildings[buildingID].insideUnitID[2] = (short)dog2ID; + DAT_BuildingsState::instance.buildings[buildingID].insideUnitUID[2] + = DAT_UnitsState::instance.units[dog2ID].uid; + } + int const dog3ID = MACRO_CALL_MEMBER(UnitsState_Func::spawnUnit, DAT_UnitsState::ptr)(0, param_1, x * 8 + 8, + y * 8 + 8, DAT_BuildingsState::instance.buildings[buildingID].terrainHeightUnk, UT_CAGEDOG); + if (dog3ID != 0) { + DAT_UnitsState::instance.units[dog3ID].workplaceBuildingID_1 = (short)buildingID; + DAT_UnitsState::instance.units[dog3ID].workplaceBuildingUID + = DAT_BuildingsState::instance.buildings[buildingID].uid; + DAT_BuildingsState::instance.buildings[buildingID].insideUnitID[3] = (short)dog3ID; + DAT_BuildingsState::instance.buildings[buildingID].insideUnitUID[3] + = DAT_UnitsState::instance.units[dog3ID].uid; + } + MACRO_CALL_MEMBER(Audio::SFX::SFXState_Func::playSFXAtLocation, DAT_SFXState::ptr)( + DAT_BuildingsState::instance.buildings[buildingID].x, DAT_BuildingsState::instance.buildings[buildingID].y, + DE::SHCDE::FX_DOG_CAGE); + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/ProcessTowerRepair.cpp b/src/OpenSHC/Synchrony/Actions/ProcessTowerRepair.cpp new file mode 100644 index 0000000000..92b938b63e --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessTowerRepair.cpp @@ -0,0 +1,47 @@ +#include "OpenSHC/Audio/MissingResourceState.func.hpp" +#include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" +#include "OpenSHC/Synchrony/Actions.func.hpp" + +#include "OpenSHC/Globals/DAT_BuildingsState.hpp" +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_MissingResourceState.hpp" + +namespace OpenSHC { +namespace Synchrony { + + // FUNCTION: STRONGHOLDCRUSADER 0x00466260 + void Actions::ProcessTowerRepair( + int playerID, int buildingID, int requiredWood, int requiredStone, int gameObjectID) + { + if (DAT_BuildingsState::instance.buildings[buildingID].uid != gameObjectID) { + return; + } + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::updateRepairCostAndReturnIfDamaged, + DAT_BuildingsState::ptr)(buildingID); + if (requiredWood + > DAT_GameState::instance.playerDataArray[playerID].currentResources[Game::Resources::RT_WOOD]) { + if (playerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + MACRO_CALL_MEMBER(Audio::MissingResourceState_Func::playResourceLackSFX, DAT_MissingResourceState::ptr)( + 1, Audio::SFX::RLSFX_WOOD); + } + return; + } + if (requiredStone + > DAT_GameState::instance.playerDataArray[playerID].currentResources[Game::Resources::RT_STONE]) { + if (playerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + MACRO_CALL_MEMBER(Audio::MissingResourceState_Func::playResourceLackSFX, DAT_MissingResourceState::ptr)( + 1, Audio::SFX::RLSFX_STONE); + } + return; + } + DAT_BuildingsState::instance.buildings[buildingID].currentHealth + = DAT_BuildingsState::instance.buildings[buildingID].maxHealth; + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceLoss, DAT_BuildingsState::ptr)( + playerID, Game::Resources::RT_WOOD, requiredWood, 0); + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceLoss, DAT_BuildingsState::ptr)( + playerID, Game::Resources::RT_STONE, requiredStone, 0); + } + +} +} diff --git a/src/OpenSHC/Synchrony/Actions/TryAcquireAmmunitionOrPlanToBuyStone.cpp b/src/OpenSHC/Synchrony/Actions/TryAcquireAmmunitionOrPlanToBuyStone.cpp new file mode 100644 index 0000000000..6e626836a3 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/TryAcquireAmmunitionOrPlanToBuyStone.cpp @@ -0,0 +1,27 @@ +#include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" +#include "OpenSHC/Synchrony/Actions.func.hpp" + +#include "OpenSHC/Globals/DAT_BuildingsState.hpp" +#include "OpenSHC/Globals/DAT_GameState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_UnitsState.hpp" + +namespace OpenSHC { +namespace Synchrony { + + // FUNCTION: STRONGHOLDCRUSADER 0x00465F20 + void Actions::TryAcquireAmmunitionOrPlanToBuyStone(int playerID, int unitID) + { + if (DAT_GameState::instance.playerDataArray[playerID].currentResources[Game::Resources::RT_STONE] >= 10) { + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceLoss, DAT_BuildingsState::ptr)( + playerID, Game::Resources::RT_STONE, 10, 0); + DAT_UnitsState::instance.units[unitID].stoneAmmunition += 20; + } else if (DAT_GameSynchronyState::instance.currentGameMode != 0 + && DAT_GameSynchronyState::instance.currentPlayerFullIDArray[playerID] == -1 + && DAT_GameSynchronyState::instance.currentAIArray[playerID] != 0) { + DAT_GameState::instance.playerDataArray[playerID].resourcesToAcquireArray[Game::Resources::RT_STONE] = 10; + } + } + +} +} diff --git a/src/OpenSHC/Synchrony/Commands/ClickDestroyBuilding.cpp b/src/OpenSHC/Synchrony/Commands/ClickDestroyBuilding.cpp new file mode 100644 index 0000000000..a16e0641a1 --- /dev/null +++ b/src/OpenSHC/Synchrony/Commands/ClickDestroyBuilding.cpp @@ -0,0 +1,124 @@ +#include "../Commands.func.hpp" + +#include "OpenSHC/Audio/SFX/SFXState.func.hpp" +#include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" +#include "OpenSHC/Map/TileMapState.func.hpp" +#include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" +#include "OpenSHC/Commands/GameCommandParameterLocation.hpp" +#include "OpenSHC/Commands/GameCommandParameterReadWrite.hpp" +#include "OpenSHC/Commands/GameCommandScheduling.hpp" +#include "OpenSHC/string-literals.hpp" + +#include "OpenSHC/Globals/DAT_BuildingsState.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_SFXState.hpp" +#include "OpenSHC/Globals/DAT_TileMapState.hpp" + +namespace OpenSHC { +namespace Synchrony { + + using namespace OpenSHC::Commands; + using namespace OpenSHC::Map::Buildings; + + // FUNCTION: STRONGHOLDCRUSADER 0x00481F40 + void Commands::ClickDestroyBuilding() + { + DAT_GameSynchronyState::instance.DAT_CommandSize = 7; + if (DAT_GameSynchronyState::instance.DAT_CommandActionPlan == GCS_SCHEDULE_AND_SEND) { + MACRO_CALL_MEMBER(GameSynchronyState_Func::serializeOrDeserializeCommandParameter, + DAT_GameSynchronyState::ptr)(&DAT_GameSynchronyState::instance.DAT_GameCommandParam0, 2, + GCPL_DYNAMIC_COMMAND_DATA_ADDRESS, GCPRW_SERIALIZE_INTO_PARAM_1); + MACRO_CALL_MEMBER(GameSynchronyState_Func::serializeOrDeserializeCommandParameter, + DAT_GameSynchronyState::ptr)(&DAT_GameSynchronyState::instance.DAT_GameCommandParam1, 1, + GCPL_DYNAMIC_COMMAND_DATA_ADDRESS, GCPRW_SERIALIZE_INTO_PARAM_1); + MACRO_CALL_MEMBER(GameSynchronyState_Func::serializeOrDeserializeCommandParameter, + DAT_GameSynchronyState::ptr)(&DAT_GameSynchronyState::instance.DAT_GameCommandParam2, 4, + GCPL_DYNAMIC_COMMAND_DATA_ADDRESS, GCPRW_SERIALIZE_INTO_PARAM_1); + return; + } + if (DAT_GameSynchronyState::instance.DAT_CommandActionPlan != GCS_EXECUTE) { + return; + } + short targetID; + MACRO_CALL_MEMBER(GameSynchronyState_Func::serializeOrDeserializeCommandParameter, DAT_GameSynchronyState::ptr)( + &targetID, 2, GCPL_DYNAMIC_COMMAND_DATA_ADDRESS, GCPRW_DESERIALIZE_FROM_PARAM1); + DAT_GameSynchronyState::instance.DAT_GameCommandParam0 = targetID; + DAT_GameSynchronyState::instance.DAT_GameCommandParam1 = 0; + MACRO_CALL_MEMBER(GameSynchronyState_Func::serializeOrDeserializeCommandParameter, DAT_GameSynchronyState::ptr)( + &DAT_GameSynchronyState::instance.DAT_GameCommandParam1, 1, GCPL_DYNAMIC_COMMAND_DATA_ADDRESS, + GCPRW_DESERIALIZE_FROM_PARAM1); + MACRO_CALL_MEMBER(GameSynchronyState_Func::serializeOrDeserializeCommandParameter, DAT_GameSynchronyState::ptr)( + &DAT_GameSynchronyState::instance.DAT_GameCommandParam2, 4, GCPL_DYNAMIC_COMMAND_DATA_ADDRESS, + GCPRW_DESERIALIZE_FROM_PARAM1); + + if (DAT_GameSynchronyState::instance.DAT_GameCommandParam0 > 0) { + int const buildingID = DAT_GameSynchronyState::instance.DAT_GameCommandParam0; + if (DAT_BuildingsState::instance.buildings[buildingID].uid + != DAT_GameSynchronyState::instance.DAT_GameCommandParam2) { + return; + } + int drawbridgeID = MACRO_CALL_MEMBER(BuildingsState_Func::findParticularBuilding, DAT_BuildingsState::ptr)( + DAT_BuildingsState::instance.buildings[buildingID].owner, + DAT_BuildingsState::instance.buildings[buildingID].x, + DAT_BuildingsState::instance.buildings[buildingID].y, + DAT_BuildingsState::instance.buildings[buildingID].widthOrHeight, BT_DRAWBRIDGE, 0); + if (drawbridgeID != 0) { + DAT_TileMapState::instance.showNoRubbleWhenDestroyingBuilding = 1; + MACRO_CALL_MEMBER(BuildingsState_Func::giveBackResourceForDestroyedBuilding, DAT_BuildingsState::ptr)( + drawbridgeID, DAT_GameSynchronyState::instance.protocolInvokerPlayerID, + DAT_GameSynchronyState::instance.DAT_GameCommandParam1); + MACRO_CALL_MEMBER(BuildingsState_Func::destroyBuilding, DAT_BuildingsState::ptr)(drawbridgeID); + drawbridgeID = MACRO_CALL_MEMBER(BuildingsState_Func::findParticularBuilding, DAT_BuildingsState::ptr)( + DAT_BuildingsState::instance.buildings[buildingID].owner, + DAT_BuildingsState::instance.buildings[buildingID].x, + DAT_BuildingsState::instance.buildings[buildingID].y, + DAT_BuildingsState::instance.buildings[buildingID].widthOrHeight, BT_DRAWBRIDGE, drawbridgeID); + if (drawbridgeID != 0) { + DAT_TileMapState::instance.showNoRubbleWhenDestroyingBuilding = 1; + MACRO_CALL_MEMBER(BuildingsState_Func::giveBackResourceForDestroyedBuilding, + DAT_BuildingsState::ptr)(drawbridgeID, DAT_GameSynchronyState::instance.protocolInvokerPlayerID, + DAT_GameSynchronyState::instance.DAT_GameCommandParam1); + MACRO_CALL_MEMBER(BuildingsState_Func::destroyBuilding, DAT_BuildingsState::ptr)(drawbridgeID); + } + } + DAT_TileMapState::instance.showNoRubbleWhenDestroyingBuilding = 1; + if (DAT_BuildingsState::instance.buildings[buildingID].suppressDestroyRefund == 0) { + MACRO_CALL_MEMBER(BuildingsState_Func::giveBackResourceForDestroyedBuilding, DAT_BuildingsState::ptr)( + DAT_GameSynchronyState::instance.DAT_GameCommandParam0, + DAT_GameSynchronyState::instance.protocolInvokerPlayerID, + DAT_GameSynchronyState::instance.DAT_GameCommandParam1); + } + if (buildingID != 0 + && DAT_BuildingsState::instance.buildings[buildingID].owner + == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + switch (DAT_BuildingsState::instance.buildings[buildingID].buildingType) { + case BT_GATEHOUSELARGE: + case BT_GATEHOUSESMALL: + case BT_TOWER1: + case BT_TOWER2: + case BT_TOWER3: + case BT_TOWER4: + case BT_TOWER5: + MACRO_CALL_MEMBER(Audio::SFX::SFXState_Func::playSFXAtLocation, DAT_SFXState::ptr)( + DAT_BuildingsState::instance.buildings[buildingID].x, + DAT_BuildingsState::instance.buildings[buildingID].y, DE::SHCDE::FX_TOWER_SMASH); + break; + default: + MACRO_CALL_MEMBER(Audio::SFX::SFXState_Func::playWAVSFX, DAT_SFXState::ptr)( + s_buildingwreck_01_wav_005a4d78); + break; + } + } + MACRO_CALL_MEMBER(BuildingsState_Func::destroyBuilding, DAT_BuildingsState::ptr)( + DAT_GameSynchronyState::instance.DAT_GameCommandParam0); + } else { + int const pitchDitchID = -DAT_GameSynchronyState::instance.DAT_GameCommandParam0; + if (DAT_TileMapState::instance.pitchDitches[pitchDitchID].uid + == DAT_GameSynchronyState::instance.DAT_GameCommandParam2) { + MACRO_CALL_MEMBER(Map::TileMapState_Func::destroyPitchDitch, DAT_TileMapState::ptr)(pitchDitchID); + } + } + } + +} +} diff --git a/src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp b/src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp new file mode 100644 index 0000000000..b296fff5b7 --- /dev/null +++ b/src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp @@ -0,0 +1,38 @@ +// disable deprecation warnings for strcpy +#pragma warning(disable : 4996) + +#include "../Synchrony.func.hpp" + +#include "OpenSHC/OS.func.hpp" +#include "OpenSHC/WindowsHelper/Enums/BOOLEnum.hpp" + +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/GUID_DPAID_Modem.hpp" + +namespace OpenSHC { + +using WindowsHelper::Enums::BOOLEnum; + +// FUNCTION: STRONGHOLDCRUSADER 0x0047E160 +BOOLEnum __stdcall Synchrony::DirectPlayModemRelated_MemoryAllocationCallback( + int* param_1, undefined4 param_2, char* param_3, undefined4 param_4) +{ + char* entry = param_3; + if (MACRO_CALL(OS_Func::isEqualGUID)((GUID*)param_1, &GUID_DPAID_Modem::instance)) { + while (strlen(entry) != 0) { + if (DAT_GameSynchronyState::instance.modemScrollbarCount >= 30) { + return FALSE; + } + DAT_GameSynchronyState::instance.stringPointerArray[DAT_GameSynchronyState::instance.modemScrollbarCount] + = (char*)MACRO_CALL(OS_Func::_malloc)(strlen(entry) + 2); + strcpy(DAT_GameSynchronyState::instance + .stringPointerArray[DAT_GameSynchronyState::instance.modemScrollbarCount], + entry); + DAT_GameSynchronyState::instance.modemScrollbarCount += 1; + entry += strlen(entry) + 1; + } + } + return TRUE; +} + +} diff --git a/src/OpenSHC/Synchrony/EnumDisplayModesCallback.cpp b/src/OpenSHC/Synchrony/EnumDisplayModesCallback.cpp new file mode 100644 index 0000000000..1c3d818ca4 --- /dev/null +++ b/src/OpenSHC/Synchrony/EnumDisplayModesCallback.cpp @@ -0,0 +1,49 @@ +#include "../Synchrony.func.hpp" + +#include "OpenSHC/Globals/DAT_WindowAndDirectDraw.hpp" + +namespace OpenSHC { + +// FUNCTION: STRONGHOLDCRUSADER 0x00467BC0 +HRESULT __stdcall Synchrony::EnumDisplayModesCallback(DDSURFACEDESC* displayDesc, LPVOID userParam) +{ + DWORD const width = displayDesc->dwWidth; + DWORD const height = displayDesc->dwHeight; + DWORD const bitCount = displayDesc->ddpfPixelFormat.dwRGBBitCount; + if (bitCount == 15 || bitCount == 16) { + if (width == 800 && height == 600) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._800x600 = 1; + } else if (width == 1024 && height == 768) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1024x768 = 1; + } else if (width == 1024 && height == 600) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1024x600 = 1; + } else if (width == 1280 && height == 1024) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1280x1024 = 1; + } else if (width == 1600 && height == 1200) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1600x1200 = 1; + } else if (width == 1280 && height == 720) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1280x720 = 1; + } else if (width == 1440 && height == 900) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1440x900 = 1; + } else if (width == 1920 && height == 1080) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1920x1080 = 1; + } else if (width == 1920 && height == 1200) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1920x1200 = 1; + } else if (width == 2560 && height == 1440) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._2560x1440 = 1; + } else if (width == 2560 && height == 1600) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._2560x1600 = 1; + } else if (width == 1366 && height == 768) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1366x768 = 1; + } else if (width == 1360 && height == 768) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1360x768 = 1; + } else if (width == 1680 && height == 1050) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1680x1050 = 1; + } else if (width == 1600 && height == 900) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1600x900 = 1; + } + } + return DDENUMRET_OK; +} + +} diff --git a/src/OpenSHC/Synchrony/MemCopyFromParameter.cpp b/src/OpenSHC/Synchrony/MemCopyFromParameter.cpp new file mode 100644 index 0000000000..1b2fc93075 --- /dev/null +++ b/src/OpenSHC/Synchrony/MemCopyFromParameter.cpp @@ -0,0 +1,28 @@ +#include "OpenSHC/OS.func.hpp" +#include "OpenSHC/Synchrony.func.hpp" +#include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" +#include "OpenSHC/string-literals.hpp" + +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" + +namespace OpenSHC { + +// FUNCTION: STRONGHOLDCRUSADER 0x00488480 +void Synchrony::MemCopyFromParameter(char* dest, size_t size, undefined4 playerID) +{ + char message[1000]; + char* const received = (char*)MACRO_CALL(OpenSHC::OS_Func::_malloc)(size); + MACRO_CALL_MEMBER( + Synchrony::GameSynchronyState_Func::serializeOrDeserializeCommandParameter, DAT_GameSynchronyState::ptr)( + received, size, Commands::GCPL_FIXED_COMMAND_DATA_ADDRESS, Commands::GCPRW_DESERIALIZE_FROM_PARAM1); + for (int i = 0; i < (int)size; ++i) { + if (received[i] != dest[i]) { + MACRO_CALL(OpenSHC::OS_Func::_sprintf)( + message, s_ID_d_OF_d_M_d_S_d_005a72d8, playerID, i, (int)received[i], (int)dest[i]); + } + dest[i] = received[i]; + } + MACRO_CALL(OpenSHC::OS_Func::_free_base)(received); +} + +} diff --git a/src/OpenSHC/Synchrony/PutPlayerIntoRandomSlot.cpp b/src/OpenSHC/Synchrony/PutPlayerIntoRandomSlot.cpp new file mode 100644 index 0000000000..fb89c7d753 --- /dev/null +++ b/src/OpenSHC/Synchrony/PutPlayerIntoRandomSlot.cpp @@ -0,0 +1,46 @@ +#include "../Synchrony.func.hpp" + +#include "OpenSHC/Random/RNG.func.hpp" + +#include "OpenSHC/Globals/DAT_GameCore.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/SEC_RNG.hpp" + +namespace OpenSHC { + +// FUNCTION: STRONGHOLDCRUSADER 0x00428480 +void Synchrony::PutPlayerIntoRandomSlot(int param_1) +{ + for (int slot = 0; slot < 8; ++slot) { + if (DAT_GameSynchronyState::instance.playerPositionsArray[slot] == param_1 - 1) { + return; + } + } + int usableSlots = 0; + int takenSlots = 0; + for (int slot = 0; slot < 8; ++slot) { + if (DAT_GameCore::instance.keepPositions[slot].x < 0) { + continue; + } + ++usableSlots; + if (DAT_GameSynchronyState::instance.playerPositionsArray[slot] >= 0) { + ++takenSlots; + } + } + if (usableSlots <= takenSlots) { + return; + } + int freeIndex = SEC_RNG::instance.currentNumber1 % (usableSlots - takenSlots); + MACRO_CALL_MEMBER(Random::RNG_Func::nextRandomNumber1, SEC_RNG::ptr)(); + for (int slot = 0; slot < 8; ++slot) { + if (DAT_GameCore::instance.keepPositions[slot].x >= 0 + && DAT_GameSynchronyState::instance.playerPositionsArray[slot] < 0) { + if (--freeIndex < 0) { + DAT_GameSynchronyState::instance.playerPositionsArray[slot] = param_1 - 1; + return; + } + } + } +} + +} diff --git a/src/OpenSHC/Synchrony/ResetAiVariationArrayValue.cpp b/src/OpenSHC/Synchrony/ResetAiVariationArrayValue.cpp new file mode 100644 index 0000000000..b3027e8fba --- /dev/null +++ b/src/OpenSHC/Synchrony/ResetAiVariationArrayValue.cpp @@ -0,0 +1,31 @@ +#include "OpenSHC/Synchrony.func.hpp" + +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" + +namespace OpenSHC { + +// FUNCTION: STRONGHOLDCRUSADER 0x00428050 +void Synchrony::ResetAiVariationArrayValue(int playerID) +{ + if ((uint)(playerID - 1) > 7) { + return; + } + DAT_GameSynchronyState::instance.aiVariationArray[playerID] = -1; + BOOLEnum variationUsed[9] = { FALSE }; + for (int other = 1; other < 9; ++other) { + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[other] == -1 + && DAT_GameSynchronyState::instance.currentAIArray[other] + == DAT_GameSynchronyState::instance.currentAIArray[playerID] + && DAT_GameSynchronyState::instance.aiVariationArray[other] != -1) { + variationUsed[DAT_GameSynchronyState::instance.aiVariationArray[other]] = TRUE; + } + } + for (int variation = 0; variation < 9; ++variation) { + if (!variationUsed[variation]) { + DAT_GameSynchronyState::instance.aiVariationArray[playerID] = variation; + return; + } + } +} + +} diff --git a/src/OpenSHC/Synchrony/SetAIPlayerNickNames.cpp b/src/OpenSHC/Synchrony/SetAIPlayerNickNames.cpp new file mode 100644 index 0000000000..42c65922c7 --- /dev/null +++ b/src/OpenSHC/Synchrony/SetAIPlayerNickNames.cpp @@ -0,0 +1,120 @@ +#include "../Synchrony.func.hpp" + +#include "OpenSHC/Text/TextManager.func.hpp" +#include "OpenSHC/AI/AIType.hpp" + +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_TextManagerObject.hpp" + +namespace OpenSHC { + +// FUNCTION: STRONGHOLDCRUSADER 0x0042A8E0 +void Synchrony::SetAIPlayerNickNames() +{ + for (int player = 1; player < 9; ++player) { + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[player] != -1 + || DAT_GameSynchronyState::instance.currentAIArray[player] == AI::AIT_NULL) { + continue; + } + switch (DAT_GameSynchronyState::instance.currentAIArray[player]) { + case 1: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 111)); + break; + case 2: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 119)); + break; + case 3: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 127)); + break; + case 4: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 135)); + break; + case 5: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 143)); + break; + case 6: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 151)); + break; + case 7: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 159)); + break; + case 8: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 167)); + break; + case 9: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 175)); + break; + case 10: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 183)); + break; + case 11: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 191)); + break; + case 12: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 199)); + break; + case 13: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 207)); + break; + case 14: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 215)); + break; + case 15: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 223)); + break; + case 16: + strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, + DAT_GameSynchronyState::instance.aiVariationArray[player] + 231)); + break; + } + } +} + +} diff --git a/src/OpenSHC/Synchrony/SyncPlayerGroupArrays.cpp b/src/OpenSHC/Synchrony/SyncPlayerGroupArrays.cpp new file mode 100644 index 0000000000..f82c034500 --- /dev/null +++ b/src/OpenSHC/Synchrony/SyncPlayerGroupArrays.cpp @@ -0,0 +1,22 @@ +#include "OpenSHC/Synchrony.func.hpp" + +#include "OpenSHC/Globals/DAT_00df423c.hpp" +#include "OpenSHC/Globals/DAT_00df4240.hpp" +#include "OpenSHC/Globals/DAT_00df4288.hpp" +#include "OpenSHC/Globals/DAT_00df4298.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" + +namespace OpenSHC { + +// FUNCTION: STRONGHOLDCRUSADER 0x004AEA10 +void Synchrony::SyncPlayerGroupArrays() +{ + DAT_00df423c::instance = 0; + DAT_00df4288::instance = 0; + memcpy(DAT_GameSynchronyState::instance.playerGroupArray2Unk, DAT_GameSynchronyState::instance.DAT_PlayerGroupArray, + sizeof(DAT_GameSynchronyState::instance.playerGroupArray2Unk)); + DAT_00df4240::instance = 0; + DAT_00df4298::instance = 0; +} + +} diff --git a/status/addresses-SHC-3BB0A8C1.txt b/status/addresses-SHC-3BB0A8C1.txt index a70f614bd4..10b05b205f 100644 --- a/status/addresses-SHC-3BB0A8C1.txt +++ b/status/addresses-SHC-3BB0A8C1.txt @@ -6859,11 +6859,11 @@ SHC_3BB0A8C1_0x0042804E | 0.0% | Pending SHC_3BB0A8C1_0x0042804F | 0.0% | Pending -SHC_3BB0A8C1_0x00428050 | 0.0% | Pending +SHC_3BB0A8C1_0x00428050 | 100.0% | Reimplemented SHC_3BB0A8C1_0x00428150 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x00428480 | 0.0% | Pending +SHC_3BB0A8C1_0x00428480 | 100.0% | Pending SHC_3BB0A8C1_0x00428590 | 0.0% | Pending @@ -6895,7 +6895,7 @@ SHC_3BB0A8C1_0x00429630 | 100.0% | Reimplemented SHC_3BB0A8C1_0x00429650 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x00429710 | 0.0% | Pending +SHC_3BB0A8C1_0x00429710 | 100.0% | Pending SHC_3BB0A8C1_0x004297E0 | 0.0% | Pending @@ -6939,7 +6939,7 @@ SHC_3BB0A8C1_0x0042A480 | 0.0% | Pending SHC_3BB0A8C1_0x0042A840 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x0042A8E0 | 0.0% | Pending +SHC_3BB0A8C1_0x0042A8E0 | 100.0% | Pending SHC_3BB0A8C1_0x0042ABFC | 0.0% | Pending @@ -19853,7 +19853,7 @@ SHC_3BB0A8C1_0x00464DA0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x00464E80 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x00464EF0 | 0.0% | Pending +SHC_3BB0A8C1_0x00464EF0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x00465040 | 100.0% | Reimplemented @@ -19875,13 +19875,13 @@ SHC_3BB0A8C1_0x004652D0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x00465360 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004653B0 | 0.0% | Pending +SHC_3BB0A8C1_0x004653B0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004653F0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x00465480 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004654F0 | 0.0% | Pending +SHC_3BB0A8C1_0x004654F0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x00465560 | 100.0% | Reimplemented @@ -19923,23 +19923,23 @@ SHC_3BB0A8C1_0x00465A20 | 100.0% | Reimplemented SHC_3BB0A8C1_0x00465DB0 | 0.0% | Pending -SHC_3BB0A8C1_0x00465E60 | 0.0% | Pending +SHC_3BB0A8C1_0x00465E60 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x00465F20 | 0.0% | Pending +SHC_3BB0A8C1_0x00465F20 | 100.0% | Reimplemented SHC_3BB0A8C1_0x00465F90 | 0.0% | Pending SHC_3BB0A8C1_0x004660B0 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004660F0 | 0.0% | Pending +SHC_3BB0A8C1_0x004660F0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x00466160 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x00466260 | 0.0% | Pending +SHC_3BB0A8C1_0x00466260 | 100.0% | Reimplemented SHC_3BB0A8C1_0x00466320 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x00466430 | 0.0% | Pending +SHC_3BB0A8C1_0x00466430 | 100.0% | Pending SHC_3BB0A8C1_0x00466480 | 0.0% | Pending @@ -20035,7 +20035,7 @@ SHC_3BB0A8C1_0x00467A90 | 100.0% | Reimplemented, only the window procedure's re SHC_3BB0A8C1_0x00467B40 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x00467BC0 | 0.0% | Pending +SHC_3BB0A8C1_0x00467BC0 | 100.0% | Pending SHC_3BB0A8C1_0x00467D80 | 0.0% | Pending @@ -22355,7 +22355,7 @@ SHC_3BB0A8C1_0x0047E050 | 100.0% | Reimplemented SHC_3BB0A8C1_0x0047E0E0 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x0047E160 | 0.0% | Pending +SHC_3BB0A8C1_0x0047E160 | 100.0% | Pending SHC_3BB0A8C1_0x0047E1A0 | 0.0% | Pending @@ -22471,7 +22471,7 @@ SHC_3BB0A8C1_0x00481C80 | 0.0% | Pending SHC_3BB0A8C1_0x00481D90 | 0.0% | Pending -SHC_3BB0A8C1_0x00481F40 | 0.0% | Pending +SHC_3BB0A8C1_0x00481F40 | 100.0% | Pending SHC_3BB0A8C1_0x004821AC | 0.0% | Pending @@ -23043,7 +23043,7 @@ SHC_3BB0A8C1_0x00486AF0 | 0.0% | Pending SHC_3BB0A8C1_0x00486B10 | 0.0% | Pending -SHC_3BB0A8C1_0x00486C40 | 0.0% | Pending +SHC_3BB0A8C1_0x00486C40 | 100.0% | Pending SHC_3BB0A8C1_0x00486C60 | 0.0% | Pending @@ -23083,7 +23083,7 @@ SHC_3BB0A8C1_0x004880E0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004882A0 | 0.0% | Pending -SHC_3BB0A8C1_0x00488480 | 0.0% | Pending +SHC_3BB0A8C1_0x00488480 | 100.0% | Reimplemented (counted: only the security cookie symbols differ) SHC_3BB0A8C1_0x00488540 | 100.0% | Reimplemented @@ -25789,7 +25789,7 @@ SHC_3BB0A8C1_0x004AC440 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004AC4C0 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004AC570 | 0.0% | Pending +SHC_3BB0A8C1_0x004AC570 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004AC650 | 100.0% | Reimplemented @@ -25797,25 +25797,25 @@ SHC_3BB0A8C1_0x004AC6E0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004AC7A0 | 0.0% | Pending -SHC_3BB0A8C1_0x004AD110 | 0.0% | Pending +SHC_3BB0A8C1_0x004AD110 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004AD1E0 | 0.0% | Pending +SHC_3BB0A8C1_0x004AD1E0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004AD2B0 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004AD2F0 | 0.0% | Pending +SHC_3BB0A8C1_0x004AD2F0 | 100.0% | Pending SHC_3BB0A8C1_0x004AD480 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004AD780 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004AD7C0 | 0.0% | Pending +SHC_3BB0A8C1_0x004AD7C0 | 100.0% | Pending SHC_3BB0A8C1_0x004AD920 | 0.0% | Pending SHC_3BB0A8C1_0x004ADD90 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004ADDD0 | 0.0% | Pending +SHC_3BB0A8C1_0x004ADDD0 | 100.0% | Pending SHC_3BB0A8C1_0x004ADFE4 | 0.0% | Pending @@ -25861,7 +25861,7 @@ SHC_3BB0A8C1_0x004AE001 | 0.0% | Pending SHC_3BB0A8C1_0x004AE002 | 0.0% | Pending -SHC_3BB0A8C1_0x004AE010 | 0.0% | Pending +SHC_3BB0A8C1_0x004AE010 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004AE070 | 100.0% | Reimplemented @@ -25877,7 +25877,7 @@ SHC_3BB0A8C1_0x004AE7D0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004AE950 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004AEA10 | 0.0% | Pending +SHC_3BB0A8C1_0x004AEA10 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004AEA50 | 0.0% | Pending @@ -27073,9 +27073,9 @@ SHC_3BB0A8C1_0x004B7600 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004B7700 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004B7730 | 0.0% | Pending +SHC_3BB0A8C1_0x004B7730 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004B77A0 | 0.0% | Pending +SHC_3BB0A8C1_0x004B77A0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004B77E0 | 100.0% | Reimplemented @@ -34153,7 +34153,7 @@ SHC_3BB0A8C1_0x004C6B20 | 0.0% | Pending SHC_3BB0A8C1_0x004C6B90 | 0.0% | Pending -SHC_3BB0A8C1_0x004C6CD0 | 0.0% | Pending +SHC_3BB0A8C1_0x004C6CD0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004C6D30 | 100.0% | Reimplemented @@ -35465,7 +35465,7 @@ SHC_3BB0A8C1_0x004D12A0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004D1320 | 0.0% | Pending -SHC_3BB0A8C1_0x004D1700 | 0.0% | Pending +SHC_3BB0A8C1_0x004D1700 | 100.0% | Pending SHC_3BB0A8C1_0x004D1710 | 0.0% | Pending From 1cb57fdb536ad8d9eba5c601fe89602833829e92 Mon Sep 17 00:00:00 2001 From: Jake Vawter Date: Sun, 15 Nov 2026 21:00:59 -0500 Subject: [PATCH 03/12] headers: the screen resolution flags are BOOLEnum Co-Authored-By: Claude Opus 5.5 --- .../Rendering/ScreenResolutionArrayStruct.hpp | 36 ++++++++++--------- .../Rendering/ScreenResolutionUnion.hpp | 6 +++- 2 files changed, 25 insertions(+), 17 deletions(-) diff --git a/src/OpenSHC/Rendering/ScreenResolutionArrayStruct.hpp b/src/OpenSHC/Rendering/ScreenResolutionArrayStruct.hpp index 0b608805b9..c7e62ab3c6 100644 --- a/src/OpenSHC/Rendering/ScreenResolutionArrayStruct.hpp +++ b/src/OpenSHC/Rendering/ScreenResolutionArrayStruct.hpp @@ -8,29 +8,33 @@ #pragma once +#include "OpenSHC/WindowsHelper/Enums/BOOLEnum.hpp" + namespace OpenSHC { namespace Rendering { + using OpenSHC::WindowsHelper::Enums::BOOLEnum; + #pragma pack(push, 1) // SIZE: 0x00000040 typedef struct ScreenResolutionArrayStruct { - int noneUnk; // 0x00000000 length: 4 - int _800x600; // 0x00000004 length: 4 - int _1024x768; // 0x00000008 length: 4 - int _1280x720; // 0x0000000C length: 4 - int _1280x1024; // 0x00000010 length: 4 - int _1366x768; // 0x00000014 length: 4 - int _1440x900; // 0x00000018 length: 4 - int _1600x900; // 0x0000001C length: 4 - int _1600x1200; // 0x00000020 length: 4 - int _1680x1050; // 0x00000024 length: 4 - int _1920x1080; // 0x00000028 length: 4 - int _1920x1200; // 0x0000002C length: 4 - int _2560x1440; // 0x00000030 length: 4 - int _2560x1600; // 0x00000034 length: 4 - int _1360x768; // 0x00000038 length: 4 - int _1024x600; // 0x0000003C length: 4 + BOOLEnum noneUnk; // 0x00000000 length: 4 + BOOLEnum _800x600; // 0x00000004 length: 4 + BOOLEnum _1024x768; // 0x00000008 length: 4 + BOOLEnum _1280x720; // 0x0000000C length: 4 + BOOLEnum _1280x1024; // 0x00000010 length: 4 + BOOLEnum _1366x768; // 0x00000014 length: 4 + BOOLEnum _1440x900; // 0x00000018 length: 4 + BOOLEnum _1600x900; // 0x0000001C length: 4 + BOOLEnum _1600x1200; // 0x00000020 length: 4 + BOOLEnum _1680x1050; // 0x00000024 length: 4 + BOOLEnum _1920x1080; // 0x00000028 length: 4 + BOOLEnum _1920x1200; // 0x0000002C length: 4 + BOOLEnum _2560x1440; // 0x00000030 length: 4 + BOOLEnum _2560x1600; // 0x00000034 length: 4 + BOOLEnum _1360x768; // 0x00000038 length: 4 + BOOLEnum _1024x600; // 0x0000003C length: 4 } ScreenResolutionArrayStruct; #pragma pack(pop) diff --git a/src/OpenSHC/Rendering/ScreenResolutionUnion.hpp b/src/OpenSHC/Rendering/ScreenResolutionUnion.hpp index 90400256a2..154da976ff 100644 --- a/src/OpenSHC/Rendering/ScreenResolutionUnion.hpp +++ b/src/OpenSHC/Rendering/ScreenResolutionUnion.hpp @@ -8,11 +8,15 @@ #pragma once +#include "OpenSHC/WindowsHelper/Enums/BOOLEnum.hpp" + #include "OpenSHC/Rendering/ScreenResolutionArrayStruct.hpp" namespace OpenSHC { namespace Rendering { + using OpenSHC::WindowsHelper::Enums::BOOLEnum; + using OpenSHC::Rendering::ScreenResolutionArrayStruct; #pragma pack(push, 1) @@ -20,7 +24,7 @@ namespace Rendering { typedef union ScreenResolutionUnion { ScreenResolutionArrayStruct fields; // 0x00000000 length: 64 - int array[16]; // 0x00000000 length: 64 + BOOLEnum array[16]; // 0x00000000 length: 64 } ScreenResolutionUnion; #pragma pack(pop) From ed31291c3579eccf5f0174f768f019b64a252499 Mon Sep 17 00:00:00 2001 From: Jake Vawter Date: Sun, 15 Nov 2026 21:01:59 -0500 Subject: [PATCH 04/12] headers: ProcessAllyRequestingGoods takes a ResourceTypeMin1, ProcessAllyGoodsRequest parameter names, DAT_LastTeamMemberIndex is an int Co-Authored-By: Claude Opus 5.5 --- src/OpenSHC/Globals/DAT_LastTeamMemberIndex.hpp | 2 +- src/OpenSHC/Synchrony/Actions.func.hpp | 6 ++++-- src/OpenSHC/Synchrony/Actions.hpp | 8 ++++++-- 3 files changed, 11 insertions(+), 5 deletions(-) diff --git a/src/OpenSHC/Globals/DAT_LastTeamMemberIndex.hpp b/src/OpenSHC/Globals/DAT_LastTeamMemberIndex.hpp index 0ba86b789e..c3175b9157 100644 --- a/src/OpenSHC/Globals/DAT_LastTeamMemberIndex.hpp +++ b/src/OpenSHC/Globals/DAT_LastTeamMemberIndex.hpp @@ -13,7 +13,7 @@ namespace OpenSHC { -MACRO_STRUCT_RESOLVER(undefined4, false, Address::SHC_3BB0A8C1_0x00DF42A8) DAT_LastTeamMemberIndex; +MACRO_STRUCT_RESOLVER(int, false, Address::SHC_3BB0A8C1_0x00DF42A8) DAT_LastTeamMemberIndex; } // namespace OpenSHC MACRO_STRUCT_INSTANCE(Address::SHC_3BB0A8C1_0x00DF42A8); diff --git a/src/OpenSHC/Synchrony/Actions.func.hpp b/src/OpenSHC/Synchrony/Actions.func.hpp index 17ae21b6cd..01a098c63a 100644 --- a/src/OpenSHC/Synchrony/Actions.func.hpp +++ b/src/OpenSHC/Synchrony/Actions.func.hpp @@ -82,11 +82,13 @@ namespace Synchrony { false, Address::SHC_3BB0A8C1_0x004AD2F0, &OpenSHC::Synchrony::Actions::ProcessAllyRequestAttackDefense) ProcessAllyRequestAttackDefense; - MACRO_FUNCTION_RESOLVER(void(__cdecl*)(int askedPlayerID, int param_2, int amount, int askee), false, + MACRO_FUNCTION_RESOLVER( + void(__cdecl*)(int askedPlayerID, ResourceTypeMin1 requestedResource, int amount, int askee), false, Address::SHC_3BB0A8C1_0x004AD7C0, &OpenSHC::Synchrony::Actions::ProcessAllyRequestingGoods) ProcessAllyRequestingGoods; - MACRO_FUNCTION_RESOLVER(void(__cdecl*)(int param_1, ResourceType param_2, int param_3, int param_4), false, + MACRO_FUNCTION_RESOLVER( + void(__cdecl*)(int receiverPlayerID, ResourceType requestedResource, int amount, int senderPlayerID), false, Address::SHC_3BB0A8C1_0x004ADDD0, &OpenSHC::Synchrony::Actions::ProcessAllyGoodsRequest) ProcessAllyGoodsRequest; diff --git a/src/OpenSHC/Synchrony/Actions.hpp b/src/OpenSHC/Synchrony/Actions.hpp index 9066c19d8e..0d7a1a36f4 100644 --- a/src/OpenSHC/Synchrony/Actions.hpp +++ b/src/OpenSHC/Synchrony/Actions.hpp @@ -9,11 +9,13 @@ #pragma once #include "OpenSHC/Game/Resources/ResourceType.hpp" +#include "OpenSHC/Game/Resources/ResourceTypeMin1.hpp" namespace OpenSHC { namespace Synchrony { namespace Actions { using OpenSHC::Game::Resources::ResourceType; + using OpenSHC::Game::Resources::ResourceTypeMin1; void __cdecl RemovePositionOfPlayer(int playerID); @@ -50,9 +52,11 @@ namespace Synchrony { void __cdecl ProcessAllyRequestAttackDefense( int targetPlayerID, int playerID, int requestedByPlayerID, int param_4); - void __cdecl ProcessAllyRequestingGoods(int askedPlayerID, int param_2, int amount, int askee); + void __cdecl ProcessAllyRequestingGoods( + int askedPlayerID, ResourceTypeMin1 requestedResource, int amount, int askee); - void __cdecl ProcessAllyGoodsRequest(int param_1, ResourceType param_2, int param_3, int param_4); + void __cdecl ProcessAllyGoodsRequest( + int receiverPlayerID, ResourceType requestedResource, int amount, int senderPlayerID); void __cdecl ProcessAllyDeniesRequest(int param_1, int param_2); From 03b0702355e69c72f21cb9eebfe94b453361210c Mon Sep 17 00:00:00 2001 From: Jake Vawter Date: Sun, 15 Nov 2026 21:03:10 -0500 Subject: [PATCH 05/12] headers: DirectPlay address callback parameters (GUID, size, data, context), ProcessReleaseDogs takes the display colour Co-Authored-By: Claude Opus 5.5 --- src/OpenSHC/Synchrony.func.hpp | 4 ++-- src/OpenSHC/Synchrony.hpp | 2 +- src/OpenSHC/Synchrony/Actions.func.hpp | 2 +- src/OpenSHC/Synchrony/Actions.hpp | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/OpenSHC/Synchrony.func.hpp b/src/OpenSHC/Synchrony.func.hpp index 93eddbe6dd..de541ffd29 100644 --- a/src/OpenSHC/Synchrony.func.hpp +++ b/src/OpenSHC/Synchrony.func.hpp @@ -55,8 +55,8 @@ namespace Synchrony_Func { Address::SHC_3BB0A8C1_0x0047DF40, &OpenSHC::Synchrony::EnumSessionsCallback_addSession_async) EnumSessionsCallback_addSession_async; - MACRO_FUNCTION_RESOLVER(BOOLEnum(__stdcall*)(int* param_1, undefined4 param_2, char* param_3, undefined4 param_4), - false, Address::SHC_3BB0A8C1_0x0047E160, &OpenSHC::Synchrony::DirectPlayModemRelated_MemoryAllocationCallback) + MACRO_FUNCTION_RESOLVER(BOOLEnum(__stdcall*)(GUID* guidDataType, DWORD dataSize, char* data, void* context), false, + Address::SHC_3BB0A8C1_0x0047E160, &OpenSHC::Synchrony::DirectPlayModemRelated_MemoryAllocationCallback) DirectPlayModemRelated_MemoryAllocationCallback; MACRO_FUNCTION_RESOLVER(void(__cdecl*)(char* dest, size_t size, undefined4 playerID), false, diff --git a/src/OpenSHC/Synchrony.hpp b/src/OpenSHC/Synchrony.hpp index e4f62e6b2b..3d74a24787 100644 --- a/src/OpenSHC/Synchrony.hpp +++ b/src/OpenSHC/Synchrony.hpp @@ -39,7 +39,7 @@ namespace Synchrony { LPCDPSESSIONDESC2 lpThisSD, LPDWORD lpdwTimeOut, DWORD dwFlags, LPVOID lpContext); BOOLEnum __stdcall DirectPlayModemRelated_MemoryAllocationCallback( - int* param_1, undefined4 param_2, char* param_3, undefined4 param_4); + GUID* guidDataType, DWORD dataSize, char* data, void* context); void __cdecl MemCopyFromParameter(char* dest, size_t size, undefined4 playerID); diff --git a/src/OpenSHC/Synchrony/Actions.func.hpp b/src/OpenSHC/Synchrony/Actions.func.hpp index 01a098c63a..d0ab764624 100644 --- a/src/OpenSHC/Synchrony/Actions.func.hpp +++ b/src/OpenSHC/Synchrony/Actions.func.hpp @@ -66,7 +66,7 @@ namespace Synchrony { Address::SHC_3BB0A8C1_0x00466260, &OpenSHC::Synchrony::Actions::ProcessTowerRepair) ProcessTowerRepair; - MACRO_FUNCTION_RESOLVER(void(__cdecl*)(int param_1, int buildingID, int buildingUID), false, + MACRO_FUNCTION_RESOLVER(void(__cdecl*)(int displayColor, int buildingID, int buildingUID), false, Address::SHC_3BB0A8C1_0x00466430, &OpenSHC::Synchrony::Actions::ProcessReleaseDogs) ProcessReleaseDogs; diff --git a/src/OpenSHC/Synchrony/Actions.hpp b/src/OpenSHC/Synchrony/Actions.hpp index 0d7a1a36f4..897d036a21 100644 --- a/src/OpenSHC/Synchrony/Actions.hpp +++ b/src/OpenSHC/Synchrony/Actions.hpp @@ -43,7 +43,7 @@ namespace Synchrony { void __cdecl ProcessTowerRepair( int playerID, int buildingID, int requiredWood, int requiredStone, int gameObjectID); - void __cdecl ProcessReleaseDogs(int param_1, int buildingID, int buildingUID); + void __cdecl ProcessReleaseDogs(int displayColor, int buildingID, int buildingUID); void __cdecl ProcessAllyAcceptsRequest(int param_1, int param_2); From f33fde9fcd0e052b84b335a9d27242523c3ee85d Mon Sep 17 00:00:00 2001 From: Jake Vawter Date: Sun, 15 Nov 2026 21:03:18 -0500 Subject: [PATCH 06/12] Review: relative main includes first, countof bounds, readable range check, TRUE for the resolution flags, BT_CESSPIT, named parameters, no needless casts Co-Authored-By: Claude Opus 5.5 --- .../initializeScenarioEvent.cpp | 4 +- .../InGameEventUnionVersion/resetEvent.cpp | 4 +- .../Game/Skirmish/RecalculateAllies.cpp | 12 ++-- .../SetupSkirmishBalanceAndOrIntensity.cpp | 17 ++--- .../commitSkirmishSettings.cpp | 4 +- ...eCurrentGameIntoTemporarySKMasterEntry.cpp | 11 ++-- src/OpenSHC/Game/Skirmish/StoreLocalTime.cpp | 2 +- .../Synchrony/Actions/GateOpenOrClose.cpp | 3 +- .../Actions/OpenOrCloseDrawbridge.cpp | 3 +- .../Actions/ProcessAllyAcceptsRequest.cpp | 3 +- .../Actions/ProcessAllyDeniesRequest.cpp | 3 +- .../Actions/ProcessAllyDeniesRequest2.cpp | 3 +- .../Actions/ProcessAllyGoodsRequest.cpp | 65 ++++++++++--------- .../Actions/ProcessAllyRequestingGoods.cpp | 24 ++++--- .../Actions/ProcessBuildingSleepUpdate.cpp | 5 +- .../Synchrony/Actions/ProcessBuyOrSell.cpp | 3 +- .../Synchrony/Actions/ProcessReleaseDogs.cpp | 18 ++--- .../Synchrony/Actions/ProcessTowerRepair.cpp | 3 +- .../TryAcquireAmmunitionOrPlanToBuyStone.cpp | 3 +- ...yModemRelated_MemoryAllocationCallback.cpp | 10 +-- .../Synchrony/EnumDisplayModesCallback.cpp | 30 ++++----- .../Synchrony/MemCopyFromParameter.cpp | 3 +- .../Synchrony/PutPlayerIntoRandomSlot.cpp | 6 +- .../Synchrony/ResetAiVariationArrayValue.cpp | 8 +-- .../Synchrony/SetAIPlayerNickNames.cpp | 2 +- .../Synchrony/SyncPlayerGroupArrays.cpp | 2 +- 26 files changed, 137 insertions(+), 114 deletions(-) diff --git a/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/initializeScenarioEvent.cpp b/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/initializeScenarioEvent.cpp index 4aa997a21b..3113eb0627 100644 --- a/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/initializeScenarioEvent.cpp +++ b/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/initializeScenarioEvent.cpp @@ -1,4 +1,4 @@ -#include "OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion.func.hpp" +#include "../InGameEventUnionVersion.func.hpp" namespace OpenSHC { namespace Game { @@ -15,7 +15,7 @@ namespace Game { *(short*)&this->data.scenario.allOrAnyCondition = 1; this->data.scenario.repeat = 0; ScenarioEventCondition* condition = this->data.scenario.conditions; - for (int i = 0; i < 40; ++i) { + for (int i = 0; i < countof(this->data.scenario.conditions); ++i) { condition->enabled = 0; condition->value = 0; condition->subType = 0; diff --git a/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/resetEvent.cpp b/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/resetEvent.cpp index cd062f159b..4199ad81ad 100644 --- a/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/resetEvent.cpp +++ b/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/resetEvent.cpp @@ -1,4 +1,4 @@ -#include "OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion.func.hpp" +#include "../InGameEventUnionVersion.func.hpp" namespace OpenSHC { namespace Game { @@ -13,7 +13,7 @@ namespace Game { this->header.tl_type = 1; this->data.invasion.crusaderArabian = 0; this->data.invasion.totalUnitCount = 0; - for (int i = 0; i < 24; ++i) { + for (int i = 0; i < countof(this->data.invasion.unitCountsPerUnitType); ++i) { this->data.invasion.unitCountsPerUnitType[i] = 0; } this->data.invasion.invasionPoint = 0; diff --git a/src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp b/src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp index 51c38a9dae..4bd3eca1a3 100644 --- a/src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp +++ b/src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp @@ -1,4 +1,5 @@ -#include "OpenSHC/Game/Skirmish.func.hpp" +#include "../Skirmish.func.hpp" + #include "OpenSHC/Map/Units/UnitsState.func.hpp" #include "OpenSHC/Globals/DAT_AlliesCount.hpp" @@ -26,7 +27,8 @@ namespace Game { int const team = DAT_GameState::instance.mapAndTime.playerTeams[DAT_GameSynchronyState::instance.currentPlayerSlotID]; DAT_AlliesCount::instance = 0; - for (int player = 1; player < 9; ++player) { + for (int player = 1; player < countof(DAT_GameSynchronyState::instance.currentPlayerFullIDArray); + ++player) { if (player == DAT_GameSynchronyState::instance.currentPlayerSlotID) { continue; } @@ -45,14 +47,14 @@ namespace Game { } DAT_SomeTeamMemberPlayerIDArray::instance[DAT_AlliesCount::instance] = player; DAT_AlliesCount::instance += 1; - if ((int)DAT_AlliesCount::instance >= 6) { + if (DAT_AlliesCount::instance >= 6) { break; } } - if ((int)DAT_LastTeamMemberIndex::instance >= (int)DAT_AlliesCount::instance) { + if (DAT_LastTeamMemberIndex::instance >= DAT_AlliesCount::instance) { DAT_LastTeamMemberIndex::instance = DAT_AlliesCount::instance - 1; } - if ((int)DAT_LastTeamMemberIndex::instance < 0) { + if (DAT_LastTeamMemberIndex::instance < 0) { DAT_LastTeamMemberIndex::instance = 0; } } diff --git a/src/OpenSHC/Game/Skirmish/SetupSkirmishBalanceAndOrIntensity.cpp b/src/OpenSHC/Game/Skirmish/SetupSkirmishBalanceAndOrIntensity.cpp index fde82e7b2a..3e8a3c4311 100644 --- a/src/OpenSHC/Game/Skirmish/SetupSkirmishBalanceAndOrIntensity.cpp +++ b/src/OpenSHC/Game/Skirmish/SetupSkirmishBalanceAndOrIntensity.cpp @@ -1,4 +1,5 @@ -#include "OpenSHC/Game/Skirmish.func.hpp" +#include "../Skirmish.func.hpp" + #include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" #include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" @@ -56,21 +57,21 @@ namespace Game { switch (DAT_GameSynchronyState::instance.skirmishGameIntensityType) { case 1: - for (int i = 0; i < 20; ++i) { + for (int i = 0; i < countof(DAT_GameSynchronyState::instance.skirmishIntensityRelatedArray); ++i) { DAT_GameSynchronyState::instance.skirmishIntensityRelatedArray[i] = DAT_RenderingDefinedData::instance .SkirmishIntensityRelatedArray[0][DAT_GameSynchronyState::instance.skirmishTechLevel][i]; } break; case 2: - for (int i = 0; i < 20; ++i) { + for (int i = 0; i < countof(DAT_GameSynchronyState::instance.skirmishIntensityRelatedArray); ++i) { DAT_GameSynchronyState::instance.skirmishIntensityRelatedArray[i] = DAT_RenderingDefinedData::instance .SkirmishIntensityRelatedArray[1][DAT_GameSynchronyState::instance.skirmishTechLevel][i]; } break; case 3: - for (int i = 0; i < 20; ++i) { + for (int i = 0; i < countof(DAT_GameSynchronyState::instance.skirmishIntensityRelatedArray); ++i) { DAT_GameSynchronyState::instance.skirmishIntensityRelatedArray[i] = DAT_RenderingDefinedData::instance .SkirmishIntensityRelatedArray[2][DAT_GameSynchronyState::instance.skirmishTechLevel][i]; @@ -80,26 +81,26 @@ namespace Game { switch (DAT_GameSynchronyState::instance.skirmishGameIntensityType2) { case 0: - for (int i = 0; i < 10; ++i) { + for (int i = 0; i < countof(DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1); ++i) { DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1[i] = 0; } break; case 1: - for (int i = 0; i < 10; ++i) { + for (int i = 0; i < countof(DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1); ++i) { DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1[i] = DAT_RenderingDefinedData::instance .SkirmishIntensityRelatedArray2[DAT_GameSynchronyState::instance.skirmishTechLevel][i]; } break; case 2: - for (int i = 0; i < 10; ++i) { + for (int i = 0; i < countof(DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1); ++i) { DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1[i] = DAT_RenderingDefinedData::instance.SkirmishIntensityRelatedArray2[5 + DAT_GameSynchronyState::instance.skirmishTechLevel][i]; } break; case 3: - for (int i = 0; i < 10; ++i) { + for (int i = 0; i < countof(DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1); ++i) { DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1[i] = DAT_RenderingDefinedData::instance.SkirmishIntensityRelatedArray2[10 + DAT_GameSynchronyState::instance.skirmishTechLevel][i]; diff --git a/src/OpenSHC/Game/Skirmish/SkirmishLobbySetupStructure/commitSkirmishSettings.cpp b/src/OpenSHC/Game/Skirmish/SkirmishLobbySetupStructure/commitSkirmishSettings.cpp index ee7bf3d412..46520738ce 100644 --- a/src/OpenSHC/Game/Skirmish/SkirmishLobbySetupStructure/commitSkirmishSettings.cpp +++ b/src/OpenSHC/Game/Skirmish/SkirmishLobbySetupStructure/commitSkirmishSettings.cpp @@ -14,7 +14,7 @@ namespace Game { this->mapu4int2 = DAT_GameSynchronyState::instance.skirmishAutoSaveEveryMinutes; this->mbr_0x4 = DAT_GameState::instance.mapAndTime.skirmishFogOfWar; strcpy(this->mapName, DAT_GameSynchronyState::instance.mapName); - for (int player = 0; player < 9; ++player) { + for (int player = 0; player < countof(this->roundTableOrderArray); ++player) { this->roundTableOrderArray[player] = DAT_GameSynchronyState::instance.DAT_RoundTableOrderArray[player]; this->playerGroupArray[player] = DAT_GameSynchronyState::instance.DAT_PlayerGroupArray[player]; this->currentAIArray[player] = DAT_GameSynchronyState::instance.currentAIArray[player]; @@ -32,7 +32,7 @@ namespace Game { this->currentAdvantageBalance = DAT_GameSynchronyState::instance.skirmishCurrentAdvantageBalance; this->currentAdvantageGroup = DAT_GameSynchronyState::instance.skirmishGameIntensityType; this->mbr_0x80 = DAT_GameSynchronyState::instance.skirmishTechLevel; - for (int player = 0; player < 9; ++player) { + for (int player = 0; player < countof(this->playerLordTypeArray); ++player) { this->playerLordTypeArray[player] = DAT_GameCore::instance.selectedLordTypes[player]; } this->mbr_0xf0 = DAT_GameCore::instance.field_0x2340; diff --git a/src/OpenSHC/Game/Skirmish/StoreCurrentGameIntoTemporarySKMasterEntry.cpp b/src/OpenSHC/Game/Skirmish/StoreCurrentGameIntoTemporarySKMasterEntry.cpp index 21f77dff5f..e8e34b3252 100644 --- a/src/OpenSHC/Game/Skirmish/StoreCurrentGameIntoTemporarySKMasterEntry.cpp +++ b/src/OpenSHC/Game/Skirmish/StoreCurrentGameIntoTemporarySKMasterEntry.cpp @@ -1,4 +1,5 @@ -#include "OpenSHC/Game/Skirmish.func.hpp" +#include "../Skirmish.func.hpp" + #include "OpenSHC/UI/GreatestLord.func.hpp" #include "OpenSHC/Globals/DAT_GameCore.hpp" @@ -18,22 +19,22 @@ namespace Game { DAT_SkMasterDataEntry::instance.skMasterScore = MACRO_CALL(UI::GreatestLord_Func::ComputeSkMasterScore)( DAT_GameSynchronyState::instance.currentPlayerSlotID); int activePlayerCount = 0; - for (int player = 1; player < 9; ++player) { + for (int player = 1; player < countof(DAT_GameSynchronyState::instance.finalResults.active); ++player) { if (DAT_GameSynchronyState::instance.finalResults.active[player] == 0) { break; } ++activePlayerCount; } DAT_SkMasterDataEntry::instance.activePlayerCount = activePlayerCount; - for (int player = 1; player < 9; ++player) { + for (int player = 1; player < countof(DAT_SkMasterDataEntry::instance.array1); ++player) { DAT_SkMasterDataEntry::instance.array1[player] = DAT_GameState::instance.mapAndTime.playerGroupArray[player]; } - for (int player = 1; player < 9; ++player) { + for (int player = 1; player < countof(DAT_SkMasterDataEntry::instance.aiArray); ++player) { DAT_SkMasterDataEntry::instance.aiArray[player] = DAT_GameSynchronyState::instance.currentAIArray[player]; } - for (int player = 1; player < 9; ++player) { + for (int player = 1; player < countof(DAT_SkMasterDataEntry::instance.aliveArray); ++player) { DAT_SkMasterDataEntry::instance.aliveArray[player] = DAT_GameState::instance.mapAndTime.playerIsAlive[player]; } diff --git a/src/OpenSHC/Game/Skirmish/StoreLocalTime.cpp b/src/OpenSHC/Game/Skirmish/StoreLocalTime.cpp index a08e01bb8c..eaaea625e4 100644 --- a/src/OpenSHC/Game/Skirmish/StoreLocalTime.cpp +++ b/src/OpenSHC/Game/Skirmish/StoreLocalTime.cpp @@ -1,4 +1,4 @@ -#include "OpenSHC/Game/Skirmish.func.hpp" +#include "../Skirmish.func.hpp" #include "OpenSHC/Globals/DAT_GameCore.hpp" #include "OpenSHC/Globals/DAT_SkMasterDataEntry.hpp" diff --git a/src/OpenSHC/Synchrony/Actions/GateOpenOrClose.cpp b/src/OpenSHC/Synchrony/Actions/GateOpenOrClose.cpp index 39f80d5722..2634415869 100644 --- a/src/OpenSHC/Synchrony/Actions/GateOpenOrClose.cpp +++ b/src/OpenSHC/Synchrony/Actions/GateOpenOrClose.cpp @@ -1,5 +1,6 @@ +#include "../Actions.func.hpp" + #include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" -#include "OpenSHC/Synchrony/Actions.func.hpp" #include "OpenSHC/Globals/DAT_BuildingsState.hpp" diff --git a/src/OpenSHC/Synchrony/Actions/OpenOrCloseDrawbridge.cpp b/src/OpenSHC/Synchrony/Actions/OpenOrCloseDrawbridge.cpp index b2a0675394..ab3f888ab5 100644 --- a/src/OpenSHC/Synchrony/Actions/OpenOrCloseDrawbridge.cpp +++ b/src/OpenSHC/Synchrony/Actions/OpenOrCloseDrawbridge.cpp @@ -1,5 +1,6 @@ +#include "../Actions.func.hpp" + #include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" -#include "OpenSHC/Synchrony/Actions.func.hpp" #include "OpenSHC/Globals/DAT_BuildingsState.hpp" diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyAcceptsRequest.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyAcceptsRequest.cpp index 617844b9ad..92f905c011 100644 --- a/src/OpenSHC/Synchrony/Actions/ProcessAllyAcceptsRequest.cpp +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyAcceptsRequest.cpp @@ -1,4 +1,5 @@ -#include "OpenSHC/Synchrony/Actions.func.hpp" +#include "../Actions.func.hpp" + #include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" #include "OpenSHC/Text/TextManager.func.hpp" diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp index 4397e9140e..676d43992e 100644 --- a/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp @@ -1,4 +1,5 @@ -#include "OpenSHC/Synchrony/Actions.func.hpp" +#include "../Actions.func.hpp" + #include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" #include "OpenSHC/Text/TextManager.func.hpp" diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest2.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest2.cpp index 7c63cf2101..4b70db6eab 100644 --- a/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest2.cpp +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest2.cpp @@ -1,4 +1,5 @@ -#include "OpenSHC/Synchrony/Actions.func.hpp" +#include "../Actions.func.hpp" + #include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" #include "OpenSHC/Text/TextManager.func.hpp" diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp index fc90f2f706..4e30a61efd 100644 --- a/src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp @@ -22,32 +22,35 @@ namespace Synchrony { using namespace OpenSHC::Game::Resources; // FUNCTION: STRONGHOLDCRUSADER 0x004ADDD0 - void Actions::ProcessAllyGoodsRequest(int param_1, ResourceType param_2, int param_3, int param_4) + void Actions::ProcessAllyGoodsRequest( + int receiverPlayerID, ResourceType requestedResource, int amount, int senderPlayerID) { - ResourceType resourceType = param_2; + ResourceType resourceType = requestedResource; if (resourceType == RT_GOLD) { - if (DAT_GameState::instance.playerDataArray[param_4].currentResources[RT_GOLD] < param_3) { - param_3 = DAT_GameState::instance.playerDataArray[param_4].currentResources[RT_GOLD]; + if (DAT_GameState::instance.playerDataArray[senderPlayerID].currentResources[RT_GOLD] < amount) { + amount = DAT_GameState::instance.playerDataArray[senderPlayerID].currentResources[RT_GOLD]; } - DAT_GameSynchronyState::instance.finalResults.finalGoodsRecieved[param_1] += param_3; - DAT_GameState::instance.playerDataArray[param_1].currentResources[RT_GOLD] += param_3; - DAT_GameState::instance.playerDataArray[param_4].currentResources[RT_GOLD] -= param_3; - DAT_GameSynchronyState::instance.finalResults.finalGoodsSent[param_4] += param_3; + DAT_GameSynchronyState::instance.finalResults.finalGoodsRecieved[receiverPlayerID] += amount; + DAT_GameState::instance.playerDataArray[receiverPlayerID].currentResources[RT_GOLD] += amount; + DAT_GameState::instance.playerDataArray[senderPlayerID].currentResources[RT_GOLD] -= amount; + DAT_GameSynchronyState::instance.finalResults.finalGoodsSent[senderPlayerID] += amount; } else { if (resourceType == RT_PARTIALPITCH) { resourceType = RT_PITCH; } MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceGain, DAT_BuildingsState::ptr)( - param_1, resourceType, param_3); + receiverPlayerID, resourceType, amount); MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceLoss, DAT_BuildingsState::ptr)( - param_4, resourceType, param_3, 0); - DAT_GameSynchronyState::instance.finalResults.finalGoodsRecieved[param_1] += MACRO_CALL_MEMBER( - Game::GameStateStructures_Func::getSellPrice, DAT_GameState::ptr)(param_1, resourceType, param_3); - DAT_GameSynchronyState::instance.finalResults.finalGoodsSent[param_4] += MACRO_CALL_MEMBER( - Game::GameStateStructures_Func::getSellPrice, DAT_GameState::ptr)(param_1, resourceType, param_3); + senderPlayerID, resourceType, amount, 0); + DAT_GameSynchronyState::instance.finalResults.finalGoodsRecieved[receiverPlayerID] + += MACRO_CALL_MEMBER(Game::GameStateStructures_Func::getSellPrice, DAT_GameState::ptr)( + receiverPlayerID, resourceType, amount); + DAT_GameSynchronyState::instance.finalResults.finalGoodsSent[senderPlayerID] + += MACRO_CALL_MEMBER(Game::GameStateStructures_Func::getSellPrice, DAT_GameState::ptr)( + receiverPlayerID, resourceType, amount); } - if (param_1 == DAT_GameSynchronyState::instance.currentPlayerSlotID) { - switch (param_2) { + if (receiverPlayerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + switch (requestedResource) { case RT_IRON: case RT_GOLD: MACRO_CALL_MEMBER(Audio::SFX::SFXState_Func::setUpSFXToPlayUnk, DAT_SFXState::ptr)( @@ -72,38 +75,40 @@ namespace Synchrony { } if (DAT_GameSynchronyState::instance.currentGameMode != Game::GM_SOLITARY && DAT_GameSynchronyState::instance.currentGameMode != Game::GM_SKIRMISH_SINGLE_PLAYER) { - if (param_1 == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + if (receiverPlayerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_ALLIES2, 1)); MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( - param_4, 0); + senderPlayerID, 0); MACRO_CALL(OS_Func::_sprintf)(DAT_GameSynchronyState::instance.receivedChatMessage, s__d__s___005a7674, - param_3, + amount, MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( - DE::SHCDE::TEXT_GOODS, param_2)); + DE::SHCDE::TEXT_GOODS, requestedResource)); MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( - param_4, param_1); + senderPlayerID, receiverPlayerID); } - if (param_4 == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + if (senderPlayerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_ALLIES2, 2)); MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( - param_4, 0); + senderPlayerID, 0); MACRO_CALL(OS_Func::_sprintf)(DAT_GameSynchronyState::instance.receivedChatMessage, s__d__s_005a766c, - param_3, + amount, MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( - DE::SHCDE::TEXT_GOODS, param_2)); + DE::SHCDE::TEXT_GOODS, requestedResource)); MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( - param_4, 0); + senderPlayerID, 0); } } - if (param_2 == DAT_GameState::instance.playerDataArray[param_4].requestedGoodsArray1Unk[param_1]) { - DAT_GameState::instance.playerDataArray[param_4].requestedGoodsArray1Unk[param_1] = 0; - DAT_GameState::instance.playerDataArray[param_4].requestedGoodsArray2Unk[param_1] = 0; + if (requestedResource + == DAT_GameState::instance.playerDataArray[senderPlayerID].requestedGoodsArray1Unk[receiverPlayerID]) { + DAT_GameState::instance.playerDataArray[senderPlayerID].requestedGoodsArray1Unk[receiverPlayerID] = 0; + DAT_GameState::instance.playerDataArray[senderPlayerID].requestedGoodsArray2Unk[receiverPlayerID] = 0; } - MACRO_CALL_MEMBER(AI::AICState_Func::playThanksBikFromPlayerToPlayer, DAT_AICState::ptr)(param_1, param_4); + MACRO_CALL_MEMBER(AI::AICState_Func::playThanksBikFromPlayerToPlayer, DAT_AICState::ptr)( + receiverPlayerID, senderPlayerID); } } diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp index 2daac481e9..e4eec068fc 100644 --- a/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp @@ -16,16 +16,18 @@ namespace OpenSHC { namespace Synchrony { using OpenSHC::Game::Resources::ResourceType; + using OpenSHC::Game::Resources::ResourceTypeMin1; // FUNCTION: STRONGHOLDCRUSADER 0x004AD7C0 - void Actions::ProcessAllyRequestingGoods(int askedPlayerID, int param_2, int amount, int askee) + void Actions::ProcessAllyRequestingGoods( + int askedPlayerID, ResourceTypeMin1 requestedResource, int amount, int askee) { - if (param_2 + 1 == Game::Resources::RT_GOLD) { + if (requestedResource + 1 == Game::Resources::RT_GOLD) { if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[askedPlayerID] == -1) { return; } DAT_GameState::instance.playerDataArray[askedPlayerID].requestedGoodsArray1Unk[askee] - = (short)(param_2 + 1); + = (short)(requestedResource + 1); DAT_GameState::instance.playerDataArray[askedPlayerID].requestedGoodsArray2Unk[askee] = (short)amount; if (askedPlayerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, @@ -38,7 +40,7 @@ namespace Synchrony { } if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[askedPlayerID] != -1) { DAT_GameState::instance.playerDataArray[askedPlayerID].requestedGoodsArray1Unk[askee] - = (short)(param_2 + 1); + = (short)(requestedResource + 1); DAT_GameState::instance.playerDataArray[askedPlayerID].requestedGoodsArray2Unk[askee] = (short)amount; if (askedPlayerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, @@ -52,13 +54,15 @@ namespace Synchrony { MACRO_CALL_MEMBER(AI::AICState_Func::playGoodsSentBikFromPlayerToPlayer, DAT_AICState::ptr)( askedPlayerID, askee); MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceGain, DAT_BuildingsState::ptr)( - askee, (ResourceType)(param_2 + 1), amount); + askee, (ResourceType)(requestedResource + 1), amount); MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceLoss, DAT_BuildingsState::ptr)( - askedPlayerID, (ResourceType)(param_2 + 1), amount, 0); - DAT_GameSynchronyState::instance.finalResults.finalGoodsRecieved[askee] += MACRO_CALL_MEMBER( - Game::GameStateStructures_Func::getSellPrice, DAT_GameState::ptr)(askedPlayerID, param_2 + 1, amount); - DAT_GameSynchronyState::instance.finalResults.finalGoodsSent[askedPlayerID] += MACRO_CALL_MEMBER( - Game::GameStateStructures_Func::getSellPrice, DAT_GameState::ptr)(askedPlayerID, param_2 + 1, amount); + askedPlayerID, (ResourceType)(requestedResource + 1), amount, 0); + DAT_GameSynchronyState::instance.finalResults.finalGoodsRecieved[askee] + += MACRO_CALL_MEMBER(Game::GameStateStructures_Func::getSellPrice, DAT_GameState::ptr)( + askedPlayerID, requestedResource + 1, amount); + DAT_GameSynchronyState::instance.finalResults.finalGoodsSent[askedPlayerID] + += MACRO_CALL_MEMBER(Game::GameStateStructures_Func::getSellPrice, DAT_GameState::ptr)( + askedPlayerID, requestedResource + 1, amount); } } diff --git a/src/OpenSHC/Synchrony/Actions/ProcessBuildingSleepUpdate.cpp b/src/OpenSHC/Synchrony/Actions/ProcessBuildingSleepUpdate.cpp index ad88fb27cd..9ed9465d90 100644 --- a/src/OpenSHC/Synchrony/Actions/ProcessBuildingSleepUpdate.cpp +++ b/src/OpenSHC/Synchrony/Actions/ProcessBuildingSleepUpdate.cpp @@ -1,6 +1,7 @@ +#include "../Actions.func.hpp" + #include "OpenSHC/Audio/SFX/SFXState.func.hpp" #include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" -#include "OpenSHC/Synchrony/Actions.func.hpp" #include "OpenSHC/string-literals.hpp" #include "OpenSHC/Globals/DAT_BuildingsState.hpp" @@ -14,7 +15,7 @@ namespace Synchrony { // FUNCTION: STRONGHOLDCRUSADER 0x004660F0 void Actions::ProcessBuildingSleepUpdate(int playerID, int buildingType) { - if (buildingType >= 91) { + if (buildingType >= Map::Buildings::BT_CESSPIT) { return; } if (DAT_GameState::instance.playerDataArray[playerID].snoozedBuildings[buildingType]) { diff --git a/src/OpenSHC/Synchrony/Actions/ProcessBuyOrSell.cpp b/src/OpenSHC/Synchrony/Actions/ProcessBuyOrSell.cpp index 306f13a152..02a1c5c7b4 100644 --- a/src/OpenSHC/Synchrony/Actions/ProcessBuyOrSell.cpp +++ b/src/OpenSHC/Synchrony/Actions/ProcessBuyOrSell.cpp @@ -1,6 +1,7 @@ +#include "../Actions.func.hpp" + #include "OpenSHC/Game/GameStateStructures.func.hpp" #include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" -#include "OpenSHC/Synchrony/Actions.func.hpp" #include "OpenSHC/Globals/DAT_BuildingsState.hpp" #include "OpenSHC/Globals/DAT_GameState.hpp" diff --git a/src/OpenSHC/Synchrony/Actions/ProcessReleaseDogs.cpp b/src/OpenSHC/Synchrony/Actions/ProcessReleaseDogs.cpp index 317a8255ac..2331e07dd7 100644 --- a/src/OpenSHC/Synchrony/Actions/ProcessReleaseDogs.cpp +++ b/src/OpenSHC/Synchrony/Actions/ProcessReleaseDogs.cpp @@ -13,7 +13,7 @@ namespace Synchrony { using namespace OpenSHC::Map::Units; // FUNCTION: STRONGHOLDCRUSADER 0x00466430 - void Actions::ProcessReleaseDogs(int param_1, int buildingID, int buildingUID) + void Actions::ProcessReleaseDogs(int displayColor, int buildingID, int buildingUID) { int const x = DAT_BuildingsState::instance.buildings[buildingID].x; int const y = DAT_BuildingsState::instance.buildings[buildingID].y; @@ -21,12 +21,12 @@ namespace Synchrony { return; } DAT_BuildingsState::instance.buildings[buildingID].flagonsOfAleOrCheeseOrReleaseDogs = 1; - for (int i = 0; i < 4; ++i) { + for (int i = 0; i < countof(DAT_BuildingsState::instance.buildings[buildingID].insideUnitID); ++i) { DAT_BuildingsState::instance.buildings[buildingID].insideUnitID[i] = 0; DAT_BuildingsState::instance.buildings[buildingID].insideUnitUID[i] = 0; } - int const dog0ID = MACRO_CALL_MEMBER(UnitsState_Func::spawnUnit, DAT_UnitsState::ptr)( - 0, param_1, x * 8, y * 8, DAT_BuildingsState::instance.buildings[buildingID].terrainHeightUnk, UT_CAGEDOG); + int const dog0ID = MACRO_CALL_MEMBER(UnitsState_Func::spawnUnit, DAT_UnitsState::ptr)(0, displayColor, x * 8, + y * 8, DAT_BuildingsState::instance.buildings[buildingID].terrainHeightUnk, UT_CAGEDOG); if (dog0ID != 0) { DAT_UnitsState::instance.units[dog0ID].workplaceBuildingID_1 = (short)buildingID; DAT_UnitsState::instance.units[dog0ID].workplaceBuildingUID @@ -35,8 +35,8 @@ namespace Synchrony { DAT_BuildingsState::instance.buildings[buildingID].insideUnitUID[0] = DAT_UnitsState::instance.units[dog0ID].uid; } - int const dog1ID = MACRO_CALL_MEMBER(UnitsState_Func::spawnUnit, DAT_UnitsState::ptr)(0, param_1, x * 8 + 8, - y * 8, DAT_BuildingsState::instance.buildings[buildingID].terrainHeightUnk, UT_CAGEDOG); + int const dog1ID = MACRO_CALL_MEMBER(UnitsState_Func::spawnUnit, DAT_UnitsState::ptr)(0, displayColor, + x * 8 + 8, y * 8, DAT_BuildingsState::instance.buildings[buildingID].terrainHeightUnk, UT_CAGEDOG); if (dog1ID != 0) { DAT_UnitsState::instance.units[dog1ID].workplaceBuildingID_1 = (short)buildingID; DAT_UnitsState::instance.units[dog1ID].workplaceBuildingUID @@ -45,7 +45,7 @@ namespace Synchrony { DAT_BuildingsState::instance.buildings[buildingID].insideUnitUID[1] = DAT_UnitsState::instance.units[dog1ID].uid; } - int const dog2ID = MACRO_CALL_MEMBER(UnitsState_Func::spawnUnit, DAT_UnitsState::ptr)(0, param_1, x * 8, + int const dog2ID = MACRO_CALL_MEMBER(UnitsState_Func::spawnUnit, DAT_UnitsState::ptr)(0, displayColor, x * 8, y * 8 + 8, DAT_BuildingsState::instance.buildings[buildingID].terrainHeightUnk, UT_CAGEDOG); if (dog2ID != 0) { DAT_UnitsState::instance.units[dog2ID].workplaceBuildingID_1 = (short)buildingID; @@ -55,8 +55,8 @@ namespace Synchrony { DAT_BuildingsState::instance.buildings[buildingID].insideUnitUID[2] = DAT_UnitsState::instance.units[dog2ID].uid; } - int const dog3ID = MACRO_CALL_MEMBER(UnitsState_Func::spawnUnit, DAT_UnitsState::ptr)(0, param_1, x * 8 + 8, - y * 8 + 8, DAT_BuildingsState::instance.buildings[buildingID].terrainHeightUnk, UT_CAGEDOG); + int const dog3ID = MACRO_CALL_MEMBER(UnitsState_Func::spawnUnit, DAT_UnitsState::ptr)(0, displayColor, + x * 8 + 8, y * 8 + 8, DAT_BuildingsState::instance.buildings[buildingID].terrainHeightUnk, UT_CAGEDOG); if (dog3ID != 0) { DAT_UnitsState::instance.units[dog3ID].workplaceBuildingID_1 = (short)buildingID; DAT_UnitsState::instance.units[dog3ID].workplaceBuildingUID diff --git a/src/OpenSHC/Synchrony/Actions/ProcessTowerRepair.cpp b/src/OpenSHC/Synchrony/Actions/ProcessTowerRepair.cpp index 92b938b63e..2b121f80ca 100644 --- a/src/OpenSHC/Synchrony/Actions/ProcessTowerRepair.cpp +++ b/src/OpenSHC/Synchrony/Actions/ProcessTowerRepair.cpp @@ -1,6 +1,7 @@ +#include "../Actions.func.hpp" + #include "OpenSHC/Audio/MissingResourceState.func.hpp" #include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" -#include "OpenSHC/Synchrony/Actions.func.hpp" #include "OpenSHC/Globals/DAT_BuildingsState.hpp" #include "OpenSHC/Globals/DAT_GameState.hpp" diff --git a/src/OpenSHC/Synchrony/Actions/TryAcquireAmmunitionOrPlanToBuyStone.cpp b/src/OpenSHC/Synchrony/Actions/TryAcquireAmmunitionOrPlanToBuyStone.cpp index 6e626836a3..5fef392902 100644 --- a/src/OpenSHC/Synchrony/Actions/TryAcquireAmmunitionOrPlanToBuyStone.cpp +++ b/src/OpenSHC/Synchrony/Actions/TryAcquireAmmunitionOrPlanToBuyStone.cpp @@ -1,5 +1,6 @@ +#include "../Actions.func.hpp" + #include "OpenSHC/Map/Buildings/BuildingsState.func.hpp" -#include "OpenSHC/Synchrony/Actions.func.hpp" #include "OpenSHC/Globals/DAT_BuildingsState.hpp" #include "OpenSHC/Globals/DAT_GameState.hpp" diff --git a/src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp b/src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp index b296fff5b7..fdd57dc28d 100644 --- a/src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp +++ b/src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp @@ -1,8 +1,8 @@ +#include "../Synchrony.func.hpp" + // disable deprecation warnings for strcpy #pragma warning(disable : 4996) -#include "../Synchrony.func.hpp" - #include "OpenSHC/OS.func.hpp" #include "OpenSHC/WindowsHelper/Enums/BOOLEnum.hpp" @@ -15,10 +15,10 @@ using WindowsHelper::Enums::BOOLEnum; // FUNCTION: STRONGHOLDCRUSADER 0x0047E160 BOOLEnum __stdcall Synchrony::DirectPlayModemRelated_MemoryAllocationCallback( - int* param_1, undefined4 param_2, char* param_3, undefined4 param_4) + GUID* guidDataType, DWORD dataSize, char* data, void* context) { - char* entry = param_3; - if (MACRO_CALL(OS_Func::isEqualGUID)((GUID*)param_1, &GUID_DPAID_Modem::instance)) { + char* entry = data; + if (MACRO_CALL(OS_Func::isEqualGUID)(guidDataType, &GUID_DPAID_Modem::instance)) { while (strlen(entry) != 0) { if (DAT_GameSynchronyState::instance.modemScrollbarCount >= 30) { return FALSE; diff --git a/src/OpenSHC/Synchrony/EnumDisplayModesCallback.cpp b/src/OpenSHC/Synchrony/EnumDisplayModesCallback.cpp index 1c3d818ca4..d0fb9afbea 100644 --- a/src/OpenSHC/Synchrony/EnumDisplayModesCallback.cpp +++ b/src/OpenSHC/Synchrony/EnumDisplayModesCallback.cpp @@ -12,35 +12,35 @@ HRESULT __stdcall Synchrony::EnumDisplayModesCallback(DDSURFACEDESC* displayDesc DWORD const bitCount = displayDesc->ddpfPixelFormat.dwRGBBitCount; if (bitCount == 15 || bitCount == 16) { if (width == 800 && height == 600) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._800x600 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._800x600 = TRUE; } else if (width == 1024 && height == 768) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1024x768 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1024x768 = TRUE; } else if (width == 1024 && height == 600) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1024x600 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1024x600 = TRUE; } else if (width == 1280 && height == 1024) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1280x1024 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1280x1024 = TRUE; } else if (width == 1600 && height == 1200) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1600x1200 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1600x1200 = TRUE; } else if (width == 1280 && height == 720) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1280x720 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1280x720 = TRUE; } else if (width == 1440 && height == 900) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1440x900 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1440x900 = TRUE; } else if (width == 1920 && height == 1080) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1920x1080 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1920x1080 = TRUE; } else if (width == 1920 && height == 1200) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1920x1200 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1920x1200 = TRUE; } else if (width == 2560 && height == 1440) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._2560x1440 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._2560x1440 = TRUE; } else if (width == 2560 && height == 1600) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._2560x1600 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._2560x1600 = TRUE; } else if (width == 1366 && height == 768) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1366x768 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1366x768 = TRUE; } else if (width == 1360 && height == 768) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1360x768 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1360x768 = TRUE; } else if (width == 1680 && height == 1050) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1680x1050 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1680x1050 = TRUE; } else if (width == 1600 && height == 900) { - DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1600x900 = 1; + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1600x900 = TRUE; } } return DDENUMRET_OK; diff --git a/src/OpenSHC/Synchrony/MemCopyFromParameter.cpp b/src/OpenSHC/Synchrony/MemCopyFromParameter.cpp index 1b2fc93075..4689768d2b 100644 --- a/src/OpenSHC/Synchrony/MemCopyFromParameter.cpp +++ b/src/OpenSHC/Synchrony/MemCopyFromParameter.cpp @@ -1,5 +1,6 @@ +#include "../Synchrony.func.hpp" + #include "OpenSHC/OS.func.hpp" -#include "OpenSHC/Synchrony.func.hpp" #include "OpenSHC/Synchrony/GameSynchronyState.func.hpp" #include "OpenSHC/string-literals.hpp" diff --git a/src/OpenSHC/Synchrony/PutPlayerIntoRandomSlot.cpp b/src/OpenSHC/Synchrony/PutPlayerIntoRandomSlot.cpp index fb89c7d753..573196c602 100644 --- a/src/OpenSHC/Synchrony/PutPlayerIntoRandomSlot.cpp +++ b/src/OpenSHC/Synchrony/PutPlayerIntoRandomSlot.cpp @@ -11,14 +11,14 @@ namespace OpenSHC { // FUNCTION: STRONGHOLDCRUSADER 0x00428480 void Synchrony::PutPlayerIntoRandomSlot(int param_1) { - for (int slot = 0; slot < 8; ++slot) { + for (int slot = 0; slot < countof(DAT_GameSynchronyState::instance.playerPositionsArray); ++slot) { if (DAT_GameSynchronyState::instance.playerPositionsArray[slot] == param_1 - 1) { return; } } int usableSlots = 0; int takenSlots = 0; - for (int slot = 0; slot < 8; ++slot) { + for (int slot = 0; slot < countof(DAT_GameCore::instance.keepPositions); ++slot) { if (DAT_GameCore::instance.keepPositions[slot].x < 0) { continue; } @@ -32,7 +32,7 @@ void Synchrony::PutPlayerIntoRandomSlot(int param_1) } int freeIndex = SEC_RNG::instance.currentNumber1 % (usableSlots - takenSlots); MACRO_CALL_MEMBER(Random::RNG_Func::nextRandomNumber1, SEC_RNG::ptr)(); - for (int slot = 0; slot < 8; ++slot) { + for (int slot = 0; slot < countof(DAT_GameCore::instance.keepPositions); ++slot) { if (DAT_GameCore::instance.keepPositions[slot].x >= 0 && DAT_GameSynchronyState::instance.playerPositionsArray[slot] < 0) { if (--freeIndex < 0) { diff --git a/src/OpenSHC/Synchrony/ResetAiVariationArrayValue.cpp b/src/OpenSHC/Synchrony/ResetAiVariationArrayValue.cpp index b3027e8fba..01ae1b3d66 100644 --- a/src/OpenSHC/Synchrony/ResetAiVariationArrayValue.cpp +++ b/src/OpenSHC/Synchrony/ResetAiVariationArrayValue.cpp @@ -1,4 +1,4 @@ -#include "OpenSHC/Synchrony.func.hpp" +#include "../Synchrony.func.hpp" #include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" @@ -7,12 +7,12 @@ namespace OpenSHC { // FUNCTION: STRONGHOLDCRUSADER 0x00428050 void Synchrony::ResetAiVariationArrayValue(int playerID) { - if ((uint)(playerID - 1) > 7) { + if (playerID < 1 || playerID > 8) { return; } DAT_GameSynchronyState::instance.aiVariationArray[playerID] = -1; BOOLEnum variationUsed[9] = { FALSE }; - for (int other = 1; other < 9; ++other) { + for (int other = 1; other < countof(DAT_GameSynchronyState::instance.currentPlayerFullIDArray); ++other) { if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[other] == -1 && DAT_GameSynchronyState::instance.currentAIArray[other] == DAT_GameSynchronyState::instance.currentAIArray[playerID] @@ -20,7 +20,7 @@ void Synchrony::ResetAiVariationArrayValue(int playerID) variationUsed[DAT_GameSynchronyState::instance.aiVariationArray[other]] = TRUE; } } - for (int variation = 0; variation < 9; ++variation) { + for (int variation = 0; variation < countof(variationUsed); ++variation) { if (!variationUsed[variation]) { DAT_GameSynchronyState::instance.aiVariationArray[playerID] = variation; return; diff --git a/src/OpenSHC/Synchrony/SetAIPlayerNickNames.cpp b/src/OpenSHC/Synchrony/SetAIPlayerNickNames.cpp index 42c65922c7..4e385cc6bc 100644 --- a/src/OpenSHC/Synchrony/SetAIPlayerNickNames.cpp +++ b/src/OpenSHC/Synchrony/SetAIPlayerNickNames.cpp @@ -11,7 +11,7 @@ namespace OpenSHC { // FUNCTION: STRONGHOLDCRUSADER 0x0042A8E0 void Synchrony::SetAIPlayerNickNames() { - for (int player = 1; player < 9; ++player) { + for (int player = 1; player < countof(DAT_GameSynchronyState::instance.currentPlayerFullIDArray); ++player) { if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[player] != -1 || DAT_GameSynchronyState::instance.currentAIArray[player] == AI::AIT_NULL) { continue; diff --git a/src/OpenSHC/Synchrony/SyncPlayerGroupArrays.cpp b/src/OpenSHC/Synchrony/SyncPlayerGroupArrays.cpp index f82c034500..bd3d917be5 100644 --- a/src/OpenSHC/Synchrony/SyncPlayerGroupArrays.cpp +++ b/src/OpenSHC/Synchrony/SyncPlayerGroupArrays.cpp @@ -1,4 +1,4 @@ -#include "OpenSHC/Synchrony.func.hpp" +#include "../Synchrony.func.hpp" #include "OpenSHC/Globals/DAT_00df423c.hpp" #include "OpenSHC/Globals/DAT_00df4240.hpp" From b865e65c5fa40c208ab49f729d2aeeed397448af Mon Sep 17 00:00:00 2001 From: Jake Vawter Date: Sun, 15 Nov 2026 21:11:38 -0500 Subject: [PATCH 07/12] headers: Actions.func.hpp needs ResourceTypeMin1 too Co-Authored-By: Claude Opus 5.5 --- src/OpenSHC/Synchrony/Actions.func.hpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/OpenSHC/Synchrony/Actions.func.hpp b/src/OpenSHC/Synchrony/Actions.func.hpp index d0ab764624..759076af96 100644 --- a/src/OpenSHC/Synchrony/Actions.func.hpp +++ b/src/OpenSHC/Synchrony/Actions.func.hpp @@ -9,12 +9,14 @@ #pragma once #include "OpenSHC/Game/Resources/ResourceType.hpp" +#include "OpenSHC/Game/Resources/ResourceTypeMin1.hpp" #include "OpenSHC/Synchrony/Actions.hpp" namespace OpenSHC { namespace Synchrony { namespace Actions_Func { using OpenSHC::Game::Resources::ResourceType; + using OpenSHC::Game::Resources::ResourceTypeMin1; MACRO_FUNCTION_RESOLVER(void(__cdecl*)(int playerID), false, Address::SHC_3BB0A8C1_0x004285C0, &OpenSHC::Synchrony::Actions::RemovePositionOfPlayer) From fd25cc425f5507130fe5b7db3ac0f2f5466d4e54 Mon Sep 17 00:00:00 2001 From: Jake Vawter Date: Sun, 15 Nov 2026 21:17:43 -0500 Subject: [PATCH 08/12] DAT_LastTeamMemberIndex stays undefined4 (an int type renames its reccmp symbol and costs RecalculateAllies 5 points); keep its casts Co-Authored-By: Claude Opus 5.5 --- src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp | 4 ++-- src/OpenSHC/Globals/DAT_LastTeamMemberIndex.hpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp b/src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp index 4bd3eca1a3..23c395b45a 100644 --- a/src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp +++ b/src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp @@ -51,10 +51,10 @@ namespace Game { break; } } - if (DAT_LastTeamMemberIndex::instance >= DAT_AlliesCount::instance) { + if ((int)DAT_LastTeamMemberIndex::instance >= DAT_AlliesCount::instance) { DAT_LastTeamMemberIndex::instance = DAT_AlliesCount::instance - 1; } - if (DAT_LastTeamMemberIndex::instance < 0) { + if ((int)DAT_LastTeamMemberIndex::instance < 0) { DAT_LastTeamMemberIndex::instance = 0; } } diff --git a/src/OpenSHC/Globals/DAT_LastTeamMemberIndex.hpp b/src/OpenSHC/Globals/DAT_LastTeamMemberIndex.hpp index c3175b9157..0ba86b789e 100644 --- a/src/OpenSHC/Globals/DAT_LastTeamMemberIndex.hpp +++ b/src/OpenSHC/Globals/DAT_LastTeamMemberIndex.hpp @@ -13,7 +13,7 @@ namespace OpenSHC { -MACRO_STRUCT_RESOLVER(int, false, Address::SHC_3BB0A8C1_0x00DF42A8) DAT_LastTeamMemberIndex; +MACRO_STRUCT_RESOLVER(undefined4, false, Address::SHC_3BB0A8C1_0x00DF42A8) DAT_LastTeamMemberIndex; } // namespace OpenSHC MACRO_STRUCT_INSTANCE(Address::SHC_3BB0A8C1_0x00DF42A8); From a151d50c9a36e7c6e98abef0c88a489f48c4bbb1 Mon Sep 17 00:00:00 2001 From: Jake Vawter Date: Mon, 16 Nov 2026 07:01:42 -0500 Subject: [PATCH 09/12] SetAIPlayerNickNames: AITypeA case labels (currentAIArray is 1-based, RAT = 1) Co-Authored-By: Claude Opus 5.5 --- .../Synchrony/SetAIPlayerNickNames.cpp | 36 +++++++++---------- 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/src/OpenSHC/Synchrony/SetAIPlayerNickNames.cpp b/src/OpenSHC/Synchrony/SetAIPlayerNickNames.cpp index 4e385cc6bc..ec5e57f60a 100644 --- a/src/OpenSHC/Synchrony/SetAIPlayerNickNames.cpp +++ b/src/OpenSHC/Synchrony/SetAIPlayerNickNames.cpp @@ -1,7 +1,7 @@ #include "../Synchrony.func.hpp" #include "OpenSHC/Text/TextManager.func.hpp" -#include "OpenSHC/AI/AIType.hpp" +#include "OpenSHC/AI/AITypeA.hpp" #include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" #include "OpenSHC/Globals/DAT_TextManagerObject.hpp" @@ -13,101 +13,101 @@ void Synchrony::SetAIPlayerNickNames() { for (int player = 1; player < countof(DAT_GameSynchronyState::instance.currentPlayerFullIDArray); ++player) { if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[player] != -1 - || DAT_GameSynchronyState::instance.currentAIArray[player] == AI::AIT_NULL) { + || DAT_GameSynchronyState::instance.currentAIArray[player] == AI::AITA_NULL) { continue; } switch (DAT_GameSynchronyState::instance.currentAIArray[player]) { - case 1: + case AI::AITA_RAT: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 111)); break; - case 2: + case AI::AITA_SNAKE: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 119)); break; - case 3: + case AI::AITA_PIG: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 127)); break; - case 4: + case AI::AITA_WOLF: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 135)); break; - case 5: + case AI::AITA_SALADIN: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 143)); break; - case 6: + case AI::AITA_CALIPH: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 151)); break; - case 7: + case AI::AITA_SULTAN: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 159)); break; - case 8: + case AI::AITA_RICHARD: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 167)); break; - case 9: + case AI::AITA_FREDERICK: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 175)); break; - case 10: + case AI::AITA_PHILIPP: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 183)); break; - case 11: + case AI::AITA_WAZIR: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 191)); break; - case 12: + case AI::AITA_EMIR: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 199)); break; - case 13: + case AI::AITA_NIZAR: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 207)); break; - case 14: + case AI::AITA_SHERIFF: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 215)); break; - case 15: + case AI::AITA_MARSHAL: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, DAT_GameSynchronyState::instance.aiVariationArray[player] + 223)); break; - case 16: + case AI::AITA_ABBOT: strcpy(DAT_GameSynchronyState::instance.DAT_PlayerNames[player], MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( DE::SHCDE::TEXT_XPLAY_WAITING_ROOM, From 05c4ad4d5bf895d36aae44e21a3d0e5c616b239d Mon Sep 17 00:00:00 2001 From: Jake Vawter Date: Mon, 16 Nov 2026 07:02:20 -0500 Subject: [PATCH 10/12] PlayerData: name the goods request arrays (goodsRequestTypeByPlayer, goodsRequestAmountByPlayer) Both live in the asked player's data and are indexed by the requesting player: resource type (0 = no request) and amount. Field rename only. Co-Authored-By: Claude Opus 5.5 --- src/OpenSHC/AI/AICState/requestGoods.cpp | 6 +++--- src/OpenSHC/Game/Player/PlayerData.hpp | 4 ++-- .../Synchrony/Actions/ProcessAllyDeniesRequest.cpp | 4 ++-- src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp | 6 +++--- .../Synchrony/Actions/ProcessAllyRequestingGoods.cpp | 8 ++++---- .../Allies/MenuItemActionHandler_Allies_Main.cpp | 4 ++-- 6 files changed, 16 insertions(+), 16 deletions(-) diff --git a/src/OpenSHC/AI/AICState/requestGoods.cpp b/src/OpenSHC/AI/AICState/requestGoods.cpp index 2c10772ed7..34d64f7aad 100644 --- a/src/OpenSHC/AI/AICState/requestGoods.cpp +++ b/src/OpenSHC/AI/AICState/requestGoods.cpp @@ -56,12 +56,12 @@ namespace AI { == 0) { continue; } - if (DAT_GameState::instance.playerDataArray[i].requestedGoodsArray1Unk[playerID] != 0) { + if (DAT_GameState::instance.playerDataArray[i].goodsRequestTypeByPlayer[playerID] != 0) { continue; } - DAT_GameState::instance.playerDataArray[i].requestedGoodsArray1Unk[playerID] = resourceType; - DAT_GameState::instance.playerDataArray[i].requestedGoodsArray2Unk[playerID] = amount; + DAT_GameState::instance.playerDataArray[i].goodsRequestTypeByPlayer[playerID] = resourceType; + DAT_GameState::instance.playerDataArray[i].goodsRequestAmountByPlayer[playerID] = amount; MACRO_CALL_MEMBER(OpenSHC::AI::AICState_Func::playGoodsRequestBikFromPlayerToPlayer, this)(playerID, i); } } diff --git a/src/OpenSHC/Game/Player/PlayerData.hpp b/src/OpenSHC/Game/Player/PlayerData.hpp index aec0aa4083..243346ea38 100644 --- a/src/OpenSHC/Game/Player/PlayerData.hpp +++ b/src/OpenSHC/Game/Player/PlayerData.hpp @@ -346,8 +346,8 @@ namespace Game { AISiegeUnitCreation aiSiegeCreationInformation[4][5]; // 0x0000368C length: 400 int attackAssaultDelayRelatedValue; // 0x0000381C length: 4 BOOLEnum isNotNervousByEnemyTroopValue; // 0x00003820 length: 4 - short requestedGoodsArray1Unk[10]; // 0x00003824 length: 20 - short requestedGoodsArray2Unk[10]; // 0x00003838 length: 20 + short goodsRequestTypeByPlayer[10]; // 0x00003824 length: 20 + short goodsRequestAmountByPlayer[10]; // 0x00003838 length: 20 int requestStateUnk; // 0x0000384C length: 4 int requestedAttackTargetUnk; // 0x00003850 length: 4 int unitPatrolRecommandRelatedDelayValue; // 0x00003854 length: 4 diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp index 676d43992e..e1ce1f2cee 100644 --- a/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp @@ -13,8 +13,8 @@ namespace Synchrony { // FUNCTION: STRONGHOLDCRUSADER 0x004AE010 void Actions::ProcessAllyDeniesRequest(int fromPlayerID, int toPlayerID) { - DAT_GameState::instance.playerDataArray[toPlayerID].requestedGoodsArray1Unk[fromPlayerID] = 0; - DAT_GameState::instance.playerDataArray[toPlayerID].requestedGoodsArray2Unk[fromPlayerID] = 0; + DAT_GameState::instance.playerDataArray[toPlayerID].goodsRequestTypeByPlayer[fromPlayerID] = 0; + DAT_GameState::instance.playerDataArray[toPlayerID].goodsRequestAmountByPlayer[fromPlayerID] = 0; if (fromPlayerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp index 4e30a61efd..413d61ecfc 100644 --- a/src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp @@ -103,9 +103,9 @@ namespace Synchrony { } } if (requestedResource - == DAT_GameState::instance.playerDataArray[senderPlayerID].requestedGoodsArray1Unk[receiverPlayerID]) { - DAT_GameState::instance.playerDataArray[senderPlayerID].requestedGoodsArray1Unk[receiverPlayerID] = 0; - DAT_GameState::instance.playerDataArray[senderPlayerID].requestedGoodsArray2Unk[receiverPlayerID] = 0; + == DAT_GameState::instance.playerDataArray[senderPlayerID].goodsRequestTypeByPlayer[receiverPlayerID]) { + DAT_GameState::instance.playerDataArray[senderPlayerID].goodsRequestTypeByPlayer[receiverPlayerID] = 0; + DAT_GameState::instance.playerDataArray[senderPlayerID].goodsRequestAmountByPlayer[receiverPlayerID] = 0; } MACRO_CALL_MEMBER(AI::AICState_Func::playThanksBikFromPlayerToPlayer, DAT_AICState::ptr)( receiverPlayerID, senderPlayerID); diff --git a/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp b/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp index e4eec068fc..1e272f52f2 100644 --- a/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp @@ -26,9 +26,9 @@ namespace Synchrony { if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[askedPlayerID] == -1) { return; } - DAT_GameState::instance.playerDataArray[askedPlayerID].requestedGoodsArray1Unk[askee] + DAT_GameState::instance.playerDataArray[askedPlayerID].goodsRequestTypeByPlayer[askee] = (short)(requestedResource + 1); - DAT_GameState::instance.playerDataArray[askedPlayerID].requestedGoodsArray2Unk[askee] = (short)amount; + DAT_GameState::instance.playerDataArray[askedPlayerID].goodsRequestAmountByPlayer[askee] = (short)amount; if (askedPlayerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( @@ -39,9 +39,9 @@ namespace Synchrony { return; } if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[askedPlayerID] != -1) { - DAT_GameState::instance.playerDataArray[askedPlayerID].requestedGoodsArray1Unk[askee] + DAT_GameState::instance.playerDataArray[askedPlayerID].goodsRequestTypeByPlayer[askee] = (short)(requestedResource + 1); - DAT_GameState::instance.playerDataArray[askedPlayerID].requestedGoodsArray2Unk[askee] = (short)amount; + DAT_GameState::instance.playerDataArray[askedPlayerID].goodsRequestAmountByPlayer[askee] = (short)amount; if (askedPlayerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { strcpy(DAT_GameSynchronyState::instance.receivedChatMessage, MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( diff --git a/src/OpenSHC/UI/MenuItems/Allies/MenuItemActionHandler_Allies_Main.cpp b/src/OpenSHC/UI/MenuItems/Allies/MenuItemActionHandler_Allies_Main.cpp index bca6f405fe..4651e21e1f 100644 --- a/src/OpenSHC/UI/MenuItems/Allies/MenuItemActionHandler_Allies_Main.cpp +++ b/src/OpenSHC/UI/MenuItems/Allies/MenuItemActionHandler_Allies_Main.cpp @@ -47,7 +47,7 @@ namespace UI { int const allyPlayerID = DAT_SomeTeamMemberPlayerIDArray::instance[DAT_LastTeamMemberIndex::instance]; short const requestedResource = DAT_GameState::instance.playerDataArray[DAT_GameSynchronyState::instance.currentPlayerSlotID] - .requestedGoodsArray1Unk[allyPlayerID]; + .goodsRequestTypeByPlayer[allyPlayerID]; DAT_SentOrRequestedGoodsAmount::instance = 0; DAT_00df4284::instance = 0; if (requestedResource >= OpenSHC::Game::Resources::RT_WOOD) { @@ -55,7 +55,7 @@ namespace UI { DAT_RequestedGoodsByWhoArray::instance[0] = requestedResource - 1; DAT_SentOrRequestedGoodsAmount::instance = DAT_GameState::instance.playerDataArray[DAT_GameSynchronyState::instance.currentPlayerSlotID] - .requestedGoodsArray2Unk[allyPlayerID]; + .goodsRequestAmountByPlayer[allyPlayerID]; } MACRO_CALL_MEMBER(OpenSHC::UI::MenuModalComposition_Func::activateModalDialog, DAT_MenuModalComposition1::ptr)(OpenSHC::UI::Enums::MMT_ALLIES_SEND_GOODS, FALSE); From e126fe080b80cc6aaf62b3d0646874053a75d397 Mon Sep 17 00:00:00 2001 From: Jake Vawter Date: Mon, 16 Nov 2026 11:24:44 -0500 Subject: [PATCH 11/12] ScreenResolutionUnion: clang-format include order Co-Authored-By: Claude Opus 5.5 --- src/OpenSHC/Rendering/ScreenResolutionUnion.hpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/OpenSHC/Rendering/ScreenResolutionUnion.hpp b/src/OpenSHC/Rendering/ScreenResolutionUnion.hpp index 154da976ff..75213aa517 100644 --- a/src/OpenSHC/Rendering/ScreenResolutionUnion.hpp +++ b/src/OpenSHC/Rendering/ScreenResolutionUnion.hpp @@ -8,9 +8,8 @@ #pragma once -#include "OpenSHC/WindowsHelper/Enums/BOOLEnum.hpp" - #include "OpenSHC/Rendering/ScreenResolutionArrayStruct.hpp" +#include "OpenSHC/WindowsHelper/Enums/BOOLEnum.hpp" namespace OpenSHC { namespace Rendering { From 8d8af62030e4f7adefd8a266eba0ccc5b637408c Mon Sep 17 00:00:00 2001 From: Jake Vawter Date: Mon, 16 Nov 2026 11:26:12 -0500 Subject: [PATCH 12/12] DirectPlayModemRelated_MemoryAllocationCallback: note why the loop stays a while Co-Authored-By: Claude Opus 5.5 --- .../DirectPlayModemRelated_MemoryAllocationCallback.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp b/src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp index fdd57dc28d..7c9f326206 100644 --- a/src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp +++ b/src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp @@ -19,6 +19,7 @@ BOOLEnum __stdcall Synchrony::DirectPlayModemRelated_MemoryAllocationCallback( { char* entry = data; if (MACRO_CALL(OS_Func::isEqualGUID)(guidDataType, &GUID_DPAID_Modem::instance)) { + // A for loop with the step in its header compiles differently (95.6%). while (strlen(entry) != 0) { if (DAT_GameSynchronyState::instance.modemScrollbarCount >= 30) { return FALSE;