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/Game/ScenarioEvents/InGameEventUnionVersion/initializeScenarioEvent.cpp b/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/initializeScenarioEvent.cpp new file mode 100644 index 0000000000..3113eb0627 --- /dev/null +++ b/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/initializeScenarioEvent.cpp @@ -0,0 +1,29 @@ +#include "../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 < countof(this->data.scenario.conditions); ++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..4199ad81ad --- /dev/null +++ b/src/OpenSHC/Game/ScenarioEvents/InGameEventUnionVersion/resetEvent.cpp @@ -0,0 +1,25 @@ +#include "../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 < countof(this->data.invasion.unitCountsPerUnitType); ++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..23c395b45a --- /dev/null +++ b/src/OpenSHC/Game/Skirmish/RecalculateAllies.cpp @@ -0,0 +1,64 @@ +#include "../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 < countof(DAT_GameSynchronyState::instance.currentPlayerFullIDArray); + ++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 (DAT_AlliesCount::instance >= 6) { + break; + } + } + if ((int)DAT_LastTeamMemberIndex::instance >= 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..3e8a3c4311 --- /dev/null +++ b/src/OpenSHC/Game/Skirmish/SetupSkirmishBalanceAndOrIntensity.cpp @@ -0,0 +1,119 @@ +#include "../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 < 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 < 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 < countof(DAT_GameSynchronyState::instance.skirmishIntensityRelatedArray); ++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 < countof(DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1); ++i) { + DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1[i] = 0; + } + break; + case 1: + 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 < 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 < countof(DAT_GameSynchronyState::instance.skirmishBalanceRelatedArrayUnk1); ++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..46520738ce --- /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 < 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]; + 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 < countof(this->playerLordTypeArray); ++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..e8e34b3252 --- /dev/null +++ b/src/OpenSHC/Game/Skirmish/StoreCurrentGameIntoTemporarySKMasterEntry.cpp @@ -0,0 +1,49 @@ +#include "../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 < 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 < countof(DAT_SkMasterDataEntry::instance.array1); ++player) { + DAT_SkMasterDataEntry::instance.array1[player] + = DAT_GameState::instance.mapAndTime.playerGroupArray[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 < countof(DAT_SkMasterDataEntry::instance.aliveArray); ++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..eaaea625e4 --- /dev/null +++ b/src/OpenSHC/Game/Skirmish/StoreLocalTime.cpp @@ -0,0 +1,24 @@ +#include "../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/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..75213aa517 100644 --- a/src/OpenSHC/Rendering/ScreenResolutionUnion.hpp +++ b/src/OpenSHC/Rendering/ScreenResolutionUnion.hpp @@ -9,10 +9,13 @@ #pragma once #include "OpenSHC/Rendering/ScreenResolutionArrayStruct.hpp" +#include "OpenSHC/WindowsHelper/Enums/BOOLEnum.hpp" namespace OpenSHC { namespace Rendering { + using OpenSHC::WindowsHelper::Enums::BOOLEnum; + using OpenSHC::Rendering::ScreenResolutionArrayStruct; #pragma pack(push, 1) @@ -20,7 +23,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) 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 17ae21b6cd..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) @@ -66,7 +68,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; @@ -82,11 +84,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..897d036a21 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); @@ -41,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); @@ -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); diff --git a/src/OpenSHC/Synchrony/Actions/GateOpenOrClose.cpp b/src/OpenSHC/Synchrony/Actions/GateOpenOrClose.cpp new file mode 100644 index 0000000000..2634415869 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/GateOpenOrClose.cpp @@ -0,0 +1,29 @@ +#include "../Actions.func.hpp" + +#include "OpenSHC/Map/Buildings/BuildingsState.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..ab3f888ab5 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/OpenOrCloseDrawbridge.cpp @@ -0,0 +1,26 @@ +#include "../Actions.func.hpp" + +#include "OpenSHC/Map/Buildings/BuildingsState.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..92f905c011 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyAcceptsRequest.cpp @@ -0,0 +1,40 @@ +#include "../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..e1ce1f2cee --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest.cpp @@ -0,0 +1,28 @@ +#include "../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].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)( + 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..4b70db6eab --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyDeniesRequest2.cpp @@ -0,0 +1,40 @@ +#include "../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..413d61ecfc --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyGoodsRequest.cpp @@ -0,0 +1,115 @@ +#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 receiverPlayerID, ResourceType requestedResource, int amount, int senderPlayerID) + { + ResourceType resourceType = requestedResource; + if (resourceType == 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[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)( + receiverPlayerID, resourceType, amount); + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceLoss, DAT_BuildingsState::ptr)( + 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 (receiverPlayerID == DAT_GameSynchronyState::instance.currentPlayerSlotID) { + switch (requestedResource) { + 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 (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)( + senderPlayerID, 0); + MACRO_CALL(OS_Func::_sprintf)(DAT_GameSynchronyState::instance.receivedChatMessage, s__d__s___005a7674, + amount, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_GOODS, requestedResource)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + senderPlayerID, receiverPlayerID); + } + 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)( + senderPlayerID, 0); + MACRO_CALL(OS_Func::_sprintf)(DAT_GameSynchronyState::instance.receivedChatMessage, s__d__s_005a766c, + amount, + MACRO_CALL_MEMBER(Text::TextManager_Func::getTextStringInGroupAtOffset, DAT_TextManagerObject::ptr)( + DE::SHCDE::TEXT_GOODS, requestedResource)); + MACRO_CALL_MEMBER(GameSynchronyState_Func::addChatMessageToDisplayList, DAT_GameSynchronyState::ptr)( + senderPlayerID, 0); + } + } + if (requestedResource + == 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/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..1e272f52f2 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessAllyRequestingGoods.cpp @@ -0,0 +1,69 @@ +#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; + using OpenSHC::Game::Resources::ResourceTypeMin1; + + // FUNCTION: STRONGHOLDCRUSADER 0x004AD7C0 + void Actions::ProcessAllyRequestingGoods( + int askedPlayerID, ResourceTypeMin1 requestedResource, int amount, int askee) + { + if (requestedResource + 1 == Game::Resources::RT_GOLD) { + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[askedPlayerID] == -1) { + return; + } + DAT_GameState::instance.playerDataArray[askedPlayerID].goodsRequestTypeByPlayer[askee] + = (short)(requestedResource + 1); + 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)( + 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].goodsRequestTypeByPlayer[askee] + = (short)(requestedResource + 1); + 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)( + 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)(requestedResource + 1), amount); + MACRO_CALL_MEMBER(Map::Buildings::BuildingsState_Func::processResourceLoss, DAT_BuildingsState::ptr)( + 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 new file mode 100644 index 0000000000..9ed9465d90 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessBuildingSleepUpdate.cpp @@ -0,0 +1,38 @@ +#include "../Actions.func.hpp" + +#include "OpenSHC/Audio/SFX/SFXState.func.hpp" +#include "OpenSHC/Map/Buildings/BuildingsState.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 >= Map::Buildings::BT_CESSPIT) { + 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..02a1c5c7b4 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessBuyOrSell.cpp @@ -0,0 +1,41 @@ +#include "../Actions.func.hpp" + +#include "OpenSHC/Game/GameStateStructures.func.hpp" +#include "OpenSHC/Map/Buildings/BuildingsState.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..2331e07dd7 --- /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 displayColor, 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 < 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, 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 + = 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, 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 + = 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, 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; + 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, 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 + = 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..2b121f80ca --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/ProcessTowerRepair.cpp @@ -0,0 +1,48 @@ +#include "../Actions.func.hpp" + +#include "OpenSHC/Audio/MissingResourceState.func.hpp" +#include "OpenSHC/Map/Buildings/BuildingsState.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..5fef392902 --- /dev/null +++ b/src/OpenSHC/Synchrony/Actions/TryAcquireAmmunitionOrPlanToBuyStone.cpp @@ -0,0 +1,28 @@ +#include "../Actions.func.hpp" + +#include "OpenSHC/Map/Buildings/BuildingsState.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..7c9f326206 --- /dev/null +++ b/src/OpenSHC/Synchrony/DirectPlayModemRelated_MemoryAllocationCallback.cpp @@ -0,0 +1,39 @@ +#include "../Synchrony.func.hpp" + +// disable deprecation warnings for strcpy +#pragma warning(disable : 4996) + +#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( + GUID* guidDataType, DWORD dataSize, char* data, void* context) +{ + 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; + } + 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..d0fb9afbea --- /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 = TRUE; + } else if (width == 1024 && height == 768) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1024x768 = TRUE; + } else if (width == 1024 && height == 600) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1024x600 = TRUE; + } else if (width == 1280 && height == 1024) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1280x1024 = TRUE; + } else if (width == 1600 && height == 1200) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1600x1200 = TRUE; + } else if (width == 1280 && height == 720) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1280x720 = TRUE; + } else if (width == 1440 && height == 900) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1440x900 = TRUE; + } else if (width == 1920 && height == 1080) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1920x1080 = TRUE; + } else if (width == 1920 && height == 1200) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1920x1200 = TRUE; + } else if (width == 2560 && height == 1440) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._2560x1440 = TRUE; + } else if (width == 2560 && height == 1600) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._2560x1600 = TRUE; + } else if (width == 1366 && height == 768) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1366x768 = TRUE; + } else if (width == 1360 && height == 768) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1360x768 = TRUE; + } else if (width == 1680 && height == 1050) { + DAT_WindowAndDirectDraw::instance.resolutionSupported_0x68.fields._1680x1050 = TRUE; + } else if (width == 1600 && height == 900) { + 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 new file mode 100644 index 0000000000..4689768d2b --- /dev/null +++ b/src/OpenSHC/Synchrony/MemCopyFromParameter.cpp @@ -0,0 +1,29 @@ +#include "../Synchrony.func.hpp" + +#include "OpenSHC/OS.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..573196c602 --- /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 < 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 < countof(DAT_GameCore::instance.keepPositions); ++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 < countof(DAT_GameCore::instance.keepPositions); ++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..01ae1b3d66 --- /dev/null +++ b/src/OpenSHC/Synchrony/ResetAiVariationArrayValue.cpp @@ -0,0 +1,31 @@ +#include "../Synchrony.func.hpp" + +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" + +namespace OpenSHC { + +// FUNCTION: STRONGHOLDCRUSADER 0x00428050 +void Synchrony::ResetAiVariationArrayValue(int playerID) +{ + if (playerID < 1 || playerID > 8) { + return; + } + DAT_GameSynchronyState::instance.aiVariationArray[playerID] = -1; + BOOLEnum variationUsed[9] = { FALSE }; + 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] + && DAT_GameSynchronyState::instance.aiVariationArray[other] != -1) { + variationUsed[DAT_GameSynchronyState::instance.aiVariationArray[other]] = TRUE; + } + } + 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 new file mode 100644 index 0000000000..ec5e57f60a --- /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/AITypeA.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 < countof(DAT_GameSynchronyState::instance.currentPlayerFullIDArray); ++player) { + if (DAT_GameSynchronyState::instance.currentPlayerFullIDArray[player] != -1 + || DAT_GameSynchronyState::instance.currentAIArray[player] == AI::AITA_NULL) { + continue; + } + switch (DAT_GameSynchronyState::instance.currentAIArray[player]) { + 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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, + 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..bd3d917be5 --- /dev/null +++ b/src/OpenSHC/Synchrony/SyncPlayerGroupArrays.cpp @@ -0,0 +1,22 @@ +#include "../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/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); diff --git a/status/addresses-SHC-3BB0A8C1.txt b/status/addresses-SHC-3BB0A8C1.txt index 3a97b43162..6b1e8b886e 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