From 09c21cdfd29c3f9d959d3939aaeaef394eddfe45 Mon Sep 17 00:00:00 2001 From: Gynt Date: Tue, 10 Nov 2026 00:47:11 +0100 Subject: [PATCH 01/13] types(ViewportRenderState): counters, window and interval fields are int; lookup table layout - ViewportRenderState: availableFloaterIndex, windowX/Y, screenPixelWidth/Height, the four animation intervals, unitBatchedRenderCounterUntil6 and unitRender1-5 are int (the original compares them signed). - screenPointToTileNumber starts at 0x4E5E0 with 321610 entries, absorbing the eight field_0x4e5e0..fc slots before it; translationMatrix has 401 triplets, absorbing translationResult1/translationTracker1/translationResult2. Both arrays are written that way by setTileSystemMemoryLookupArrays. ViewportBasedTileNumber and convertMinimapClickToTileXY index the moved array with the shifted base (+8 entries), and still measure 100%. - TileMapState.cursorOverlayAnimationFrame, DAT_CurrentlyRenderedSpriteID and DAT_RenderedUnitOwner are int. From reimpl/ViewportRenderState, limited to the changes its 100% functions need. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XmXCmYbLQCBa8ek5RWjimR --- .../Globals/DAT_CurrentlyRenderedSpriteID.hpp | 4 +- src/OpenSHC/Globals/DAT_RenderedUnitOwner.hpp | 4 +- src/OpenSHC/Map/TileMapState.hpp | 2 +- .../Rendering/ViewportBasedTileNumber.cpp | 2 +- src/OpenSHC/Rendering/ViewportRenderState.hpp | 45 +++++++------------ .../convertMinimapClickToTileXY.cpp | 2 +- 6 files changed, 24 insertions(+), 35 deletions(-) diff --git a/src/OpenSHC/Globals/DAT_CurrentlyRenderedSpriteID.hpp b/src/OpenSHC/Globals/DAT_CurrentlyRenderedSpriteID.hpp index 27b23753d7..d41ca86682 100644 --- a/src/OpenSHC/Globals/DAT_CurrentlyRenderedSpriteID.hpp +++ b/src/OpenSHC/Globals/DAT_CurrentlyRenderedSpriteID.hpp @@ -9,11 +9,11 @@ #pragma once // GLOBAL: STRONGHOLDCRUSADER 0x00ED3180 -// StructResolver::Instance::instance +// StructResolver::Instance::instance namespace OpenSHC { -MACRO_STRUCT_RESOLVER(undefined4, false, Address::SHC_3BB0A8C1_0x00ED3180) DAT_CurrentlyRenderedSpriteID; +MACRO_STRUCT_RESOLVER(int, false, Address::SHC_3BB0A8C1_0x00ED3180) DAT_CurrentlyRenderedSpriteID; } // namespace OpenSHC MACRO_STRUCT_INSTANCE(Address::SHC_3BB0A8C1_0x00ED3180); diff --git a/src/OpenSHC/Globals/DAT_RenderedUnitOwner.hpp b/src/OpenSHC/Globals/DAT_RenderedUnitOwner.hpp index 3b2f13dbf5..16c914d5e2 100644 --- a/src/OpenSHC/Globals/DAT_RenderedUnitOwner.hpp +++ b/src/OpenSHC/Globals/DAT_RenderedUnitOwner.hpp @@ -9,11 +9,11 @@ #pragma once // GLOBAL: STRONGHOLDCRUSADER 0x00ED3158 -// StructResolver::Instance::instance +// StructResolver::Instance::instance namespace OpenSHC { -MACRO_STRUCT_RESOLVER(undefined4, false, Address::SHC_3BB0A8C1_0x00ED3158) DAT_RenderedUnitOwner; +MACRO_STRUCT_RESOLVER(int, false, Address::SHC_3BB0A8C1_0x00ED3158) DAT_RenderedUnitOwner; } // namespace OpenSHC MACRO_STRUCT_INSTANCE(Address::SHC_3BB0A8C1_0x00ED3158); diff --git a/src/OpenSHC/Map/TileMapState.hpp b/src/OpenSHC/Map/TileMapState.hpp index 03e1ef3539..5eb2c8e2ad 100644 --- a/src/OpenSHC/Map/TileMapState.hpp +++ b/src/OpenSHC/Map/TileMapState.hpp @@ -181,7 +181,7 @@ namespace Map { int DAT_TempBuildingRotation; // 0x005549B4 length: 4 int field_0x5549b8; // 0x005549B8 length: 4 undefined4 cursorAnimationTime; // 0x005549BC length: 4 - undefined4 cursorOverlayAnimationFrame; // 0x005549C0 length: 4 + int cursorOverlayAnimationFrame; // 0x005549C0 length: 4 undefined4 cursorOverlayImageBase; // 0x005549C4 length: 4 undefined4 cursorOverlayGmID; // 0x005549C8 length: 4 undefined4 flagAnimationDivisor; // 0x005549CC length: 4 diff --git a/src/OpenSHC/Rendering/ViewportBasedTileNumber.cpp b/src/OpenSHC/Rendering/ViewportBasedTileNumber.cpp index cbeb0a3c00..03d1a54d5c 100644 --- a/src/OpenSHC/Rendering/ViewportBasedTileNumber.cpp +++ b/src/OpenSHC/Rendering/ViewportBasedTileNumber.cpp @@ -25,7 +25,7 @@ int Rendering::ViewportBasedTileNumber() + (DAT_ViewportRenderState::instance.viewportState.viewportY / 16 + DAT_ViewportRenderState::instance.viewportState.mbr_0xb0 / 2) * 401 - + DAT_ViewportRenderState::instance.viewportState.mbr_0xac + orientationOffset - 8]; + + DAT_ViewportRenderState::instance.viewportState.mbr_0xac + orientationOffset]; } } diff --git a/src/OpenSHC/Rendering/ViewportRenderState.hpp b/src/OpenSHC/Rendering/ViewportRenderState.hpp index ad28998c80..6dee74d85b 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState.hpp +++ b/src/OpenSHC/Rendering/ViewportRenderState.hpp @@ -36,59 +36,48 @@ namespace Rendering { undefined4 DAT_MapEditorDisplayLayer; // 0x000000BC length: 4 uchar DAT_BinaryTileMap400x400[160000]; // 0x000000C0 length: 160000 short tileTranslationMatrix_YComponent[80400]; // 0x000271C0 length: 160800 - int field_0x4e5e0; // 0x0004E5E0 length: 4 - undefined4 field_0x4e5e4; // 0x0004E5E4 length: 4 - undefined4 field_0x4e5e8; // 0x0004E5E8 length: 4 - undefined4 field_0x4e5ec; // 0x0004E5EC length: 4 - undefined4 field_0x4e5f0; // 0x0004E5F0 length: 4 - undefined4 field_0x4e5f4; // 0x0004E5F4 length: 4 - undefined4 field_0x4e5f8; // 0x0004E5F8 length: 4 - undefined4 field_0x4e5fc; // 0x0004E5FC length: 4 - int screenPointToTileNumber[321602]; // 0x0004E600 length: 1286408 + int screenPointToTileNumber[321610]; // 0x0004E5E0 length: 1286440 undefined1 padding_0x188708[8]; // 0x00188708 length: 8 int DAT_TileTranslationMatrix_X_offset_min_24; // 0x00188710 length: 4 int field_0x188714; // 0x00188714 length: 4 int field_0x188718; // 0x00188718 length: 4 int DAT_TileTranslationMatrix_X_offset_min_12; // 0x0018871C length: 4 - TranslationMatrixTriplet translationMatrix[400]; // 0x00188720 length: 4800 - undefined4 translationResult1; // 0x001899E0 length: 4 - undefined4 translationTracker1; // 0x001899E4 length: 4 - undefined4 translationResult2; // 0x001899E8 length: 4 + TranslationMatrixTriplet translationMatrix[401]; // 0x00188720 length: 4812 Floater floatersArray[250]; // 0x001899EC length: 7000 - undefined4 availableFloaterIndex; // 0x0018B544 length: 4 + int availableFloaterIndex; // 0x0018B544 length: 4 int landscapeAnimationRandomTileArray[45]; // 0x0018B548 length: 180 byte landscapeAnimationValueArray[60]; // 0x0018B5FC length: 60 int landscapeSeaWhiteCapsAnimationFrames[45]; // 0x0018B638 length: 180 byte unused02[60]; // 0x0018B6EC length: 60 - undefined4 windowX; // 0x0018B728 length: 4 - undefined4 windowY; // 0x0018B72C length: 4 - undefined4 screenPixelWidth; // 0x0018B730 length: 4 - undefined4 screenPixelHeight; // 0x0018B734 length: 4 + int windowX; // 0x0018B728 length: 4 + int windowY; // 0x0018B72C length: 4 + int screenPixelWidth; // 0x0018B730 length: 4 + int screenPixelHeight; // 0x0018B734 length: 4 undefined4 field_0x18b738; // 0x0018B738 length: 4 - undefined4 interval_03_160; // 0x0018B73C length: 4 + int interval_03_160; // 0x0018B73C length: 4 undefined4 previousIntervalTime_03; // 0x0018B740 length: 4 - undefined4 interval_04_180; // 0x0018B744 length: 4 + int interval_04_180; // 0x0018B744 length: 4 undefined4 previousIntervalTime_04; // 0x0018B748 length: 4 - undefined4 interval_01_80; // 0x0018B74C length: 4 + int interval_01_80; // 0x0018B74C length: 4 undefined4 previousIntervalTime_01; // 0x0018B750 length: 4 - undefined4 interval_02_100; // 0x0018B754 length: 4 + int interval_02_100; // 0x0018B754 length: 4 undefined4 previousIntervalTime_02; // 0x0018B758 length: 4 int unknownCounterUntil_0x20; // 0x0018B75C length: 4 int unknownCounterUntil_0x24; // 0x0018B760 length: 4 int field_0x18b764; // 0x0018B764 length: 4 int unknownCounterUntil_0x10; // 0x0018B768 length: 4 int unknownCounterUntil_0x200; // 0x0018B76C length: 4 - undefined4 unitBatchedRenderCounterUntil6; // 0x0018B770 length: 4 + int unitBatchedRenderCounterUntil6; // 0x0018B770 length: 4 UnitRenderHelpStructure unitBatch1[500]; // 0x0018B774 length: 16000 UnitRenderHelpStructure unitBatch2[500]; // 0x0018F5F4 length: 16000 UnitRenderHelpStructure unitBatch3[500]; // 0x00193474 length: 16000 UnitRenderHelpStructure unitBatch4[500]; // 0x001972F4 length: 16000 UnitRenderHelpStructure unitBatch5[500]; // 0x0019B174 length: 16000 - undefined4 unitRender1; // 0x0019EFF4 length: 4 - undefined4 unitRender2; // 0x0019EFF8 length: 4 - undefined4 unitRender3; // 0x0019EFFC length: 4 - undefined4 unitRender4; // 0x0019F000 length: 4 - undefined4 unitRender5; // 0x0019F004 length: 4 + int unitRender1; // 0x0019EFF4 length: 4 + int unitRender2; // 0x0019EFF8 length: 4 + int unitRender3; // 0x0019EFFC length: 4 + int unitRender4; // 0x0019F000 length: 4 + int unitRender5; // 0x0019F004 length: 4 private: ViewportRenderState(ViewportRenderState const&); diff --git a/src/OpenSHC/UI/MinimapViewState/convertMinimapClickToTileXY.cpp b/src/OpenSHC/UI/MinimapViewState/convertMinimapClickToTileXY.cpp index 87caa224d4..9aaf81de66 100644 --- a/src/OpenSHC/UI/MinimapViewState/convertMinimapClickToTileXY.cpp +++ b/src/OpenSHC/UI/MinimapViewState/convertMinimapClickToTileXY.cpp @@ -34,7 +34,7 @@ namespace UI { orientationOffset = 241200; } int const tile = DAT_ViewportRenderState::instance - .screenPointToTileNumber[*tileX / 32 + screenY / 16 * 401 + orientationOffset - 6]; + .screenPointToTileNumber[*tileX / 32 + screenY / 16 * 401 + orientationOffset + 2]; int const row = DAT_ViewportRenderState::instance.tileTranslationMatrix_YComponent[tile]; *tileY = row; *tileX = tile - DAT_ViewportRenderState::instance.translationMatrix[row].addXgetTile; From effad8e9977070d63bf426a822a9a3479351b4c5 Mon Sep 17 00:00:00 2001 From: Gynt Date: Tue, 10 Nov 2026 00:47:22 +0100 Subject: [PATCH 02/13] Reimplement 15 Rendering::ViewportRenderState functions at 100% From reimpl/ViewportRenderState: every function that measures 100% there, and again 100% in a trial build of this branch (on main d5d965db8, data and function resolvers enabled, all 23 ViewportRenderState sources plus ViewportBasedTileNumber and convertMinimapClickToTileXY at 100%). - 15 new sources in src/OpenSHC/Rendering/ViewportRenderState/, with their status lines set to 100.0% Reimplemented - the 8 sources main already has at 100% are identical there and unchanged Left out: resetupViewport, which reaches 100% only under /GL together with setupViewport (here 43.8%, with setupViewport proxied to the original), and the 8 functions still below 100% on reimpl/ViewportRenderState (setupViewport, computeMouseTileFromScreenPosition, renderAssassinClimbingOverlay, renderGmOverlayBuilding, renderMap, renderUnits, setTileSystemMemoryLookupArrays, updateBuildingPreviewPosition), with the header changes only they use. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XmXCmYbLQCBa8ek5RWjimR --- .../Constructor_ViewportRenderState.cpp | 41 ++ .../ViewportRenderState/assignRandomTiles.cpp | 30 + .../clearAllFloatingLayerElements.cpp | 19 + .../createFloatingLayerElement.cpp | 49 ++ .../ViewportRenderState/focusOnTile.cpp | 46 ++ .../renderBuildingAnimation.cpp | 67 ++ .../renderDebugDataMousePointing.cpp | 73 ++ .../renderGmOverlayBuilding2.cpp | 647 ++++++++++++++++++ .../saveFocusTileAndCenterPreview.cpp | 15 + .../scheduleUnitForBatchedRendering.cpp | 98 +++ .../setViewportBasedOnMapSize.cpp | 95 +++ .../ViewportRenderState/setupMouseTileXY.cpp | 27 + .../ViewportRenderState/setupMouseTileXY2.cpp | 27 + .../tweakValidTilesToExcludeMapBorders.cpp | 31 + .../updateWaterAnimationFrames.cpp | 50 ++ status/addresses-SHC-3BB0A8C1.txt | 30 +- 16 files changed, 1330 insertions(+), 15 deletions(-) create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/clearAllFloatingLayerElements.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/createFloatingLayerElement.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/saveFocusTileAndCenterPreview.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/tweakValidTilesToExcludeMapBorders.cpp create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/updateWaterAnimationFrames.cpp diff --git a/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp b/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp new file mode 100644 index 0000000000..cea6e0430c --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp @@ -0,0 +1,41 @@ +#include "../ViewportRenderState.func.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E1FA0 + ViewportRenderState* ViewportRenderState::Constructor_ViewportRenderState() + { + this->viewportState.viewportX = 32; + this->viewportState.viewportY = 8; + this->viewportState.previousMouseTile = -1; + + DWORD now = timeGetTime(); + this->previousIntervalTime_02 = now; + this->previousIntervalTime_01 = now; + this->previousIntervalTime_04 = now; + this->previousIntervalTime_03 = now; + + this->viewportState.isZoomedOutUnk = 0; + this->DAT_MapEditorDisplayLayer = 0; + this->unknownCounterUntil_0x20 = 0; + this->unknownCounterUntil_0x200 = 0; + this->unknownCounterUntil_0x24 = 0; + this->field_0x18b764 = 0; + this->unknownCounterUntil_0x10 = 0; + this->viewportState.field_0x94 = 0; + + this->interval_03_160 = 160; + this->interval_04_180 = 180; + this->interval_01_80 = 80; + this->interval_02_100 = 100; + this->availableFloaterIndex = 1; + + for (int i = 0; i < 45; i++) { + this->landscapeAnimationRandomTileArray[i] = 0; + } + return this; + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp b/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp new file mode 100644 index 0000000000..a39069e310 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp @@ -0,0 +1,30 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/OS.func.hpp" + +#include "OpenSHC/Globals/DAT_TileMapState.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E5B80 + void ViewportRenderState::assignRandomTiles() + { + for (int i = 0; i < 45; i++) { + if (this->landscapeAnimationRandomTileArray[i] == 0) { + int randomTile + = (MACRO_CALL(OpenSHC::OS_Func::_rand)() << 15 | MACRO_CALL(OpenSHC::OS_Func::_rand)()) % 80400; + if ((DAT_TileMapState::instance.LogicLayer[randomTile] & 1) != 0 + && (DAT_TileMapState::instance.MiscDisplayLayer[randomTile] & 0x3c0) == 0 + && (DAT_TileMapState::instance.Logic2Layer[randomTile] & 8) == 0) { + this->landscapeAnimationRandomTileArray[i] = randomTile; + this->landscapeSeaWhiteCapsAnimationFrames[i] = 0; + } + } else if (8 <= this->landscapeSeaWhiteCapsAnimationFrames[i]) { + this->landscapeAnimationRandomTileArray[i] = 0; + } + } + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/clearAllFloatingLayerElements.cpp b/src/OpenSHC/Rendering/ViewportRenderState/clearAllFloatingLayerElements.cpp new file mode 100644 index 0000000000..ece09939f0 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/clearAllFloatingLayerElements.cpp @@ -0,0 +1,19 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/Globals/DAT_TileMapState.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E6340 + void ViewportRenderState::clearAllFloatingLayerElements() + { + for (int floaterIndex = 1; floaterIndex < this->availableFloaterIndex; floaterIndex++) { + DAT_TileMapState::instance.FloatingLayer[this->floatersArray[floaterIndex].tile] = 0; + this->floatersArray[floaterIndex].id = 0; + } + this->availableFloaterIndex = 1; + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/createFloatingLayerElement.cpp b/src/OpenSHC/Rendering/ViewportRenderState/createFloatingLayerElement.cpp new file mode 100644 index 0000000000..4ebdc9fadc --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/createFloatingLayerElement.cpp @@ -0,0 +1,49 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/Globals/DAT_TextureRenderCoreObject.hpp" +#include "OpenSHC/Globals/DAT_TileMapState.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E63A0 + void ViewportRenderState::createFloatingLayerElement( + GmID gmID, int imageID, int imageX, int imageY, int tile, int variation) + { + int newFloaterIndex = this->availableFloaterIndex; + if (tile < 0) { + return; + } + if (250 <= this->availableFloaterIndex) { + return; + } + + if (DAT_TileMapState::instance.FloatingLayer[tile] == 0) { + this->floatersArray[newFloaterIndex].id = 0; + } else { + uint floaterID = DAT_TileMapState::instance.FloatingLayer[tile]; + if (249 < floaterID) { + return; + } + for (; floaterID != 0; floaterID = this->floatersArray[floaterID].id) { + if (this->floatersArray[floaterID].imageID == imageID && this->floatersArray[floaterID].gmID == gmID) { + return; + } + } + this->floatersArray[newFloaterIndex].id = DAT_TileMapState::instance.FloatingLayer[tile]; + } + + DAT_TileMapState::instance.FloatingLayer[tile] = (ushort)newFloaterIndex; + this->floatersArray[newFloaterIndex].gmID = gmID; + this->floatersArray[newFloaterIndex].imageID = imageID; + this->floatersArray[newFloaterIndex].originX + = imageX - DAT_TextureRenderCoreObject::instance.gmFileHeaderColorpaletteArray[gmID].originX; + this->floatersArray[newFloaterIndex].originY + = imageY - DAT_TextureRenderCoreObject::instance.gmFileHeaderColorpaletteArray[gmID].originY; + this->floatersArray[newFloaterIndex].tile = tile; + this->floatersArray[newFloaterIndex].variation = variation; + this->availableFloaterIndex = this->availableFloaterIndex + 1; + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp b/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp new file mode 100644 index 0000000000..89a97ee687 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp @@ -0,0 +1,46 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/Globals/DAT_TileMapState.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E5E20 + void ViewportRenderState::focusOnTile(int tile) + { + int screenPointIndex = 8; + if (DAT_TileMapState::instance.mapOrientation != 0) { + if (DAT_TileMapState::instance.mapOrientation == 6) { + screenPointIndex = 80408; + } else if (DAT_TileMapState::instance.mapOrientation == 4) { + screenPointIndex = 160808; + } else if (DAT_TileMapState::instance.mapOrientation == 2) { + screenPointIndex = 241208; + } + } + + int rowLength = 201; + int tileX = 0; + int tileY; + bool found = false; + for (tileY = 0; tileY < 400; tileY++) { + rowLength = (rowLength != 201) + 200; + for (tileX = 0; tileX < rowLength; ++tileX) { + if (this->screenPointToTileNumber[screenPointIndex] == tile) { + found = true; + break; + } + screenPointIndex = screenPointIndex + 1; + } + if (found) { + break; + } + } + + this->viewportState.viewportX = (tileX - this->viewportState.mbr_0xac) * 32; + this->viewportState.viewportY = (tileY - this->viewportState.mbr_0xb0) * 8; + MACRO_CALL_MEMBER(OpenSHC::Rendering::ViewportRenderState_Func::setViewportBasedOnMapSize, this)(); + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp new file mode 100644 index 0000000000..621fb620fd --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp @@ -0,0 +1,67 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/UI/Rendering/TextureRenderCore.func.hpp" + +#include "OpenSHC/Globals/DAT_BuildingsState.hpp" +#include "OpenSHC/Globals/DAT_CurrentlyRenderedSpriteID.hpp" +#include "OpenSHC/Globals/DAT_RenderedUnitOwner.hpp" +#include "OpenSHC/Globals/DAT_TextureRenderCoreObject.hpp" +#include "OpenSHC/Globals/DAT_TileMapState.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E3870 + void ViewportRenderState::renderBuildingAnimation( + int buildingID, int screenX, int screenY, undefined4 param_4, int clipToBuilding) + { + if (DAT_BuildingsState::instance.buildings[buildingID].renderAnimation == 0) { + return; + } + if (DAT_BuildingsState::instance.buildings[buildingID].animationFrame == 0) { + return; + } + if (DAT_TileMapState::instance.disableElevationRendering != 0) { + return; + } + if (DAT_BuildingsState::instance.buildings[buildingID].drawBridgeState1 != 0) { + return; + } + + if (clipToBuilding != 0) { + MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::temporarySaveMapSurfaceHeightRangeUnk, + DAT_TextureRenderCoreObject::ptr) + (); + MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::setMapSurfaceHeightRange, + DAT_TextureRenderCoreObject::ptr) + ((screenY - 39 < 0) ? 0 : screenY - 39, 2076); + } + + DAT_RenderedUnitOwner::instance = DAT_BuildingsState::instance.buildings[buildingID].playerColorUnk; + DAT_CurrentlyRenderedSpriteID::instance = DAT_BuildingsState::instance.buildings[buildingID].spriteID2; + if (DAT_BuildingsState::instance.buildings[buildingID].renderBlendStrength != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGMWithBlending, DAT_TextureRenderCoreObject::ptr) + ((OpenSHC::IO::Graphics::GmID)DAT_CurrentlyRenderedSpriteID::instance, + DAT_BuildingsState::instance.buildings[buildingID].animationFrame, + DAT_BuildingsState::instance.buildings[buildingID].spriteOffetX + screenX, + DAT_BuildingsState::instance.buildings[buildingID].spriteOffetY + screenY, + DAT_BuildingsState::instance.buildings[buildingID].renderBlendStrength); + } else { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr) + ((OpenSHC::DE::SHCDE::eGM)DAT_CurrentlyRenderedSpriteID::instance, + DAT_BuildingsState::instance.buildings[buildingID].animationFrame, + DAT_BuildingsState::instance.buildings[buildingID].spriteOffetX + screenX, + DAT_BuildingsState::instance.buildings[buildingID].spriteOffetY + screenY); + } + if (clipToBuilding != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::restoreMapSurfaceHeightRangeFromTemporaryUnk, + DAT_TextureRenderCoreObject::ptr) + (); + } + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp new file mode 100644 index 0000000000..be4e2bbfcf --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp @@ -0,0 +1,73 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/OS.func.hpp" +#include "OpenSHC/Text/TextManager.func.hpp" +#include "OpenSHC/Text/TextAlignment.hpp" +#include "OpenSHC/WindowsHelper/Enums/BOOLEnum.hpp" + +#include "OpenSHC/Globals/DAT_TextManagerObject.hpp" +#include "OpenSHC/Globals/DAT_TileMapState.hpp" +#include "OpenSHC/Globals/DAT_ViewportRenderState.hpp" +#include "OpenSHC/Globals/MSVC_SecurityCookie.hpp" + +namespace OpenSHC { +namespace Rendering { + + using OpenSHC::Text::TextAlignment; + using OpenSHC::WindowsHelper::Enums::BOOLEnum; + + // FUNCTION: STRONGHOLDCRUSADER 0x004E64D0 + void ViewportRenderState::renderDebugDataMousePointing(int x, int y, int width, int height) + { + char text[200]; + uint securityCookie = MSVC_SecurityCookie::instance ^ (uint)text; + + int textX = x + 2; + + MACRO_CALL(OpenSHC::OS_Func::_sprintf) + (text, "Mouse Atom Ref: %d", this->viewportState.mouseAtomRefFloorTile); + MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) + (text, textX, y, OpenSHC::Text::TTA_LEFT, 16777215, 18, FALSE, 0); + + MACRO_CALL(OpenSHC::OS_Func::_sprintf) + (text, "Mouse: x%d, y%d, off%d", DAT_ViewportRenderState::instance.viewportState.mouseX, + DAT_ViewportRenderState::instance.viewportState.mouseY, + DAT_ViewportRenderState::instance.viewportState.mouseTile); + MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) + (text, textX, y + 16, OpenSHC::Text::TTA_LEFT, 16777215, 18, FALSE, 0); + + MACRO_CALL(OpenSHC::OS_Func::_sprintf) + (text, "Tile centre: x%d,y%d", DAT_ViewportRenderState::instance.viewportState.tileCenterX, + DAT_ViewportRenderState::instance.viewportState.tileCenterY); + MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) + (text, textX, y + 32, OpenSHC::Text::TTA_LEFT, 16777215, 18, FALSE, 0); + + MACRO_CALL(OpenSHC::OS_Func::_sprintf) + (text, "Chimp: %d Struct: %d Fly: %d", this->viewportState.mouseRayUnitID, + this->viewportState.mouseRayBuildingID, this->viewportState.mouseRayEntityID); + MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) + (text, textX, y + 64, OpenSHC::Text::TTA_LEFT, 16777215, 18, FALSE, 0); + + MACRO_CALL(OpenSHC::OS_Func::_sprintf) + (text, "Logic Layer: %x %x", DAT_TileMapState::instance.LogicLayer[this->viewportState.mouseAtomRefFloorTile], + DAT_TileMapState::instance.LogicLayer[this->viewportState.mouseTile]); + MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) + (text, textX, y + 80, OpenSHC::Text::TTA_LEFT, 16777215, 18, FALSE, 0); + + MACRO_CALL(OpenSHC::OS_Func::_sprintf) + (text, "Logic2 Layer: %x %x", + (char)DAT_TileMapState::instance.Logic2Layer[this->viewportState.mouseAtomRefFloorTile], + (char)DAT_TileMapState::instance.Logic2Layer[this->viewportState.mouseTile]); + MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) + (text, textX + 20, y + 80, OpenSHC::Text::TTA_LEFT, 16777215, 18, TRUE, 0); + + MACRO_CALL(OpenSHC::OS_Func::_sprintf) + (text, "Damage Layer: %d %d", + (char)DAT_TileMapState::instance.DamageLayer[this->viewportState.mouseAtomRefFloorTile], + (char)DAT_TileMapState::instance.DamageLayer[this->viewportState.mouseTile]); + MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) + (text, textX, y + 96, OpenSHC::Text::TTA_LEFT, 16777215, 18, FALSE, 0); + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp new file mode 100644 index 0000000000..ae19cb5beb --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp @@ -0,0 +1,647 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/UI/Rendering/TextureRenderCore.func.hpp" +#include "OpenSHC/DE/SHCDE/eGM.hpp" +#include "OpenSHC/Game/GameMode2.hpp" +#include "OpenSHC/IO/Graphics/GmID.hpp" +#include "OpenSHC/Map/Buildings/Building.hpp" +#include "OpenSHC/Map/Buildings/BuildingType.hpp" +#include "OpenSHC/Map/Buildings/BuildingTypeShort.hpp" +#include "OpenSHC/Map/MapType2.hpp" +#include "OpenSHC/UI/Enums/MenuViewType.hpp" + +#include "OpenSHC/Globals/DAT_BuildingDefinedData.hpp" +#include "OpenSHC/Globals/DAT_BuildingsState.hpp" +#include "OpenSHC/Globals/DAT_CurrentlyRenderedSpriteID.hpp" +#include "OpenSHC/Globals/DAT_GameCore.hpp" +#include "OpenSHC/Globals/DAT_GameSynchronyState.hpp" +#include "OpenSHC/Globals/DAT_MapPropertiesState.hpp" +#include "OpenSHC/Globals/DAT_RenderedUnitOwner.hpp" +#include "OpenSHC/Globals/DAT_TextureRenderCoreObject.hpp" +#include "OpenSHC/Globals/DAT_TileMapState.hpp" + +namespace OpenSHC { +namespace Rendering { + + using OpenSHC::DE::SHCDE::eGM; + using OpenSHC::Game::GameMode2; + using OpenSHC::IO::Graphics::GmID; + using OpenSHC::Map::MapType2; + using OpenSHC::Map::Buildings::Building; + using OpenSHC::Map::Buildings::BuildingType; + using OpenSHC::Map::Buildings::BuildingTypeShort; + using OpenSHC::UI::Enums::MenuViewType; + + // FUNCTION: STRONGHOLDCRUSADER 0x004E2AD0 + void ViewportRenderState::renderGmOverlayBuilding2(int buildingID, int screenX, int screenY, int tile) + { + BuildingTypeShort buildingType; + + int heightOffset = 0; + if (DAT_BuildingDefinedData::instance + .BuildingHeights[DAT_BuildingsState::instance.buildings[buildingID].buildingType] + == 0) { + heightOffset = DAT_BuildingsState::instance.buildings[buildingID].widthOrHeight << 5; + } + if ((int)DAT_BuildingsState::instance.buildings[buildingID].widthOrHeight <= 2) { + int healthBarYOffset = 0; + if ((((DAT_GameCore::instance.currentMenuViewType == OpenSHC::UI::Enums::MVT_BUILDING_AND_STATUS_MENU) + && (buildingID == DAT_BuildingsState::instance.menuSelectedBuildingID)) + || ((buildingID == DAT_BuildingsState::instance.selectedBuildingID + && (DAT_BuildingsState::instance.selectedBuildingUID + == DAT_BuildingsState::instance.buildings[buildingID].uid)))) + && DAT_BuildingsState::instance.buildings[buildingID].maxHealth != 0) { + int const maxHealth = DAT_BuildingsState::instance.buildings[buildingID].maxHealth; + int healthPercent; + if (maxHealth == 0) { + healthPercent = 100; + } else { + healthPercent + = (DAT_BuildingsState::instance.buildings[buildingID].currentHealth * 100) / maxHealth; + } + int const healthImage = healthPercent / 10; + switch (DAT_BuildingsState::instance.buildings[buildingID].buildingType) { + case OpenSHC::Map::Buildings::BT_GALLOWS: + case OpenSHC::Map::Buildings::BT_GIBBET: + healthBarYOffset = 80; + break; + case OpenSHC::Map::Buildings::BT_TOWER1: + healthBarYOffset = 30; + break; + } + if (healthImage >= 0 && healthImage <= 10) { + MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, + DAT_TextureRenderCoreObject::ptr)(OpenSHC::DE::SHCDE::GM_FLOATS, healthImage + 17, screenX + 4, + screenY + - DAT_BuildingDefinedData::instance + .BuildingHeights[DAT_BuildingsState::instance.buildings[buildingID].buildingType] + - healthBarYOffset - 12); + } + } + if ((DAT_GameCore::instance.gameMode_2 != OpenSHC::Game::GM_BUILDERUnk) + || (DAT_MapPropertiesState::instance.SEC_U3_MapType2_1 != OpenSHC::Map::MT_SIEGE)) { + if (DAT_BuildingsState::instance.buildings[buildingID].sleeping) { + int const animationTick = (DAT_TileMapState::instance.cursorOverlayAnimationFrame - 1) % 8; + MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGMWithAlphaMask, + DAT_TextureRenderCoreObject::ptr)(OpenSHC::IO::Graphics::GID_FLOAT_POP_CIRC, + animationTick + 203, screenX - 35, + screenY + - DAT_BuildingDefinedData::instance + .BuildingHeights[DAT_BuildingsState::instance.buildings[buildingID].buildingType] + - heightOffset - 42, + OpenSHC::IO::Graphics::GID_FLOAT_POP_CIRC, animationTick + 211, 0); + } else if (DAT_BuildingsState::instance.buildings[buildingID].currentlyNeededEmployeeCount != 0 + && DAT_GameCore::instance.field_0x108 != 0) { + MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGMWithAlphaMask, + DAT_TextureRenderCoreObject::ptr)(OpenSHC::IO::Graphics::GID_FLOATS_NEW, + DAT_TileMapState::instance.cursorOverlayAnimationFrame + 280, screenX - 35, + screenY + - DAT_BuildingDefinedData::instance + .BuildingHeights[DAT_BuildingsState::instance.buildings[buildingID].buildingType] + - heightOffset - 42, + OpenSHC::IO::Graphics::GID_FLOATS_NEW, + DAT_TileMapState::instance.cursorOverlayAnimationFrame + 296, 0); + } + } + short const bannerState = DAT_BuildingsState::instance.buildings[buildingID].field_0xc2; + if (bannerState == 1) { + int const maskImage = DAT_TileMapState::instance.cursorOverlayAnimationFrame + 16; + int const overlayImage = DAT_TileMapState::instance.cursorOverlayAnimationFrame; + MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGMWithAlphaMask, + DAT_TextureRenderCoreObject::ptr)(OpenSHC::IO::Graphics::GID_FLOATS_NEW, overlayImage, screenX - 35, + screenY + - DAT_BuildingDefinedData::instance + .BuildingHeights[DAT_BuildingsState::instance.buildings[buildingID].buildingType] + - heightOffset - 42, + OpenSHC::IO::Graphics::GID_FLOATS_NEW, maskImage, 0); + DAT_BuildingsState::instance.buildings[buildingID].field_0xc2 = 0; + } else if (bannerState == 2) { + int const maskImage = DAT_TileMapState::instance.cursorOverlayAnimationFrame + 132; + int const overlayImage = DAT_TileMapState::instance.cursorOverlayAnimationFrame + 116; + MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGMWithAlphaMask, + DAT_TextureRenderCoreObject::ptr)(OpenSHC::IO::Graphics::GID_FLOATS_NEW, overlayImage, screenX - 35, + screenY + - DAT_BuildingDefinedData::instance + .BuildingHeights[DAT_BuildingsState::instance.buildings[buildingID].buildingType] + - heightOffset - 42, + OpenSHC::IO::Graphics::GID_FLOATS_NEW, maskImage, 0); + DAT_BuildingsState::instance.buildings[buildingID].field_0xc2 = 0; + } + } + int frame; + if (DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics == 0) { + switch (DAT_BuildingsState::instance.buildings[buildingID].buildingType) { + case OpenSHC::Map::Buildings::BT_GATEHOUSELARGE: + if (5 + - (DAT_BuildingsState::instance.buildings[buildingID].currentHealth * 5) + / DAT_BuildingsState::instance.buildings[buildingID].maxHealth + != 0) { + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage5; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 79, screenY - 76); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage6; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 36, screenY - 102); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage7; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 43, screenY - 41); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage8; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 64, screenY - 118); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage9; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 36, screenY - 102); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].flagSlot.overlayImage; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 53, screenY - 59); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].overlayImageID; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 72, screenY - 87); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage10; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 79, screenY - 115); + } + } + break; + case OpenSHC::Map::Buildings::BT_GATEHOUSESMALL: + if (5 + - (DAT_BuildingsState::instance.buildings[buildingID].currentHealth * 5) + / DAT_BuildingsState::instance.buildings[buildingID].maxHealth + != 0) { + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage5; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 20, screenY - 88); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage6; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 47, screenY - 84); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage7; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 17, screenY - 32); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage8; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 23, screenY - 103); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage9; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 15, screenY - 39); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].flagSlot.overlayImage; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 56, screenY - 45); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].overlayImageID; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 25, screenY - 76); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage10; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 58, screenY - 124); + } + } + break; + case OpenSHC::Map::Buildings::BT_TOWER1: + if (5 + - (DAT_BuildingsState::instance.buildings[buildingID].currentHealth * 5) + / DAT_BuildingsState::instance.buildings[buildingID].maxHealth + != 0) { + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage5; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 15, screenY - 66); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage6; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 13, screenY - 178); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage7; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 9, screenY - 252); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage8; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX, screenY - 108); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage9; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 13, screenY - 189); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].flagSlot.overlayImage; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 15, screenY - 217); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].overlayImageID; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 8, screenY - 49); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage10; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 11, screenY - 90); + } + } + break; + case OpenSHC::Map::Buildings::BT_TOWER2: + if (5 + - (DAT_BuildingsState::instance.buildings[buildingID].currentHealth * 5) + / DAT_BuildingsState::instance.buildings[buildingID].maxHealth + != 0) { + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage5; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 9, screenY - 59); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage6; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 49, screenY - 45); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage7; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 43, screenY - 36); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage8; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 25, screenY - 69); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage9; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 38, screenY - 85); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].flagSlot.overlayImage; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 22, screenY - 36); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].overlayImageID; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 16, screenY - 22); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage10; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 50, screenY - 94); + } + } + break; + case OpenSHC::Map::Buildings::BT_TOWER3: + if (5 + - (DAT_BuildingsState::instance.buildings[buildingID].currentHealth * 5) + / DAT_BuildingsState::instance.buildings[buildingID].maxHealth + != 0) { + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage5; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 57, screenY - 96); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage6; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 19, screenY - 22); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage7; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 35, screenY - 131); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage8; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 25, screenY - 129); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage9; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 49, screenY - 47); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].flagSlot.overlayImage; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 46, screenY - 96); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].overlayImageID; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 16, screenY - 106); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage10; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 32, screenY - 91); + } + } + break; + case OpenSHC::Map::Buildings::BT_TOWER4: + if (5 + - (DAT_BuildingsState::instance.buildings[buildingID].currentHealth * 5) + / DAT_BuildingsState::instance.buildings[buildingID].maxHealth + != 0) { + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage5; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 65, screenY - 159); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage6; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 37, screenY - 97); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage7; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 75, screenY - 65); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage8; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 65, screenY - 69); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage9; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 38, screenY - 115); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].flagSlot.overlayImage; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 19, screenY - 59); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].overlayImageID; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 54, screenY - 139); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage10; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 66, screenY - 110); + } + } + break; + case OpenSHC::Map::Buildings::BT_TOWER5: + if (5 + - (DAT_BuildingsState::instance.buildings[buildingID].currentHealth * 5) + / DAT_BuildingsState::instance.buildings[buildingID].maxHealth + != 0) { + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage5; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 51, screenY - 127); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage6; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 4, screenY - 91); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage7; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 41, screenY - 122); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage8; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 33, screenY - 69); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage9; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 40, screenY - 89); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].flagSlot.overlayImage; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 22, screenY - 55); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].overlayImageID; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX - 22, screenY - 132); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraOverlayImage10; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CRACKS, frame, screenX + 58, screenY - 66); + } + } + } + } + if ((DAT_BuildingsState::instance.buildings[buildingID].displayOwnerFlag != 0) + && (DAT_BuildingsState::instance.buildings[buildingID].buildingType + == OpenSHC::Map::Buildings::BT_OXTETHER)) { + DAT_RenderedUnitOwner::instance = DAT_BuildingsState::instance.buildings[buildingID].playerColorUnk; + frame = DAT_BuildingsState::instance.buildings[buildingID].overlayImageID; + DAT_CurrentlyRenderedSpriteID::instance = 189; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_ANIM_FLAG_SMALL, frame, screenX - 30, screenY - 67); + } + } + if (DAT_BuildingsState::instance.buildings[buildingID].renderAnimation == 0) { + return; + } + if (DAT_BuildingsState::instance.buildings[buildingID].animationFrame == 0) { + return; + } + if (DAT_TileMapState::instance.disableElevationRendering != 0) { + return; + } + DAT_CurrentlyRenderedSpriteID::instance = (GmID)DAT_BuildingsState::instance.buildings[buildingID].spriteID2; + buildingType = DAT_BuildingsState::instance.buildings[buildingID].buildingType; + DAT_RenderedUnitOwner::instance = 0; + if (buildingType == OpenSHC::Map::Buildings::BT_KILLINGPIT + && DAT_BuildingsState::instance.buildings[buildingID].owner + != DAT_GameSynchronyState::instance.currentPlayerSlotID + && DAT_BuildingsState::instance.buildings[buildingID].state < 1) { + return; + } + // the field, not buildingType: testing the local lets MSVC jump the killing-pit paths past this check + if (DAT_BuildingsState::instance.buildings[buildingID].buildingType == OpenSHC::Map::Buildings::BT_DRAWBRIDGE) { + MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::temporarySaveMapSurfaceHeightRangeUnk, + DAT_TextureRenderCoreObject::ptr)(); + if (DAT_BuildingsState::instance.buildings[buildingID].drawBridgeState1 == 0) { + MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::setMapSurfaceHeightRange, + DAT_TextureRenderCoreObject::ptr)(screenY - 23 < 0 ? 0 : screenY - 23, 2076); + } + } + buildingType = DAT_BuildingsState::instance.buildings[buildingID].buildingType; + if (buildingType == OpenSHC::Map::Buildings::BT_TOWER2) { + if (DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics == 0) { + int frame = DAT_BuildingsState::instance.buildings[buildingID].extraAnimationSprite2; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CASTLE_ANIMS, frame, screenX - 36, screenY - 120); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraAnimationSprite4; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CASTLE_ANIMS, frame, screenX + 32, screenY - 113); + } + } + } else if (buildingType == OpenSHC::Map::Buildings::BT_TOWER3) { + if (DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics == 0) { + int frame = DAT_BuildingsState::instance.buildings[buildingID].extraAnimationSprite2; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CASTLE_ANIMS, frame, screenX - 36, screenY - 119); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraAnimationSprite4; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CASTLE_ANIMS, frame, screenX + 46, screenY - 119); + } + } + } else if (buildingType == OpenSHC::Map::Buildings::BT_TOWER4) { + if (DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics == 0) { + int frame = DAT_BuildingsState::instance.buildings[buildingID].extraAnimationSprite2; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CASTLE_ANIMS, frame, screenX - 52, screenY - 130); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraAnimationSprite4; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CASTLE_ANIMS, frame, screenX + 48, screenY - 125); + } + } + } else if (buildingType == OpenSHC::Map::Buildings::BT_TOWER5) { + if (DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics == 0) { + int frame = DAT_BuildingsState::instance.buildings[buildingID].extraAnimationSprite2; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CASTLE_ANIMS, frame, screenX - 51, screenY - 130); + } + frame = DAT_BuildingsState::instance.buildings[buildingID].extraAnimationSprite4; + if (frame != 0) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( + OpenSHC::DE::SHCDE::GM_CASTLE_ANIMS, frame, screenX + 49, screenY - 124); + } + } + } else { + DAT_RenderedUnitOwner::instance = DAT_BuildingsState::instance.buildings[buildingID].playerColorUnk; + short blendStrength = DAT_BuildingsState::instance.buildings[buildingID].renderBlendStrength; + DAT_CurrentlyRenderedSpriteID::instance + = (GmID)DAT_BuildingsState::instance.buildings[buildingID].spriteID2; + if (blendStrength != 0) { + MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGMWithBlending, + DAT_TextureRenderCoreObject::ptr)((GmID)DAT_CurrentlyRenderedSpriteID::instance, + DAT_BuildingsState::instance.buildings[buildingID].animationFrame, + DAT_BuildingsState::instance.buildings[buildingID].spriteOffetX + screenX, + DAT_BuildingsState::instance.buildings[buildingID].spriteOffetY + screenY, blendStrength); + } else { + MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, + DAT_TextureRenderCoreObject::ptr)((eGM)DAT_CurrentlyRenderedSpriteID::instance, + DAT_BuildingsState::instance.buildings[buildingID].animationFrame, + DAT_BuildingsState::instance.buildings[buildingID].spriteOffetX + screenX, + DAT_BuildingsState::instance.buildings[buildingID].spriteOffetY + screenY); + } + } + if (DAT_BuildingsState::instance.buildings[buildingID].buildingType == OpenSHC::Map::Buildings::BT_DRAWBRIDGE) { + MACRO_CALL_MEMBER( + OpenSHC::UI::Rendering::TextureRenderCore_Func::restoreMapSurfaceHeightRangeFromTemporaryUnk, + DAT_TextureRenderCoreObject::ptr)(); + } + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/saveFocusTileAndCenterPreview.cpp b/src/OpenSHC/Rendering/ViewportRenderState/saveFocusTileAndCenterPreview.cpp new file mode 100644 index 0000000000..83bb327b04 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/saveFocusTileAndCenterPreview.cpp @@ -0,0 +1,15 @@ +#include "../ViewportRenderState.func.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E8C50 + void ViewportRenderState::saveFocusTileAndCenterPreview() + { + MACRO_CALL_MEMBER(OpenSHC::Rendering::ViewportRenderState_Func::updateBuildingPreviewPosition, this) + (this->screenPixelWidth / 2 + this->windowX, this->screenPixelHeight / 2 + this->windowY); + this->field_0x18b738 = this->viewportState.mouseTile; + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp b/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp new file mode 100644 index 0000000000..767f0f3f25 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp @@ -0,0 +1,98 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/Globals/DAT_CurrentlyRenderedSpriteID.hpp" +#include "OpenSHC/Globals/DAT_RenderedUnitOwner.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E26D0 + void ViewportRenderState::scheduleUnitForBatchedRendering(undefined4 unitIDOrStatus, undefined4 drawX, + undefined4 drawY, undefined4 imageID, undefined4 blendStrength, undefined4 gmID, int param_7) + { + int batch; + if (param_7 == 1) { + batch = this->unitBatchedRenderCounterUntil6 + 4; + if (5 < batch) { + batch = batch - 5; + } + } else if (param_7 == 2) { + batch = this->unitBatchedRenderCounterUntil6 + 3; + if (5 < batch) { + batch = batch - 5; + } + } else { + batch = this->unitBatchedRenderCounterUntil6; + } + + switch (batch) { + case 1: + if (this->unitRender1 < 500) { + this->unitBatch1[this->unitRender1].unitIDOrStatus = unitIDOrStatus; + this->unitBatch1[this->unitRender1].ownerColor = DAT_RenderedUnitOwner::instance; + this->unitBatch1[this->unitRender1].spriteID = DAT_CurrentlyRenderedSpriteID::instance; + this->unitBatch1[this->unitRender1].drawX = drawX; + this->unitBatch1[this->unitRender1].drawY = drawY; + this->unitBatch1[this->unitRender1].imageID = imageID; + this->unitBatch1[this->unitRender1].blendStrength = blendStrength; + this->unitBatch1[this->unitRender1].gmID = gmID; + this->unitRender1 = this->unitRender1 + 1; + } + break; + case 2: + if (this->unitRender2 < 500) { + this->unitBatch2[this->unitRender2].unitIDOrStatus = unitIDOrStatus; + this->unitBatch2[this->unitRender2].ownerColor = DAT_RenderedUnitOwner::instance; + this->unitBatch2[this->unitRender2].spriteID = DAT_CurrentlyRenderedSpriteID::instance; + this->unitBatch2[this->unitRender2].drawX = drawX; + this->unitBatch2[this->unitRender2].drawY = drawY; + this->unitBatch2[this->unitRender2].imageID = imageID; + this->unitBatch2[this->unitRender2].blendStrength = blendStrength; + this->unitBatch2[this->unitRender2].gmID = gmID; + this->unitRender2 = this->unitRender2 + 1; + } + break; + case 3: + if (this->unitRender3 < 500) { + this->unitBatch3[this->unitRender3].unitIDOrStatus = unitIDOrStatus; + this->unitBatch3[this->unitRender3].ownerColor = DAT_RenderedUnitOwner::instance; + this->unitBatch3[this->unitRender3].spriteID = DAT_CurrentlyRenderedSpriteID::instance; + this->unitBatch3[this->unitRender3].drawX = drawX; + this->unitBatch3[this->unitRender3].drawY = drawY; + this->unitBatch3[this->unitRender3].imageID = imageID; + this->unitBatch3[this->unitRender3].blendStrength = blendStrength; + this->unitBatch3[this->unitRender3].gmID = gmID; + this->unitRender3 = this->unitRender3 + 1; + } + break; + case 4: + if (this->unitRender4 < 500) { + this->unitBatch4[this->unitRender4].unitIDOrStatus = unitIDOrStatus; + this->unitBatch4[this->unitRender4].ownerColor = DAT_RenderedUnitOwner::instance; + this->unitBatch4[this->unitRender4].spriteID = DAT_CurrentlyRenderedSpriteID::instance; + this->unitBatch4[this->unitRender4].drawX = drawX; + this->unitBatch4[this->unitRender4].drawY = drawY; + this->unitBatch4[this->unitRender4].imageID = imageID; + this->unitBatch4[this->unitRender4].blendStrength = blendStrength; + this->unitBatch4[this->unitRender4].gmID = gmID; + this->unitRender4 = this->unitRender4 + 1; + } + break; + case 5: + if (this->unitRender5 < 500) { + this->unitBatch5[this->unitRender5].unitIDOrStatus = unitIDOrStatus; + this->unitBatch5[this->unitRender5].ownerColor = DAT_RenderedUnitOwner::instance; + this->unitBatch5[this->unitRender5].spriteID = DAT_CurrentlyRenderedSpriteID::instance; + this->unitBatch5[this->unitRender5].drawX = drawX; + this->unitBatch5[this->unitRender5].drawY = drawY; + this->unitBatch5[this->unitRender5].imageID = imageID; + this->unitBatch5[this->unitRender5].blendStrength = blendStrength; + this->unitBatch5[this->unitRender5].gmID = gmID; + this->unitRender5 = this->unitRender5 + 1; + } + break; + } + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp new file mode 100644 index 0000000000..0475e22773 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp @@ -0,0 +1,95 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/Rendering/ScreenResolutionEnum.hpp" + +#include "OpenSHC/Globals/DAT_TileMapState.hpp" +#include "OpenSHC/Globals/DAT_ViewportRenderState.hpp" +#include "OpenSHC/Globals/DAT_WindowAndDirectDraw.hpp" + +namespace OpenSHC { +namespace Rendering { + + using OpenSHC::Rendering::ScreenResolutionEnum; + + // FUNCTION: STRONGHOLDCRUSADER 0x004E5C00 + void ViewportRenderState::setViewportBasedOnMapSize() + { + int mapBorder = 400 - DAT_TileMapState::instance.mapSize; + if (mapBorder == 400) { + mapBorder = 0; + } + mapBorder = mapBorder / 2; + + int maxViewportX = (((400 - mapBorder) / 2 - this->viewportState.viewportHeight) + 4) * 32; + int maxViewportY = ((401 - this->viewportState.viewportWidth) - mapBorder) * 8; + int minViewportX = (mapBorder / 2 + 1) * 32; + int minViewportY = mapBorder * 8 + 16; + if (this->viewportState.isZoomedOutUnk != 0) { + minViewportX = (mapBorder / 2 - 4) * 32; + } + + if (this->viewportState.viewportX < minViewportX) { + this->viewportState.viewportX = minViewportX; + } + if (this->viewportState.viewportX > maxViewportX) { + this->viewportState.viewportX = maxViewportX; + } + if (this->viewportState.viewportY < minViewportY) { + this->viewportState.viewportY = minViewportY; + } + if (this->viewportState.viewportY > maxViewportY) { + this->viewportState.viewportY = maxViewportY; + } + + if (DAT_TileMapState::instance.mapOrientation != 0) { + if (DAT_TileMapState::instance.mapOrientation == 6) { + if (this->viewportState.viewportX > maxViewportX - 32) { + this->viewportState.viewportX = maxViewportX - 32; + } + } else if (DAT_TileMapState::instance.mapOrientation == 4) { + if (this->viewportState.viewportY < minViewportY + 8) { + this->viewportState.viewportY = minViewportY + 8; + } + if (this->viewportState.viewportY > maxViewportY - 8) { + this->viewportState.viewportY = maxViewportY - 8; + } + } else if (DAT_TileMapState::instance.mapOrientation == 2) { + if (this->viewportState.viewportX < minViewportX + 16) { + this->viewportState.viewportX = minViewportX + 16; + } + if (this->viewportState.viewportY > maxViewportY - 8) { + this->viewportState.viewportY = maxViewportY - 8; + } + } + } + + if (DAT_TileMapState::instance.mapSize == 160 + && DAT_WindowAndDirectDraw::instance.currentGameResolution == OpenSHC::Rendering::SRE_1024x768 + && this->viewportState.isZoomedOutUnk != 0) { + minViewportY = minViewportY - 10; + maxViewportY = maxViewportY - 10; + } + + if (minViewportX > maxViewportX) { + this->viewportState.viewportX = (minViewportX - maxViewportX) / 2 + maxViewportX; + } + if (minViewportY > maxViewportY) { + this->viewportState.viewportY = (minViewportY - maxViewportY) / 2 + maxViewportY; + } + + if (this->viewportState.isZoomedOutUnk == 0) { + this->viewportState.currentCameraOffsetX + = (DAT_ViewportRenderState::instance.viewportState.viewportX & 0x1f) + 150; + this->viewportState.currentCameraOffsetY + = (DAT_ViewportRenderState::instance.viewportState.viewportY & 0xf) + 8; + } else { + this->viewportState.currentCameraOffsetX + = (DAT_ViewportRenderState::instance.viewportState.viewportX >> 1 & 0xf) + 150; + this->viewportState.currentCameraOffsetY + = (DAT_ViewportRenderState::instance.viewportState.viewportY >> 1 & 7) + 8; + } + this->viewportState.currentCameraOffsetY = this->viewportState.currentCameraOffsetY + 8; + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY.cpp new file mode 100644 index 0000000000..3877b8c45f --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY.cpp @@ -0,0 +1,27 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/Map/MapConstants.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E5DD0 + void ViewportRenderState::setupMouseTileXY() + { + this->viewportState.mouseTileX = 0; + for (this->viewportState.mouseTileY = 0; this->viewportState.mouseTileY < Map::MC_MAP_XY_LIMIT; + this->viewportState.mouseTileY++) { + if (this->viewportState.mouseAtomRefFloorTile + < this->translationMatrix[this->viewportState.mouseTileY + 1].firstTileOfRow) { + break; + } + } + + this->viewportState.mouseTileX = this->viewportState.mouseAtomRefFloorTile + - this->translationMatrix[this->viewportState.mouseTileY].firstTileOfRow; + this->viewportState.mouseTileX + = this->translationMatrix[this->viewportState.mouseTileY].distanceToCenter + this->viewportState.mouseTileX; + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp new file mode 100644 index 0000000000..49070bd27d --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp @@ -0,0 +1,27 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/Map/MapConstants.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E5D80 + void ViewportRenderState::setupMouseTileXY2() + { + this->viewportState.mouseTileX = 0; + for (this->viewportState.mouseTileY = 0; this->viewportState.mouseTileY < Map::MC_MAP_XY_LIMIT; + this->viewportState.mouseTileY++) { + if (this->viewportState.mouseTile + < this->translationMatrix[this->viewportState.mouseTileY + 1].firstTileOfRow) { + break; + } + } + + this->viewportState.mouseTileX + = this->viewportState.mouseTile - this->translationMatrix[this->viewportState.mouseTileY].firstTileOfRow; + this->viewportState.mouseTileX + = this->translationMatrix[this->viewportState.mouseTileY].distanceToCenter + this->viewportState.mouseTileX; + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/tweakValidTilesToExcludeMapBorders.cpp b/src/OpenSHC/Rendering/ViewportRenderState/tweakValidTilesToExcludeMapBorders.cpp new file mode 100644 index 0000000000..f22164afb6 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/tweakValidTilesToExcludeMapBorders.cpp @@ -0,0 +1,31 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/Map/LogicHelpers/Logic1.hpp" +#include "OpenSHC/Map/MapConstants.hpp" + +#include "OpenSHC/Globals/DAT_TileMapState.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E25A0 + void ViewportRenderState::tweakValidTilesToExcludeMapBorders() + { + for (int y = 0; y < Map::MC_MAP_XY_LIMIT; y++) { + for (int x = 0; x < Map::MC_MAP_XY_LIMIT; x++) { + if (this->DAT_BinaryTileMap400x400[y * Map::MC_MAP_XY_LIMIT + x] == 0) { + continue; + } + int tile = this->translationMatrix[y].addXgetTile + x; + this->tileTranslationMatrix_YComponent[tile] = (short)y; + if ((DAT_TileMapState::instance.LogicLayer[tile] + & (Map::LogicHelpers::L_BORDER | Map::LogicHelpers::L_BORDER_EDGE)) + != 0) { + this->DAT_BinaryTileMap400x400[y * Map::MC_MAP_XY_LIMIT + x] = 0; + } + } + } + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/updateWaterAnimationFrames.cpp b/src/OpenSHC/Rendering/ViewportRenderState/updateWaterAnimationFrames.cpp new file mode 100644 index 0000000000..2c815f6662 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/updateWaterAnimationFrames.cpp @@ -0,0 +1,50 @@ +#include "../ViewportRenderState.func.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E5A90 + void ViewportRenderState::updateWaterAnimationFrames() + { + DWORD now = timeGetTime(); + + this->field_0x18b764 = 0; + if ((int)(now - this->previousIntervalTime_04) >= this->interval_04_180) { + this->previousIntervalTime_04 = now; + this->field_0x18b764 = 1; + for (int i = 0; i < 45; i++) { + this->landscapeSeaWhiteCapsAnimationFrames[i] = this->landscapeSeaWhiteCapsAnimationFrames[i] + 1; + } + } + + if ((int)(now - this->previousIntervalTime_01) >= this->interval_01_80) { + this->previousIntervalTime_01 = now; + this->unknownCounterUntil_0x10 = this->unknownCounterUntil_0x10 + 1; + if (this->unknownCounterUntil_0x10 >= 16) { + this->unknownCounterUntil_0x10 = 0; + } + } + + if ((int)(now - this->previousIntervalTime_02) >= this->interval_02_100) { + this->previousIntervalTime_02 = now; + this->unknownCounterUntil_0x20 = this->unknownCounterUntil_0x20 + 1; + if (this->unknownCounterUntil_0x20 >= 32) { + this->unknownCounterUntil_0x20 = 0; + } + } + + if ((int)(now - this->previousIntervalTime_03) >= this->interval_03_160) { + this->previousIntervalTime_03 = now; + this->unknownCounterUntil_0x24 = this->unknownCounterUntil_0x24 + 1; + if (this->unknownCounterUntil_0x24 >= 36) { + this->unknownCounterUntil_0x24 = 0; + } + this->unknownCounterUntil_0x200 = this->unknownCounterUntil_0x200 + 1; + if (this->unknownCounterUntil_0x200 >= 512) { + this->unknownCounterUntil_0x200 = 0; + } + } + } + +} +} diff --git a/status/addresses-SHC-3BB0A8C1.txt b/status/addresses-SHC-3BB0A8C1.txt index ed989c9a21..dd488cd320 100644 --- a/status/addresses-SHC-3BB0A8C1.txt +++ b/status/addresses-SHC-3BB0A8C1.txt @@ -36389,7 +36389,7 @@ SHC_3BB0A8C1_0x004E1E70 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E1F50 | 0.0% | Pending -SHC_3BB0A8C1_0x004E1FA0 | 0.0% | Pending +SHC_3BB0A8C1_0x004E1FA0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E2050 | 0.0% | Pending @@ -36397,13 +36397,13 @@ SHC_3BB0A8C1_0x004E21E0 | 0.0% | Pending SHC_3BB0A8C1_0x004E2460 | 0.0% | Pending -SHC_3BB0A8C1_0x004E25A0 | 0.0% | Pending +SHC_3BB0A8C1_0x004E25A0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E2600 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E2630 | 0.0% | Pending -SHC_3BB0A8C1_0x004E26D0 | 0.0% | Pending +SHC_3BB0A8C1_0x004E26D0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E2AB4 | 0.0% | Pending @@ -36415,7 +36415,7 @@ SHC_3BB0A8C1_0x004E2AC0 | 0.0% | Pending SHC_3BB0A8C1_0x004E2AC4 | 0.0% | Pending -SHC_3BB0A8C1_0x004E2AD0 | 0.0% | Pending +SHC_3BB0A8C1_0x004E2AD0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E3828 | 0.0% | Pending @@ -36501,7 +36501,7 @@ SHC_3BB0A8C1_0x004E3868 | 0.0% | Pending SHC_3BB0A8C1_0x004E3869 | 0.0% | Pending -SHC_3BB0A8C1_0x004E3870 | 0.0% | Pending +SHC_3BB0A8C1_0x004E3870 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E3980 | 0.0% | Pending @@ -36875,17 +36875,17 @@ SHC_3BB0A8C1_0x004E5A88 | 0.0% | Pending SHC_3BB0A8C1_0x004E5A89 | 0.0% | Pending -SHC_3BB0A8C1_0x004E5A90 | 0.0% | Pending +SHC_3BB0A8C1_0x004E5A90 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004E5B80 | 0.0% | Pending +SHC_3BB0A8C1_0x004E5B80 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004E5C00 | 0.0% | Pending +SHC_3BB0A8C1_0x004E5C00 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004E5D80 | 0.0% | Pending +SHC_3BB0A8C1_0x004E5D80 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004E5DD0 | 0.0% | Pending +SHC_3BB0A8C1_0x004E5DD0 | 100.0% | Reimplemented -SHC_3BB0A8C1_0x004E5E20 | 0.0% | Pending +SHC_3BB0A8C1_0x004E5E20 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E5ED0 | 0.0% | Pending @@ -36971,15 +36971,15 @@ SHC_3BB0A8C1_0x004E6335 | 0.0% | Pending SHC_3BB0A8C1_0x004E6336 | 0.0% | Pending -SHC_3BB0A8C1_0x004E6340 | 0.0% | Pending +SHC_3BB0A8C1_0x004E6340 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E6360 | 0.0% | Pending -SHC_3BB0A8C1_0x004E63A0 | 0.0% | Pending +SHC_3BB0A8C1_0x004E63A0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E6410 | 0.0% | Pending -SHC_3BB0A8C1_0x004E64D0 | 0.0% | Pending +SHC_3BB0A8C1_0x004E64D0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E66F0 | 0.0% | Pending @@ -37333,7 +37333,7 @@ SHC_3BB0A8C1_0x004E8C4B | 0.0% | Pending SHC_3BB0A8C1_0x004E8C4C | 0.0% | Pending -SHC_3BB0A8C1_0x004E8C50 | 0.0% | Pending +SHC_3BB0A8C1_0x004E8C50 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E8C90 | 100.0% | Reimplemented From c661a3c410c51f9b738d9562de416e626cd6207e Mon Sep 17 00:00:00 2001 From: Gynt Date: Tue, 10 Nov 2026 07:44:54 +0100 Subject: [PATCH 03/13] Reimplement Rendering::ViewportRenderState::resetupViewport 100% in the reimpl/ViewportRenderState build, where it is compiled with /GL together with setupViewport; not re-measured on this branch. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XmXCmYbLQCBa8ek5RWjimR --- .../ViewportRenderState/resetupViewport.cpp | 38 +++++++++++++++++++ status/addresses-SHC-3BB0A8C1.txt | 2 +- 2 files changed, 39 insertions(+), 1 deletion(-) create mode 100644 src/OpenSHC/Rendering/ViewportRenderState/resetupViewport.cpp diff --git a/src/OpenSHC/Rendering/ViewportRenderState/resetupViewport.cpp b/src/OpenSHC/Rendering/ViewportRenderState/resetupViewport.cpp new file mode 100644 index 0000000000..b5050fc64b --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/resetupViewport.cpp @@ -0,0 +1,38 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/UI/Enums/BuildingsAndStatusMenuTabType.hpp" +#include "OpenSHC/UI/Enums/MenuViewType.hpp" + +#include "OpenSHC/Globals/DAT_GameCore.hpp" +#include "OpenSHC/Globals/DAT_WindowAndDirectDraw.hpp" + +namespace OpenSHC { +namespace Rendering { + + using OpenSHC::UI::Enums::BuildingsAndStatusMenuTabType; + using OpenSHC::UI::Enums::MenuViewType; + + // FUNCTION: STRONGHOLDCRUSADER 0x004E7770 + void ViewportRenderState::resetupViewport(int zoomUnk) + { + int savedViewportY = this->viewportState.viewportY + this->viewportState.mbr_0xb0 * 8; + int savedViewportX = this->viewportState.mbr_0xac * 32 + this->viewportState.viewportX; + this->viewportState.isZoomedOutUnk = zoomUnk; + + if ((DAT_GameCore::instance.currentMenuViewType == OpenSHC::UI::Enums::MVT_BUILD_MENU + || DAT_GameCore::instance.currentMenuViewType == OpenSHC::UI::Enums::MVT_MAP_EDITOR_LANDSCAPING) + && (DAT_GameCore::instance.activeMenuTab.tabType == OpenSHC::UI::Enums::BASMTT_SIEGETENT_SIEGETOWER + || DAT_GameCore::instance.activeMenuTab.tabType == OpenSHC::UI::Enums::BASMTT_SIEGETENT_SHIELD)) { + MACRO_CALL_MEMBER(OpenSHC::Rendering::ViewportRenderState_Func::setupViewport, this) + (0, 0, DAT_WindowAndDirectDraw::instance.resolutionX, DAT_WindowAndDirectDraw::instance.resolutionY); + } else { + MACRO_CALL_MEMBER(OpenSHC::Rendering::ViewportRenderState_Func::setupViewport, this) + (0, 0, DAT_WindowAndDirectDraw::instance.resolutionX, DAT_WindowAndDirectDraw::instance.resolutionY - 128); + } + this->viewportState.viewportX = savedViewportX - this->viewportState.mbr_0xac * 32; + this->viewportState.viewportY = savedViewportY - this->viewportState.mbr_0xb0 * 8; + MACRO_CALL_MEMBER(OpenSHC::Rendering::ViewportRenderState_Func::setViewportBasedOnMapSize, this)(); + } + +} +} diff --git a/status/addresses-SHC-3BB0A8C1.txt b/status/addresses-SHC-3BB0A8C1.txt index dd488cd320..9822b2f470 100644 --- a/status/addresses-SHC-3BB0A8C1.txt +++ b/status/addresses-SHC-3BB0A8C1.txt @@ -36983,7 +36983,7 @@ SHC_3BB0A8C1_0x004E64D0 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E66F0 | 0.0% | Pending -SHC_3BB0A8C1_0x004E7770 | 0.0% | Pending +SHC_3BB0A8C1_0x004E7770 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E7800 | 100.0% | Reimplemented From c6bccdd2793df35dc0d914c951756d6a961faa11 Mon Sep 17 00:00:00 2001 From: Gynt Date: Wed, 11 Nov 2026 00:59:06 +0100 Subject: [PATCH 04/13] Rendering::Enums::ViewportConstants: tile pixel sizes, screen point table layout Constants the ViewportRenderState functions use: the 32 x 8 pixel tile column and row steps, the screen point tables' start, size and row lengths, the map surface height and the unit render batch and white cap frame counts. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XmXCmYbLQCBa8ek5RWjimR --- .../Rendering/Enums/ViewportConstants.hpp | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 src/OpenSHC/Rendering/Enums/ViewportConstants.hpp diff --git a/src/OpenSHC/Rendering/Enums/ViewportConstants.hpp b/src/OpenSHC/Rendering/Enums/ViewportConstants.hpp new file mode 100644 index 0000000000..fa5754d1f8 --- /dev/null +++ b/src/OpenSHC/Rendering/Enums/ViewportConstants.hpp @@ -0,0 +1,31 @@ +#pragma once + +namespace OpenSHC { +namespace Rendering { + namespace Enums { + typedef enum ViewportConstants { + + // the unit render batches unitBatch1 to unitBatch5 + VC_UNIT_BATCH_COUNT = 5, // 0x00000005 + // viewportY steps 8 pixels per tile row: rows are staggered, so a 16 pixel tile spans two rows + VC_TILE_ROW_PIXEL_HEIGHT = 8, // 0x00000008 + // the orientation 0 table starts 8 entries into screenPointToTileNumber + VC_SCREEN_POINT_TABLE_START = 8, // 0x00000008 + // a sea white cap animation runs this many frames before its tile is released + VC_SEA_WHITE_CAP_FRAME_COUNT = 8, // 0x00000008 + // viewportX steps 32 pixels per tile column + VC_TILE_PIXEL_WIDTH = 32, // 0x00000020 + // the screen point rows alternate between 201 and 200 tiles + VC_SCREEN_POINT_SHORT_ROW = 200, // 0x000000C8 + VC_SCREEN_POINT_LONG_ROW = 201, // 0x000000C9 + // height of the map surface (initializeDirectDraw), the end of a setMapSurfaceHeightRange range + VC_MAP_SURFACE_HEIGHT = 2076, // 0x0000081C + // entries per orientation in screenPointToTileNumber, one per map tile + VC_SCREEN_POINT_TABLE_SIZE = 80400 // 0x00013A10 + + } ViewportConstants; + + static_assert_cpp98_obj(sizeof(ViewportConstants) == 4, ViewportConstants); + } // namespace Enums +} // namespace Rendering +} // namespace OpenSHC From 70935831b3acfb7309cdd3182354e7a7dfde5abe Mon Sep 17 00:00:00 2001 From: Gynt Date: Wed, 11 Nov 2026 00:59:06 +0100 Subject: [PATCH 05/13] style(ViewportRenderState): enum names, countof bounds and compound assignment LogicLayer and Logic2Layer tests use the Logic1 and Logic2 flags, map sizes use MapConstants, the debug overlay text is Colors::COL_FFFFFF, and the remaining pixel and table constants come from the new ViewportConstants. Array bounds are countof(); the floater id check keeps `countof - 1 <` because `>= countof` compiles to cmp 250 / jae where the original has cmp 249 / ja. Self-assignments are ++, += and -=. All 24 ViewportRenderState functions on this branch measure as before (23 at 100%, resetupViewport unchanged at 43.8% without /GL). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XmXCmYbLQCBa8ek5RWjimR --- .../Constructor_ViewportRenderState.cpp | 8 ++-- .../ViewportRenderState/assignRandomTiles.cpp | 16 ++++--- .../createFloatingLayerElement.cpp | 6 +-- .../ViewportRenderState/focusOnTile.cpp | 23 +++++----- .../renderBuildingAnimation.cpp | 3 +- .../renderDebugDataMousePointing.cpp | 15 ++++--- .../renderGmOverlayBuilding2.cpp | 6 ++- .../ViewportRenderState/resetupViewport.cpp | 10 +++-- .../scheduleUnitForBatchedRendering.cpp | 30 +++++++------ .../setViewportBasedOnMapSize.cpp | 43 ++++++++++--------- .../ViewportRenderState/setupMouseTileXY.cpp | 3 +- .../ViewportRenderState/setupMouseTileXY2.cpp | 3 +- .../updateWaterAnimationFrames.cpp | 12 +++--- 13 files changed, 98 insertions(+), 80 deletions(-) diff --git a/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp b/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp index cea6e0430c..d7b228472e 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp @@ -1,13 +1,15 @@ #include "../ViewportRenderState.func.hpp" +#include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" + namespace OpenSHC { namespace Rendering { // FUNCTION: STRONGHOLDCRUSADER 0x004E1FA0 ViewportRenderState* ViewportRenderState::Constructor_ViewportRenderState() { - this->viewportState.viewportX = 32; - this->viewportState.viewportY = 8; + this->viewportState.viewportX = Enums::VC_TILE_PIXEL_WIDTH; + this->viewportState.viewportY = Enums::VC_TILE_ROW_PIXEL_HEIGHT; this->viewportState.previousMouseTile = -1; DWORD now = timeGetTime(); @@ -31,7 +33,7 @@ namespace Rendering { this->interval_02_100 = 100; this->availableFloaterIndex = 1; - for (int i = 0; i < 45; i++) { + for (int i = 0; i < countof(this->landscapeAnimationRandomTileArray); ++i) { this->landscapeAnimationRandomTileArray[i] = 0; } return this; diff --git a/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp b/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp index a39069e310..3aef88026f 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp @@ -1,6 +1,10 @@ #include "../ViewportRenderState.func.hpp" #include "OpenSHC/OS.func.hpp" +#include "OpenSHC/Map/LogicHelpers/Logic1.hpp" +#include "OpenSHC/Map/LogicHelpers/Logic2.hpp" +#include "OpenSHC/Map/MapConstants.hpp" +#include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" #include "OpenSHC/Globals/DAT_TileMapState.hpp" @@ -10,17 +14,17 @@ namespace Rendering { // FUNCTION: STRONGHOLDCRUSADER 0x004E5B80 void ViewportRenderState::assignRandomTiles() { - for (int i = 0; i < 45; i++) { + for (int i = 0; i < countof(this->landscapeAnimationRandomTileArray); ++i) { if (this->landscapeAnimationRandomTileArray[i] == 0) { - int randomTile - = (MACRO_CALL(OpenSHC::OS_Func::_rand)() << 15 | MACRO_CALL(OpenSHC::OS_Func::_rand)()) % 80400; - if ((DAT_TileMapState::instance.LogicLayer[randomTile] & 1) != 0 + int randomTile = (MACRO_CALL(OpenSHC::OS_Func::_rand)() << 15 | MACRO_CALL(OpenSHC::OS_Func::_rand)()) + % Map::MC_MAP_TILES_COUNT; + if ((DAT_TileMapState::instance.LogicLayer[randomTile] & Map::LogicHelpers::L_SEA) != 0 && (DAT_TileMapState::instance.MiscDisplayLayer[randomTile] & 0x3c0) == 0 - && (DAT_TileMapState::instance.Logic2Layer[randomTile] & 8) == 0) { + && (DAT_TileMapState::instance.Logic2Layer[randomTile] & Map::LogicHelpers::L2_PLATEAU_HIGH) == 0) { this->landscapeAnimationRandomTileArray[i] = randomTile; this->landscapeSeaWhiteCapsAnimationFrames[i] = 0; } - } else if (8 <= this->landscapeSeaWhiteCapsAnimationFrames[i]) { + } else if (Enums::VC_SEA_WHITE_CAP_FRAME_COUNT <= this->landscapeSeaWhiteCapsAnimationFrames[i]) { this->landscapeAnimationRandomTileArray[i] = 0; } } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/createFloatingLayerElement.cpp b/src/OpenSHC/Rendering/ViewportRenderState/createFloatingLayerElement.cpp index 4ebdc9fadc..ecad642fc4 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/createFloatingLayerElement.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/createFloatingLayerElement.cpp @@ -14,7 +14,7 @@ namespace Rendering { if (tile < 0) { return; } - if (250 <= this->availableFloaterIndex) { + if (countof(this->floatersArray) <= this->availableFloaterIndex) { return; } @@ -22,7 +22,7 @@ namespace Rendering { this->floatersArray[newFloaterIndex].id = 0; } else { uint floaterID = DAT_TileMapState::instance.FloatingLayer[tile]; - if (249 < floaterID) { + if (countof(this->floatersArray) - 1 < floaterID) { return; } for (; floaterID != 0; floaterID = this->floatersArray[floaterID].id) { @@ -42,7 +42,7 @@ namespace Rendering { = imageY - DAT_TextureRenderCoreObject::instance.gmFileHeaderColorpaletteArray[gmID].originY; this->floatersArray[newFloaterIndex].tile = tile; this->floatersArray[newFloaterIndex].variation = variation; - this->availableFloaterIndex = this->availableFloaterIndex + 1; + this->availableFloaterIndex++; } } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp b/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp index 89a97ee687..ca6c26644d 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp @@ -1,5 +1,8 @@ #include "../ViewportRenderState.func.hpp" +#include "OpenSHC/Map/MapConstants.hpp" +#include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" + #include "OpenSHC/Globals/DAT_TileMapState.hpp" namespace OpenSHC { @@ -8,37 +11,37 @@ namespace Rendering { // FUNCTION: STRONGHOLDCRUSADER 0x004E5E20 void ViewportRenderState::focusOnTile(int tile) { - int screenPointIndex = 8; + int screenPointIndex = Enums::VC_SCREEN_POINT_TABLE_START; if (DAT_TileMapState::instance.mapOrientation != 0) { if (DAT_TileMapState::instance.mapOrientation == 6) { - screenPointIndex = 80408; + screenPointIndex = Enums::VC_SCREEN_POINT_TABLE_START + Enums::VC_SCREEN_POINT_TABLE_SIZE; } else if (DAT_TileMapState::instance.mapOrientation == 4) { - screenPointIndex = 160808; + screenPointIndex = Enums::VC_SCREEN_POINT_TABLE_START + 2 * Enums::VC_SCREEN_POINT_TABLE_SIZE; } else if (DAT_TileMapState::instance.mapOrientation == 2) { - screenPointIndex = 241208; + screenPointIndex = Enums::VC_SCREEN_POINT_TABLE_START + 3 * Enums::VC_SCREEN_POINT_TABLE_SIZE; } } - int rowLength = 201; + int rowLength = Enums::VC_SCREEN_POINT_LONG_ROW; int tileX = 0; int tileY; bool found = false; - for (tileY = 0; tileY < 400; tileY++) { - rowLength = (rowLength != 201) + 200; + for (tileY = 0; tileY < Map::MC_MAP_XY_LIMIT; tileY++) { + rowLength = (rowLength != Enums::VC_SCREEN_POINT_LONG_ROW) + Enums::VC_SCREEN_POINT_SHORT_ROW; for (tileX = 0; tileX < rowLength; ++tileX) { if (this->screenPointToTileNumber[screenPointIndex] == tile) { found = true; break; } - screenPointIndex = screenPointIndex + 1; + screenPointIndex++; } if (found) { break; } } - this->viewportState.viewportX = (tileX - this->viewportState.mbr_0xac) * 32; - this->viewportState.viewportY = (tileY - this->viewportState.mbr_0xb0) * 8; + this->viewportState.viewportX = (tileX - this->viewportState.mbr_0xac) * Enums::VC_TILE_PIXEL_WIDTH; + this->viewportState.viewportY = (tileY - this->viewportState.mbr_0xb0) * Enums::VC_TILE_ROW_PIXEL_HEIGHT; MACRO_CALL_MEMBER(OpenSHC::Rendering::ViewportRenderState_Func::setViewportBasedOnMapSize, this)(); } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp index 621fb620fd..fb490af9fe 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp @@ -1,6 +1,7 @@ #include "../ViewportRenderState.func.hpp" #include "OpenSHC/UI/Rendering/TextureRenderCore.func.hpp" +#include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" #include "OpenSHC/Globals/DAT_BuildingsState.hpp" #include "OpenSHC/Globals/DAT_CurrentlyRenderedSpriteID.hpp" @@ -34,7 +35,7 @@ namespace Rendering { (); MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::setMapSurfaceHeightRange, DAT_TextureRenderCoreObject::ptr) - ((screenY - 39 < 0) ? 0 : screenY - 39, 2076); + ((screenY - 39 < 0) ? 0 : screenY - 39, Enums::VC_MAP_SURFACE_HEIGHT); } DAT_RenderedUnitOwner::instance = DAT_BuildingsState::instance.buildings[buildingID].playerColorUnk; diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp index be4e2bbfcf..598133cabb 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp @@ -2,6 +2,7 @@ #include "OpenSHC/OS.func.hpp" #include "OpenSHC/Text/TextManager.func.hpp" +#include "OpenSHC/Rendering/Colors/ColorsEnum.hpp" #include "OpenSHC/Text/TextAlignment.hpp" #include "OpenSHC/WindowsHelper/Enums/BOOLEnum.hpp" @@ -27,46 +28,46 @@ namespace Rendering { MACRO_CALL(OpenSHC::OS_Func::_sprintf) (text, "Mouse Atom Ref: %d", this->viewportState.mouseAtomRefFloorTile); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) - (text, textX, y, OpenSHC::Text::TTA_LEFT, 16777215, 18, FALSE, 0); + (text, textX, y, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) (text, "Mouse: x%d, y%d, off%d", DAT_ViewportRenderState::instance.viewportState.mouseX, DAT_ViewportRenderState::instance.viewportState.mouseY, DAT_ViewportRenderState::instance.viewportState.mouseTile); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) - (text, textX, y + 16, OpenSHC::Text::TTA_LEFT, 16777215, 18, FALSE, 0); + (text, textX, y + 16, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) (text, "Tile centre: x%d,y%d", DAT_ViewportRenderState::instance.viewportState.tileCenterX, DAT_ViewportRenderState::instance.viewportState.tileCenterY); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) - (text, textX, y + 32, OpenSHC::Text::TTA_LEFT, 16777215, 18, FALSE, 0); + (text, textX, y + 32, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) (text, "Chimp: %d Struct: %d Fly: %d", this->viewportState.mouseRayUnitID, this->viewportState.mouseRayBuildingID, this->viewportState.mouseRayEntityID); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) - (text, textX, y + 64, OpenSHC::Text::TTA_LEFT, 16777215, 18, FALSE, 0); + (text, textX, y + 64, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) (text, "Logic Layer: %x %x", DAT_TileMapState::instance.LogicLayer[this->viewportState.mouseAtomRefFloorTile], DAT_TileMapState::instance.LogicLayer[this->viewportState.mouseTile]); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) - (text, textX, y + 80, OpenSHC::Text::TTA_LEFT, 16777215, 18, FALSE, 0); + (text, textX, y + 80, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) (text, "Logic2 Layer: %x %x", (char)DAT_TileMapState::instance.Logic2Layer[this->viewportState.mouseAtomRefFloorTile], (char)DAT_TileMapState::instance.Logic2Layer[this->viewportState.mouseTile]); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) - (text, textX + 20, y + 80, OpenSHC::Text::TTA_LEFT, 16777215, 18, TRUE, 0); + (text, textX + 20, y + 80, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, TRUE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) (text, "Damage Layer: %d %d", (char)DAT_TileMapState::instance.DamageLayer[this->viewportState.mouseAtomRefFloorTile], (char)DAT_TileMapState::instance.DamageLayer[this->viewportState.mouseTile]); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) - (text, textX, y + 96, OpenSHC::Text::TTA_LEFT, 16777215, 18, FALSE, 0); + (text, textX, y + 96, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); } } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp index ae19cb5beb..bdf28a68e3 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp @@ -8,6 +8,7 @@ #include "OpenSHC/Map/Buildings/BuildingType.hpp" #include "OpenSHC/Map/Buildings/BuildingTypeShort.hpp" #include "OpenSHC/Map/MapType2.hpp" +#include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" #include "OpenSHC/UI/Enums/MenuViewType.hpp" #include "OpenSHC/Globals/DAT_BuildingDefinedData.hpp" @@ -522,7 +523,7 @@ namespace Rendering { == OpenSHC::Map::Buildings::BT_OXTETHER)) { DAT_RenderedUnitOwner::instance = DAT_BuildingsState::instance.buildings[buildingID].playerColorUnk; frame = DAT_BuildingsState::instance.buildings[buildingID].overlayImageID; - DAT_CurrentlyRenderedSpriteID::instance = 189; + DAT_CurrentlyRenderedSpriteID::instance = OpenSHC::IO::Graphics::GID_ANIM_FLAG_SMALL; if (frame != 0) { MACRO_CALL_MEMBER( OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGM, DAT_TextureRenderCoreObject::ptr)( @@ -553,7 +554,8 @@ namespace Rendering { DAT_TextureRenderCoreObject::ptr)(); if (DAT_BuildingsState::instance.buildings[buildingID].drawBridgeState1 == 0) { MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::setMapSurfaceHeightRange, - DAT_TextureRenderCoreObject::ptr)(screenY - 23 < 0 ? 0 : screenY - 23, 2076); + DAT_TextureRenderCoreObject::ptr)( + screenY - 23 < 0 ? 0 : screenY - 23, Enums::VC_MAP_SURFACE_HEIGHT); } } buildingType = DAT_BuildingsState::instance.buildings[buildingID].buildingType; diff --git a/src/OpenSHC/Rendering/ViewportRenderState/resetupViewport.cpp b/src/OpenSHC/Rendering/ViewportRenderState/resetupViewport.cpp index b5050fc64b..2e52bac849 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/resetupViewport.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/resetupViewport.cpp @@ -1,5 +1,6 @@ #include "../ViewportRenderState.func.hpp" +#include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" #include "OpenSHC/UI/Enums/BuildingsAndStatusMenuTabType.hpp" #include "OpenSHC/UI/Enums/MenuViewType.hpp" @@ -15,8 +16,9 @@ namespace Rendering { // FUNCTION: STRONGHOLDCRUSADER 0x004E7770 void ViewportRenderState::resetupViewport(int zoomUnk) { - int savedViewportY = this->viewportState.viewportY + this->viewportState.mbr_0xb0 * 8; - int savedViewportX = this->viewportState.mbr_0xac * 32 + this->viewportState.viewportX; + int savedViewportY + = this->viewportState.viewportY + this->viewportState.mbr_0xb0 * Enums::VC_TILE_ROW_PIXEL_HEIGHT; + int savedViewportX = this->viewportState.mbr_0xac * Enums::VC_TILE_PIXEL_WIDTH + this->viewportState.viewportX; this->viewportState.isZoomedOutUnk = zoomUnk; if ((DAT_GameCore::instance.currentMenuViewType == OpenSHC::UI::Enums::MVT_BUILD_MENU @@ -29,8 +31,8 @@ namespace Rendering { MACRO_CALL_MEMBER(OpenSHC::Rendering::ViewportRenderState_Func::setupViewport, this) (0, 0, DAT_WindowAndDirectDraw::instance.resolutionX, DAT_WindowAndDirectDraw::instance.resolutionY - 128); } - this->viewportState.viewportX = savedViewportX - this->viewportState.mbr_0xac * 32; - this->viewportState.viewportY = savedViewportY - this->viewportState.mbr_0xb0 * 8; + this->viewportState.viewportX = savedViewportX - this->viewportState.mbr_0xac * Enums::VC_TILE_PIXEL_WIDTH; + this->viewportState.viewportY = savedViewportY - this->viewportState.mbr_0xb0 * Enums::VC_TILE_ROW_PIXEL_HEIGHT; MACRO_CALL_MEMBER(OpenSHC::Rendering::ViewportRenderState_Func::setViewportBasedOnMapSize, this)(); } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp b/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp index 767f0f3f25..721cee4d4c 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp @@ -1,5 +1,7 @@ #include "../ViewportRenderState.func.hpp" +#include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" + #include "OpenSHC/Globals/DAT_CurrentlyRenderedSpriteID.hpp" #include "OpenSHC/Globals/DAT_RenderedUnitOwner.hpp" @@ -13,13 +15,13 @@ namespace Rendering { int batch; if (param_7 == 1) { batch = this->unitBatchedRenderCounterUntil6 + 4; - if (5 < batch) { - batch = batch - 5; + if (Enums::VC_UNIT_BATCH_COUNT < batch) { + batch -= Enums::VC_UNIT_BATCH_COUNT; } } else if (param_7 == 2) { batch = this->unitBatchedRenderCounterUntil6 + 3; - if (5 < batch) { - batch = batch - 5; + if (Enums::VC_UNIT_BATCH_COUNT < batch) { + batch -= Enums::VC_UNIT_BATCH_COUNT; } } else { batch = this->unitBatchedRenderCounterUntil6; @@ -27,7 +29,7 @@ namespace Rendering { switch (batch) { case 1: - if (this->unitRender1 < 500) { + if (this->unitRender1 < countof(this->unitBatch1)) { this->unitBatch1[this->unitRender1].unitIDOrStatus = unitIDOrStatus; this->unitBatch1[this->unitRender1].ownerColor = DAT_RenderedUnitOwner::instance; this->unitBatch1[this->unitRender1].spriteID = DAT_CurrentlyRenderedSpriteID::instance; @@ -36,11 +38,11 @@ namespace Rendering { this->unitBatch1[this->unitRender1].imageID = imageID; this->unitBatch1[this->unitRender1].blendStrength = blendStrength; this->unitBatch1[this->unitRender1].gmID = gmID; - this->unitRender1 = this->unitRender1 + 1; + this->unitRender1++; } break; case 2: - if (this->unitRender2 < 500) { + if (this->unitRender2 < countof(this->unitBatch2)) { this->unitBatch2[this->unitRender2].unitIDOrStatus = unitIDOrStatus; this->unitBatch2[this->unitRender2].ownerColor = DAT_RenderedUnitOwner::instance; this->unitBatch2[this->unitRender2].spriteID = DAT_CurrentlyRenderedSpriteID::instance; @@ -49,11 +51,11 @@ namespace Rendering { this->unitBatch2[this->unitRender2].imageID = imageID; this->unitBatch2[this->unitRender2].blendStrength = blendStrength; this->unitBatch2[this->unitRender2].gmID = gmID; - this->unitRender2 = this->unitRender2 + 1; + this->unitRender2++; } break; case 3: - if (this->unitRender3 < 500) { + if (this->unitRender3 < countof(this->unitBatch3)) { this->unitBatch3[this->unitRender3].unitIDOrStatus = unitIDOrStatus; this->unitBatch3[this->unitRender3].ownerColor = DAT_RenderedUnitOwner::instance; this->unitBatch3[this->unitRender3].spriteID = DAT_CurrentlyRenderedSpriteID::instance; @@ -62,11 +64,11 @@ namespace Rendering { this->unitBatch3[this->unitRender3].imageID = imageID; this->unitBatch3[this->unitRender3].blendStrength = blendStrength; this->unitBatch3[this->unitRender3].gmID = gmID; - this->unitRender3 = this->unitRender3 + 1; + this->unitRender3++; } break; case 4: - if (this->unitRender4 < 500) { + if (this->unitRender4 < countof(this->unitBatch4)) { this->unitBatch4[this->unitRender4].unitIDOrStatus = unitIDOrStatus; this->unitBatch4[this->unitRender4].ownerColor = DAT_RenderedUnitOwner::instance; this->unitBatch4[this->unitRender4].spriteID = DAT_CurrentlyRenderedSpriteID::instance; @@ -75,11 +77,11 @@ namespace Rendering { this->unitBatch4[this->unitRender4].imageID = imageID; this->unitBatch4[this->unitRender4].blendStrength = blendStrength; this->unitBatch4[this->unitRender4].gmID = gmID; - this->unitRender4 = this->unitRender4 + 1; + this->unitRender4++; } break; case 5: - if (this->unitRender5 < 500) { + if (this->unitRender5 < countof(this->unitBatch5)) { this->unitBatch5[this->unitRender5].unitIDOrStatus = unitIDOrStatus; this->unitBatch5[this->unitRender5].ownerColor = DAT_RenderedUnitOwner::instance; this->unitBatch5[this->unitRender5].spriteID = DAT_CurrentlyRenderedSpriteID::instance; @@ -88,7 +90,7 @@ namespace Rendering { this->unitBatch5[this->unitRender5].imageID = imageID; this->unitBatch5[this->unitRender5].blendStrength = blendStrength; this->unitBatch5[this->unitRender5].gmID = gmID; - this->unitRender5 = this->unitRender5 + 1; + this->unitRender5++; } break; } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp index 0475e22773..0fe5151e12 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp @@ -1,5 +1,7 @@ #include "../ViewportRenderState.func.hpp" +#include "OpenSHC/Map/MapConstants.hpp" +#include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" #include "OpenSHC/Rendering/ScreenResolutionEnum.hpp" #include "OpenSHC/Globals/DAT_TileMapState.hpp" @@ -14,18 +16,19 @@ namespace Rendering { // FUNCTION: STRONGHOLDCRUSADER 0x004E5C00 void ViewportRenderState::setViewportBasedOnMapSize() { - int mapBorder = 400 - DAT_TileMapState::instance.mapSize; - if (mapBorder == 400) { + int mapBorder = Map::MC_MAP_SIZE_400 - DAT_TileMapState::instance.mapSize; + if (mapBorder == Map::MC_MAP_SIZE_400) { mapBorder = 0; } - mapBorder = mapBorder / 2; + mapBorder /= 2; - int maxViewportX = (((400 - mapBorder) / 2 - this->viewportState.viewportHeight) + 4) * 32; - int maxViewportY = ((401 - this->viewportState.viewportWidth) - mapBorder) * 8; - int minViewportX = (mapBorder / 2 + 1) * 32; - int minViewportY = mapBorder * 8 + 16; + int maxViewportX = (((Map::MC_MAP_SIZE_400 - mapBorder) / 2 - this->viewportState.viewportHeight) + 4) + * Enums::VC_TILE_PIXEL_WIDTH; + int maxViewportY = ((401 - this->viewportState.viewportWidth) - mapBorder) * Enums::VC_TILE_ROW_PIXEL_HEIGHT; + int minViewportX = (mapBorder / 2 + 1) * Enums::VC_TILE_PIXEL_WIDTH; + int minViewportY = mapBorder * Enums::VC_TILE_ROW_PIXEL_HEIGHT + 16; if (this->viewportState.isZoomedOutUnk != 0) { - minViewportX = (mapBorder / 2 - 4) * 32; + minViewportX = (mapBorder / 2 - 4) * Enums::VC_TILE_PIXEL_WIDTH; } if (this->viewportState.viewportX < minViewportX) { @@ -43,31 +46,31 @@ namespace Rendering { if (DAT_TileMapState::instance.mapOrientation != 0) { if (DAT_TileMapState::instance.mapOrientation == 6) { - if (this->viewportState.viewportX > maxViewportX - 32) { - this->viewportState.viewportX = maxViewportX - 32; + if (this->viewportState.viewportX > maxViewportX - Enums::VC_TILE_PIXEL_WIDTH) { + this->viewportState.viewportX = maxViewportX - Enums::VC_TILE_PIXEL_WIDTH; } } else if (DAT_TileMapState::instance.mapOrientation == 4) { - if (this->viewportState.viewportY < minViewportY + 8) { - this->viewportState.viewportY = minViewportY + 8; + if (this->viewportState.viewportY < minViewportY + Enums::VC_TILE_ROW_PIXEL_HEIGHT) { + this->viewportState.viewportY = minViewportY + Enums::VC_TILE_ROW_PIXEL_HEIGHT; } - if (this->viewportState.viewportY > maxViewportY - 8) { - this->viewportState.viewportY = maxViewportY - 8; + if (this->viewportState.viewportY > maxViewportY - Enums::VC_TILE_ROW_PIXEL_HEIGHT) { + this->viewportState.viewportY = maxViewportY - Enums::VC_TILE_ROW_PIXEL_HEIGHT; } } else if (DAT_TileMapState::instance.mapOrientation == 2) { if (this->viewportState.viewportX < minViewportX + 16) { this->viewportState.viewportX = minViewportX + 16; } - if (this->viewportState.viewportY > maxViewportY - 8) { - this->viewportState.viewportY = maxViewportY - 8; + if (this->viewportState.viewportY > maxViewportY - Enums::VC_TILE_ROW_PIXEL_HEIGHT) { + this->viewportState.viewportY = maxViewportY - Enums::VC_TILE_ROW_PIXEL_HEIGHT; } } } - if (DAT_TileMapState::instance.mapSize == 160 + if (DAT_TileMapState::instance.mapSize == Map::MC_MAP_SIZE_160 && DAT_WindowAndDirectDraw::instance.currentGameResolution == OpenSHC::Rendering::SRE_1024x768 && this->viewportState.isZoomedOutUnk != 0) { - minViewportY = minViewportY - 10; - maxViewportY = maxViewportY - 10; + minViewportY -= 10; + maxViewportY -= 10; } if (minViewportX > maxViewportX) { @@ -88,7 +91,7 @@ namespace Rendering { this->viewportState.currentCameraOffsetY = (DAT_ViewportRenderState::instance.viewportState.viewportY >> 1 & 7) + 8; } - this->viewportState.currentCameraOffsetY = this->viewportState.currentCameraOffsetY + 8; + this->viewportState.currentCameraOffsetY += 8; } } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY.cpp index 3877b8c45f..8bf979be94 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY.cpp @@ -19,8 +19,7 @@ namespace Rendering { this->viewportState.mouseTileX = this->viewportState.mouseAtomRefFloorTile - this->translationMatrix[this->viewportState.mouseTileY].firstTileOfRow; - this->viewportState.mouseTileX - = this->translationMatrix[this->viewportState.mouseTileY].distanceToCenter + this->viewportState.mouseTileX; + this->viewportState.mouseTileX += this->translationMatrix[this->viewportState.mouseTileY].distanceToCenter; } } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp index 49070bd27d..abb64575a8 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp @@ -19,8 +19,7 @@ namespace Rendering { this->viewportState.mouseTileX = this->viewportState.mouseTile - this->translationMatrix[this->viewportState.mouseTileY].firstTileOfRow; - this->viewportState.mouseTileX - = this->translationMatrix[this->viewportState.mouseTileY].distanceToCenter + this->viewportState.mouseTileX; + this->viewportState.mouseTileX += this->translationMatrix[this->viewportState.mouseTileY].distanceToCenter; } } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/updateWaterAnimationFrames.cpp b/src/OpenSHC/Rendering/ViewportRenderState/updateWaterAnimationFrames.cpp index 2c815f6662..9ef2dfedeb 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/updateWaterAnimationFrames.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/updateWaterAnimationFrames.cpp @@ -12,14 +12,14 @@ namespace Rendering { if ((int)(now - this->previousIntervalTime_04) >= this->interval_04_180) { this->previousIntervalTime_04 = now; this->field_0x18b764 = 1; - for (int i = 0; i < 45; i++) { - this->landscapeSeaWhiteCapsAnimationFrames[i] = this->landscapeSeaWhiteCapsAnimationFrames[i] + 1; + for (int i = 0; i < countof(this->landscapeSeaWhiteCapsAnimationFrames); ++i) { + this->landscapeSeaWhiteCapsAnimationFrames[i]++; } } if ((int)(now - this->previousIntervalTime_01) >= this->interval_01_80) { this->previousIntervalTime_01 = now; - this->unknownCounterUntil_0x10 = this->unknownCounterUntil_0x10 + 1; + this->unknownCounterUntil_0x10++; if (this->unknownCounterUntil_0x10 >= 16) { this->unknownCounterUntil_0x10 = 0; } @@ -27,7 +27,7 @@ namespace Rendering { if ((int)(now - this->previousIntervalTime_02) >= this->interval_02_100) { this->previousIntervalTime_02 = now; - this->unknownCounterUntil_0x20 = this->unknownCounterUntil_0x20 + 1; + this->unknownCounterUntil_0x20++; if (this->unknownCounterUntil_0x20 >= 32) { this->unknownCounterUntil_0x20 = 0; } @@ -35,11 +35,11 @@ namespace Rendering { if ((int)(now - this->previousIntervalTime_03) >= this->interval_03_160) { this->previousIntervalTime_03 = now; - this->unknownCounterUntil_0x24 = this->unknownCounterUntil_0x24 + 1; + this->unknownCounterUntil_0x24++; if (this->unknownCounterUntil_0x24 >= 36) { this->unknownCounterUntil_0x24 = 0; } - this->unknownCounterUntil_0x200 = this->unknownCounterUntil_0x200 + 1; + this->unknownCounterUntil_0x200++; if (this->unknownCounterUntil_0x200 >= 512) { this->unknownCounterUntil_0x200 = 0; } From 360d8f1656c4b5ec79d84b19faa7907ec14ac484 Mon Sep 17 00:00:00 2001 From: Gynt Date: Wed, 11 Nov 2026 10:46:02 +0100 Subject: [PATCH 06/13] types(MapConstants): map orientations MC_MAP_NORTH, EAST, SOUTH and WEST TileMapState::mapOrientation takes 0, 2, 4 and 6. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XmXCmYbLQCBa8ek5RWjimR --- src/OpenSHC/Map/MapConstants.hpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/OpenSHC/Map/MapConstants.hpp b/src/OpenSHC/Map/MapConstants.hpp index 92ff4e691b..0dfae3f5dc 100644 --- a/src/OpenSHC/Map/MapConstants.hpp +++ b/src/OpenSHC/Map/MapConstants.hpp @@ -12,6 +12,10 @@ namespace OpenSHC { namespace Map { typedef enum MapConstants { + MC_MAP_NORTH = 0, // 0x00000000 + MC_MAP_EAST = 2, // 0x00000002 + MC_MAP_SOUTH = 4, // 0x00000004 + MC_MAP_WEST = 6, // 0x00000006 MC_MAP_SIZE_160 = 160, // 0x000000A0 MC_MAP_SIZE_200 = 200, // 0x000000C8 MC_MAP_SIZE_300 = 300, // 0x0000012C From 18b0b6eec8ad120ee698d531823338569c345a61 Mon Sep 17 00:00:00 2001 From: Gynt Date: Wed, 11 Nov 2026 10:46:44 +0100 Subject: [PATCH 07/13] style(ViewportRenderState): mapOrientation tests use MC_MAP_NORTH, EAST, SOUTH and WEST focusOnTile and setViewportBasedOnMapSize compile as before (quick_diff identical to the committed sources). Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XmXCmYbLQCBa8ek5RWjimR --- src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp | 8 ++++---- .../ViewportRenderState/setViewportBasedOnMapSize.cpp | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp b/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp index ca6c26644d..3269a1e769 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp @@ -12,12 +12,12 @@ namespace Rendering { void ViewportRenderState::focusOnTile(int tile) { int screenPointIndex = Enums::VC_SCREEN_POINT_TABLE_START; - if (DAT_TileMapState::instance.mapOrientation != 0) { - if (DAT_TileMapState::instance.mapOrientation == 6) { + if (DAT_TileMapState::instance.mapOrientation != Map::MC_MAP_NORTH) { + if (DAT_TileMapState::instance.mapOrientation == Map::MC_MAP_WEST) { screenPointIndex = Enums::VC_SCREEN_POINT_TABLE_START + Enums::VC_SCREEN_POINT_TABLE_SIZE; - } else if (DAT_TileMapState::instance.mapOrientation == 4) { + } else if (DAT_TileMapState::instance.mapOrientation == Map::MC_MAP_SOUTH) { screenPointIndex = Enums::VC_SCREEN_POINT_TABLE_START + 2 * Enums::VC_SCREEN_POINT_TABLE_SIZE; - } else if (DAT_TileMapState::instance.mapOrientation == 2) { + } else if (DAT_TileMapState::instance.mapOrientation == Map::MC_MAP_EAST) { screenPointIndex = Enums::VC_SCREEN_POINT_TABLE_START + 3 * Enums::VC_SCREEN_POINT_TABLE_SIZE; } } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp index 0fe5151e12..1d5427eb54 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp @@ -44,19 +44,19 @@ namespace Rendering { this->viewportState.viewportY = maxViewportY; } - if (DAT_TileMapState::instance.mapOrientation != 0) { - if (DAT_TileMapState::instance.mapOrientation == 6) { + if (DAT_TileMapState::instance.mapOrientation != Map::MC_MAP_NORTH) { + if (DAT_TileMapState::instance.mapOrientation == Map::MC_MAP_WEST) { if (this->viewportState.viewportX > maxViewportX - Enums::VC_TILE_PIXEL_WIDTH) { this->viewportState.viewportX = maxViewportX - Enums::VC_TILE_PIXEL_WIDTH; } - } else if (DAT_TileMapState::instance.mapOrientation == 4) { + } else if (DAT_TileMapState::instance.mapOrientation == Map::MC_MAP_SOUTH) { if (this->viewportState.viewportY < minViewportY + Enums::VC_TILE_ROW_PIXEL_HEIGHT) { this->viewportState.viewportY = minViewportY + Enums::VC_TILE_ROW_PIXEL_HEIGHT; } if (this->viewportState.viewportY > maxViewportY - Enums::VC_TILE_ROW_PIXEL_HEIGHT) { this->viewportState.viewportY = maxViewportY - Enums::VC_TILE_ROW_PIXEL_HEIGHT; } - } else if (DAT_TileMapState::instance.mapOrientation == 2) { + } else if (DAT_TileMapState::instance.mapOrientation == Map::MC_MAP_EAST) { if (this->viewportState.viewportX < minViewportX + 16) { this->viewportState.viewportX = minViewportX + 16; } From c429729eea3dc9359e89f36bd804ab2b4c01ad4c Mon Sep 17 00:00:00 2001 From: Gynt Date: Wed, 11 Nov 2026 10:58:22 +0100 Subject: [PATCH 08/13] style(ViewportRenderState): debug overlay format strings from string-literals.hpp renderDebugDataMousePointing still measures 100%. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XmXCmYbLQCBa8ek5RWjimR --- .../renderDebugDataMousePointing.cpp | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp index 598133cabb..08c8a6206b 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp @@ -5,6 +5,7 @@ #include "OpenSHC/Rendering/Colors/ColorsEnum.hpp" #include "OpenSHC/Text/TextAlignment.hpp" #include "OpenSHC/WindowsHelper/Enums/BOOLEnum.hpp" +#include "OpenSHC/string-literals.hpp" #include "OpenSHC/Globals/DAT_TextManagerObject.hpp" #include "OpenSHC/Globals/DAT_TileMapState.hpp" @@ -26,44 +27,45 @@ namespace Rendering { int textX = x + 2; MACRO_CALL(OpenSHC::OS_Func::_sprintf) - (text, "Mouse Atom Ref: %d", this->viewportState.mouseAtomRefFloorTile); + (text, s_Mouse_Atom_Ref___d_005ab8a4, this->viewportState.mouseAtomRefFloorTile); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) (text, textX, y, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) - (text, "Mouse: x%d, y%d, off%d", DAT_ViewportRenderState::instance.viewportState.mouseX, + (text, s_Mouse__x_d__y_d__off_d_005ab88c, DAT_ViewportRenderState::instance.viewportState.mouseX, DAT_ViewportRenderState::instance.viewportState.mouseY, DAT_ViewportRenderState::instance.viewportState.mouseTile); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) (text, textX, y + 16, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) - (text, "Tile centre: x%d,y%d", DAT_ViewportRenderState::instance.viewportState.tileCenterX, + (text, s_Tile_centre__x_d_y_d_005ab874, DAT_ViewportRenderState::instance.viewportState.tileCenterX, DAT_ViewportRenderState::instance.viewportState.tileCenterY); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) (text, textX, y + 32, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) - (text, "Chimp: %d Struct: %d Fly: %d", this->viewportState.mouseRayUnitID, + (text, s_Chimp___d_Struct___d_Fly___d_005ab854, this->viewportState.mouseRayUnitID, this->viewportState.mouseRayBuildingID, this->viewportState.mouseRayEntityID); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) (text, textX, y + 64, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) - (text, "Logic Layer: %x %x", DAT_TileMapState::instance.LogicLayer[this->viewportState.mouseAtomRefFloorTile], + (text, s_Logic_Layer___x__x_005ab840, + DAT_TileMapState::instance.LogicLayer[this->viewportState.mouseAtomRefFloorTile], DAT_TileMapState::instance.LogicLayer[this->viewportState.mouseTile]); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) (text, textX, y + 80, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) - (text, "Logic2 Layer: %x %x", + (text, s_Logic2_Layer___x__x_005ab828, (char)DAT_TileMapState::instance.Logic2Layer[this->viewportState.mouseAtomRefFloorTile], (char)DAT_TileMapState::instance.Logic2Layer[this->viewportState.mouseTile]); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) (text, textX + 20, y + 80, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, TRUE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) - (text, "Damage Layer: %d %d", + (text, s_Damage_Layer___d__d_005ab810, (char)DAT_TileMapState::instance.DamageLayer[this->viewportState.mouseAtomRefFloorTile], (char)DAT_TileMapState::instance.DamageLayer[this->viewportState.mouseTile]); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) From 978d0aafeade0057af6b0af5fd94cfbdd46dd432 Mon Sep 17 00:00:00 2001 From: Gynt Date: Wed, 11 Nov 2026 11:01:27 +0100 Subject: [PATCH 09/13] style(ViewportRenderState): drop the decompiler's security cookie local /GS (on by default in MSVC 2005) emits the cookie for char text[200] itself; the unused local read of MSVC_SecurityCookie was optimised away. renderDebugDataMousePointing still measures 100%. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01XmXCmYbLQCBa8ek5RWjimR --- .../ViewportRenderState/renderDebugDataMousePointing.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp index 08c8a6206b..3adba965c0 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp @@ -10,7 +10,6 @@ #include "OpenSHC/Globals/DAT_TextManagerObject.hpp" #include "OpenSHC/Globals/DAT_TileMapState.hpp" #include "OpenSHC/Globals/DAT_ViewportRenderState.hpp" -#include "OpenSHC/Globals/MSVC_SecurityCookie.hpp" namespace OpenSHC { namespace Rendering { @@ -22,7 +21,6 @@ namespace Rendering { void ViewportRenderState::renderDebugDataMousePointing(int x, int y, int width, int height) { char text[200]; - uint securityCookie = MSVC_SecurityCookie::instance ^ (uint)text; int textX = x + 2; From 92ef3b72494d4ff2e6463c090dfdf888ae85728e Mon Sep 17 00:00:00 2001 From: Gynt Date: Sat, 14 Nov 2026 01:47:44 +0100 Subject: [PATCH 10/13] types(ViewportRenderState): name review-flagged fields, enums for magic numbers - Map::LogicHelpers::MiscDisplay: MiscDisplayLayer bits 0x40-0x200 are the sea edge graphics updateGfxLayer sets (cliff, shore, shore edge); MD_SEA_EDGES is their 0x3C0 mask. - Map::Buildings::BuildingTargetMarker(Short): Building+0xC2, set to 1 by drawFlagsAndUnitDestinations for a building an own unit targets and to 2 by the unit selection handler for an own engine when engineers are selected; renderGmOverlayBuilding2 draws the marker and clears it. - ViewportConstants: VC_TILE_PIXEL_HEIGHT (16) and VC_MAP_SURFACE_MARGIN_X (150, the map surface's left margin in currentCameraOffsetX). - ViewportRenderState: the updateWaterAnimationFrames clocks named after the counters they drive (animationFrame16/32/36/512, slowAnimation*); slowAnimationTicked is BOOLEnum. - ViewportState::mouseTile -> mouseFlatTile: the height-ignoring tile updateBuildingPreviewPosition writes, against the elevation-aware mouseAtomRefFloorTile. - Floater::id -> nextFloaterID: the per-tile floater chain link. - TileMapState::disableElevationRendering is BOOLEnum. - scheduleUnitForBatchedRendering takes ints; param_7 -> batchesEarlier. - renderBuildingAnimation(buildingID, screenX, screenY, tile, BOOLEnum clipToBuilding). Co-Authored-By: Claude Opus 5.5 (1M context) --- src/OpenSHC/Map/Buildings/Building.hpp | 4 ++- .../Map/Buildings/BuildingTargetMarker.hpp | 25 +++++++++++++++ .../Buildings/BuildingTargetMarkerShort.hpp | 21 ++++++++++++ src/OpenSHC/Map/Floaters/Floater.hpp | 2 +- src/OpenSHC/Map/LogicHelpers/MiscDisplay.hpp | 27 ++++++++++++++++ src/OpenSHC/Map/TileMapState.hpp | 2 +- .../Rendering/Enums/ViewportConstants.hpp | 2 ++ .../Rendering/ViewportRenderState.func.hpp | 7 ++-- src/OpenSHC/Rendering/ViewportRenderState.hpp | 32 +++++++++---------- src/OpenSHC/Rendering/ViewportState.hpp | 2 +- 10 files changed, 100 insertions(+), 24 deletions(-) create mode 100644 src/OpenSHC/Map/Buildings/BuildingTargetMarker.hpp create mode 100644 src/OpenSHC/Map/Buildings/BuildingTargetMarkerShort.hpp create mode 100644 src/OpenSHC/Map/LogicHelpers/MiscDisplay.hpp diff --git a/src/OpenSHC/Map/Buildings/Building.hpp b/src/OpenSHC/Map/Buildings/Building.hpp index 32964f2d13..73db67fc76 100644 --- a/src/OpenSHC/Map/Buildings/Building.hpp +++ b/src/OpenSHC/Map/Buildings/Building.hpp @@ -11,6 +11,7 @@ #include "OpenSHC/Game/Resources/ResourceTypeShort.hpp" #include "OpenSHC/Map/Buildings/BuildingFlagSlot.hpp" #include "OpenSHC/Map/Buildings/BuildingLogicalStateShort.hpp" +#include "OpenSHC/Map/Buildings/BuildingTargetMarkerShort.hpp" #include "OpenSHC/Map/Buildings/BuildingTypeShort.hpp" #include "OpenSHC/Map/Buildings/Enums/DefensiveTowerEngineTypeByte.hpp" @@ -21,6 +22,7 @@ namespace Map { using OpenSHC::Game::Resources::ResourceTypeShort; using OpenSHC::Map::Buildings::BuildingFlagSlot; using OpenSHC::Map::Buildings::BuildingLogicalStateShort; + using OpenSHC::Map::Buildings::BuildingTargetMarkerShort; using OpenSHC::Map::Buildings::BuildingTypeShort; using OpenSHC::Map::Buildings::Enums::DefensiveTowerEngineTypeByte; @@ -89,7 +91,7 @@ namespace Map { short tickRelatedVisuallyActiveIndicator; // 0x000000BC length: 2 short renderBlendStrength; // 0x000000BE length: 2 short recruitTimer; // 0x000000C0 length: 2 - short field_0xc2; // 0x000000C2 length: 2 + BuildingTargetMarkerShort targetMarker; // 0x000000C2 length: 2 short noRubble; // 0x000000C4 length: 2 undefined1 padding_0xc6[2]; // 0x000000C6 length: 2 int miscDisplayLayerTile; // 0x000000C8 length: 4 diff --git a/src/OpenSHC/Map/Buildings/BuildingTargetMarker.hpp b/src/OpenSHC/Map/Buildings/BuildingTargetMarker.hpp new file mode 100644 index 0000000000..978228614b --- /dev/null +++ b/src/OpenSHC/Map/Buildings/BuildingTargetMarker.hpp @@ -0,0 +1,25 @@ +/** + THIS FILE IS AUTO GENERATED + Communicate changes to the dev team (e.g. via a Pull Request). + Changes get lost otherwise. + + path: 'OpenSHC/Map/Buildings/BuildingTargetMarker.hpp' +*/ + +#pragma once + +namespace OpenSHC { +namespace Map { + namespace Buildings { + typedef enum BuildingTargetMarker { + + BTM_NONE = 0, // 0x00000000 + BTM_UNIT_TARGET = 1, // 0x00000001 + BTM_ENGINEER_TARGET = 2 // 0x00000002 + + } BuildingTargetMarker; + + static_assert_cpp98_obj(sizeof(BuildingTargetMarker) == 4, BuildingTargetMarker); + } // namespace Buildings +} // namespace Map +} // namespace OpenSHC diff --git a/src/OpenSHC/Map/Buildings/BuildingTargetMarkerShort.hpp b/src/OpenSHC/Map/Buildings/BuildingTargetMarkerShort.hpp new file mode 100644 index 0000000000..389dbf5908 --- /dev/null +++ b/src/OpenSHC/Map/Buildings/BuildingTargetMarkerShort.hpp @@ -0,0 +1,21 @@ +/** + THIS FILE IS AUTO GENERATED + Communicate changes to the dev team (e.g. via a Pull Request). + Changes get lost otherwise. + + path: 'OpenSHC/Map/Buildings/BuildingTargetMarkerShort.hpp' +*/ + +#pragma once + +#include "OpenSHC/Map/Buildings/BuildingTargetMarker.hpp" + +namespace OpenSHC { +namespace Map { + namespace Buildings { + typedef short BuildingTargetMarkerShort; + + static_assert_cpp98_obj(sizeof(BuildingTargetMarkerShort) == 2, BuildingTargetMarkerShort); + } // namespace Buildings +} // namespace Map +} // namespace OpenSHC diff --git a/src/OpenSHC/Map/Floaters/Floater.hpp b/src/OpenSHC/Map/Floaters/Floater.hpp index b985c50b3e..75392b97de 100644 --- a/src/OpenSHC/Map/Floaters/Floater.hpp +++ b/src/OpenSHC/Map/Floaters/Floater.hpp @@ -26,7 +26,7 @@ namespace Map { int originY; // 0x0000000C length: 4 int tile; // 0x00000010 length: 4 int variation; // 0x00000014 length: 4 - int id; // 0x00000018 length: 4 + int nextFloaterID; // 0x00000018 length: 4 } Floater; #pragma pack(pop) diff --git a/src/OpenSHC/Map/LogicHelpers/MiscDisplay.hpp b/src/OpenSHC/Map/LogicHelpers/MiscDisplay.hpp new file mode 100644 index 0000000000..12f92e7fa5 --- /dev/null +++ b/src/OpenSHC/Map/LogicHelpers/MiscDisplay.hpp @@ -0,0 +1,27 @@ +/** + THIS FILE IS AUTO GENERATED + Communicate changes to the dev team (e.g. via a Pull Request). + Changes get lost otherwise. + + path: 'OpenSHC/Map/LogicHelpers/MiscDisplay.hpp' +*/ + +#pragma once + +namespace OpenSHC { +namespace Map { + namespace LogicHelpers { + typedef enum MiscDisplay { + + MD_SEA_CLIFF = 64, // 0x00000040 + MD_SEA_UNNAMED_0x80 = 128, // 0x00000080 + MD_SEA_SHORE = 256, // 0x00000100 + MD_SEA_SHORE_EDGE = 512, // 0x00000200 + MD_SEA_EDGES = 960 // 0x000003C0 + + } MiscDisplay; + + static_assert_cpp98_obj(sizeof(MiscDisplay) == 4, MiscDisplay); + } // namespace LogicHelpers +} // namespace Map +} // namespace OpenSHC diff --git a/src/OpenSHC/Map/TileMapState.hpp b/src/OpenSHC/Map/TileMapState.hpp index 5eb2c8e2ad..ae03ec6bbe 100644 --- a/src/OpenSHC/Map/TileMapState.hpp +++ b/src/OpenSHC/Map/TileMapState.hpp @@ -119,7 +119,7 @@ namespace Map { undefined4 refreshCertainTileMap_old; // 0x005548BC length: 4 undefined4 counter1; // 0x005548C0 length: 4 undefined4 refreshRelatedOne; // 0x005548C4 length: 4 - undefined4 disableElevationRendering; // 0x005548C8 length: 4 + BOOLEnum disableElevationRendering; // 0x005548C8 length: 4 undefined4 flatViewToggleValue1; // 0x005548CC length: 4 undefined4 field_0x5548d0; // 0x005548D0 length: 4 undefined4 flatViewToggleValue2; // 0x005548D4 length: 4 diff --git a/src/OpenSHC/Rendering/Enums/ViewportConstants.hpp b/src/OpenSHC/Rendering/Enums/ViewportConstants.hpp index 9289356431..51f07c0756 100644 --- a/src/OpenSHC/Rendering/Enums/ViewportConstants.hpp +++ b/src/OpenSHC/Rendering/Enums/ViewportConstants.hpp @@ -17,7 +17,9 @@ namespace Rendering { VC_SCREEN_POINT_TABLE_START = 8, // 0x00000008 VC_SEA_WHITE_CAP_FRAME_COUNT = 8, // 0x00000008 VC_TILE_ROW_PIXEL_HEIGHT = 8, // 0x00000008 + VC_TILE_PIXEL_HEIGHT = 16, // 0x00000010 VC_TILE_PIXEL_WIDTH = 32, // 0x00000020 + VC_MAP_SURFACE_MARGIN_X = 150, // 0x00000096 VC_SCREEN_POINT_SHORT_ROW = 200, // 0x000000C8 VC_SCREEN_POINT_LONG_ROW = 201, // 0x000000C9 VC_MAP_SURFACE_HEIGHT = 2076, // 0x0000081C diff --git a/src/OpenSHC/Rendering/ViewportRenderState.func.hpp b/src/OpenSHC/Rendering/ViewportRenderState.func.hpp index 3cf3905d51..41a831d7d8 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState.func.hpp +++ b/src/OpenSHC/Rendering/ViewportRenderState.func.hpp @@ -46,16 +46,15 @@ namespace Rendering { &ViewportRenderState::renderAssassinClimbingOverlay) renderAssassinClimbingOverlay; - MACRO_FUNCTION_RESOLVER( - void (ViewportRenderState::*)(undefined4, undefined4, undefined4, undefined4, undefined4, undefined4, int), - false, Address::SHC_3BB0A8C1_0x004E26D0, &ViewportRenderState::scheduleUnitForBatchedRendering) + MACRO_FUNCTION_RESOLVER(void (ViewportRenderState::*)(int, int, int, int, int, int, int), false, + Address::SHC_3BB0A8C1_0x004E26D0, &ViewportRenderState::scheduleUnitForBatchedRendering) scheduleUnitForBatchedRendering; MACRO_FUNCTION_RESOLVER(void (ViewportRenderState::*)(int, int, int, int), false, Address::SHC_3BB0A8C1_0x004E2AD0, &ViewportRenderState::renderGmOverlayBuilding2) renderGmOverlayBuilding2; - MACRO_FUNCTION_RESOLVER(void (ViewportRenderState::*)(int, int, int, undefined4, int), false, + MACRO_FUNCTION_RESOLVER(void (ViewportRenderState::*)(int, int, int, int, BOOLEnum), false, Address::SHC_3BB0A8C1_0x004E3870, &ViewportRenderState::renderBuildingAnimation) renderBuildingAnimation; diff --git a/src/OpenSHC/Rendering/ViewportRenderState.hpp b/src/OpenSHC/Rendering/ViewportRenderState.hpp index 6dee74d85b..e5de731e99 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState.hpp +++ b/src/OpenSHC/Rendering/ViewportRenderState.hpp @@ -54,19 +54,19 @@ namespace Rendering { int screenPixelWidth; // 0x0018B730 length: 4 int screenPixelHeight; // 0x0018B734 length: 4 undefined4 field_0x18b738; // 0x0018B738 length: 4 - int interval_03_160; // 0x0018B73C length: 4 - undefined4 previousIntervalTime_03; // 0x0018B740 length: 4 - int interval_04_180; // 0x0018B744 length: 4 - undefined4 previousIntervalTime_04; // 0x0018B748 length: 4 - int interval_01_80; // 0x0018B74C length: 4 - undefined4 previousIntervalTime_01; // 0x0018B750 length: 4 - int interval_02_100; // 0x0018B754 length: 4 - undefined4 previousIntervalTime_02; // 0x0018B758 length: 4 - int unknownCounterUntil_0x20; // 0x0018B75C length: 4 - int unknownCounterUntil_0x24; // 0x0018B760 length: 4 - int field_0x18b764; // 0x0018B764 length: 4 - int unknownCounterUntil_0x10; // 0x0018B768 length: 4 - int unknownCounterUntil_0x200; // 0x0018B76C length: 4 + int animationFrame36Interval; // 0x0018B73C length: 4 + undefined4 animationFrame36PreviousTime; // 0x0018B740 length: 4 + int slowAnimationInterval; // 0x0018B744 length: 4 + undefined4 slowAnimationPreviousTime; // 0x0018B748 length: 4 + int animationFrame16Interval; // 0x0018B74C length: 4 + undefined4 animationFrame16PreviousTime; // 0x0018B750 length: 4 + int animationFrame32Interval; // 0x0018B754 length: 4 + undefined4 animationFrame32PreviousTime; // 0x0018B758 length: 4 + int animationFrame32; // 0x0018B75C length: 4 + int animationFrame36; // 0x0018B760 length: 4 + BOOLEnum slowAnimationTicked; // 0x0018B764 length: 4 + int animationFrame16; // 0x0018B768 length: 4 + int animationFrame512; // 0x0018B76C length: 4 int unitBatchedRenderCounterUntil6; // 0x0018B770 length: 4 UnitRenderHelpStructure unitBatch1[500]; // 0x0018B774 length: 16000 UnitRenderHelpStructure unitBatch2[500]; // 0x0018F5F4 length: 16000 @@ -104,12 +104,12 @@ namespace Rendering { void renderAssassinClimbingOverlay(int param_1); - void scheduleUnitForBatchedRendering(undefined4 unitIDOrStatus, undefined4 drawX, undefined4 drawY, - undefined4 imageID, undefined4 blendStrength, undefined4 gmID, int param_7); + void scheduleUnitForBatchedRendering( + int unitIDOrStatus, int drawX, int drawY, int imageID, int blendStrength, int gmID, int batchesEarlier); void renderGmOverlayBuilding2(int param_1, int param_2, int param_3, int param_4); - void renderBuildingAnimation(int param_1, int param_2, int param_3, undefined4 param_4, int param_5); + void renderBuildingAnimation(int buildingID, int screenX, int screenY, int tile, BOOLEnum clipToBuilding); void renderGmOverlayBuilding(int tileIndex, int xUnk, int yUnk, int param_4); diff --git a/src/OpenSHC/Rendering/ViewportState.hpp b/src/OpenSHC/Rendering/ViewportState.hpp index f86cce94d8..cb65fa7207 100644 --- a/src/OpenSHC/Rendering/ViewportState.hpp +++ b/src/OpenSHC/Rendering/ViewportState.hpp @@ -18,7 +18,7 @@ namespace Rendering { undefined4 field_0x0; // 0x00000000 length: 4 int mouseTileX; // 0x00000004 length: 4 int mouseTileY; // 0x00000008 length: 4 - int mouseTile; // 0x0000000C length: 4 + int mouseFlatTile; // 0x0000000C length: 4 int previousMouseTile; // 0x00000010 length: 4 undefined4 field_0x14; // 0x00000014 length: 4 undefined4 field_0x18; // 0x00000018 length: 4 From 85f7280285f364fe1e0f176bc20fd63ef4cf5e47 Mon Sep 17 00:00:00 2001 From: Gynt Date: Sat, 14 Nov 2026 01:47:51 +0100 Subject: [PATCH 11/13] style(ViewportRenderState): use the review's new names and enums MD_SEA_EDGES for the white cap tile test, BTM_* for the building target marker, FALSE/TRUE for the BOOLEnum flags, the renamed animation clocks, mouseFlatTile and nextFloaterID, MC_MAP_SIZE_400 + 1 and tile-size and map-surface-margin constants in setViewportBasedOnMapSize. Dropped the redundant (char) casts on char layers and the (ushort) store cast, and renderGmOverlayBuilding2 declares buildingType at first use. All 25 functions stay at 100%. Co-Authored-By: Claude Opus 5.5 (1M context) --- .../Constructor_ViewportRenderState.cpp | 26 +++++------ .../ViewportRenderState/assignRandomTiles.cpp | 3 +- .../clearAllFloatingLayerElements.cpp | 2 +- .../createFloatingLayerElement.cpp | 8 ++-- .../renderBuildingAnimation.cpp | 8 ++-- .../renderDebugDataMousePointing.cpp | 12 ++--- .../renderGmOverlayBuilding2.cpp | 17 ++++--- .../saveFocusTileAndCenterPreview.cpp | 2 +- .../scheduleUnitForBatchedRendering.cpp | 8 ++-- .../setViewportBasedOnMapSize.cpp | 27 +++++++----- .../ViewportRenderState/setupMouseTileXY2.cpp | 6 +-- .../updateWaterAnimationFrames.cpp | 44 +++++++++---------- 12 files changed, 84 insertions(+), 79 deletions(-) diff --git a/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp b/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp index d7b228472e..e938c2822b 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp @@ -13,24 +13,24 @@ namespace Rendering { this->viewportState.previousMouseTile = -1; DWORD now = timeGetTime(); - this->previousIntervalTime_02 = now; - this->previousIntervalTime_01 = now; - this->previousIntervalTime_04 = now; - this->previousIntervalTime_03 = now; + this->animationFrame32PreviousTime = now; + this->animationFrame16PreviousTime = now; + this->slowAnimationPreviousTime = now; + this->animationFrame36PreviousTime = now; this->viewportState.isZoomedOutUnk = 0; this->DAT_MapEditorDisplayLayer = 0; - this->unknownCounterUntil_0x20 = 0; - this->unknownCounterUntil_0x200 = 0; - this->unknownCounterUntil_0x24 = 0; - this->field_0x18b764 = 0; - this->unknownCounterUntil_0x10 = 0; + this->animationFrame32 = 0; + this->animationFrame512 = 0; + this->animationFrame36 = 0; + this->slowAnimationTicked = FALSE; + this->animationFrame16 = 0; this->viewportState.field_0x94 = 0; - this->interval_03_160 = 160; - this->interval_04_180 = 180; - this->interval_01_80 = 80; - this->interval_02_100 = 100; + this->animationFrame36Interval = 160; + this->slowAnimationInterval = 180; + this->animationFrame16Interval = 80; + this->animationFrame32Interval = 100; this->availableFloaterIndex = 1; for (int i = 0; i < countof(this->landscapeAnimationRandomTileArray); ++i) { diff --git a/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp b/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp index 3aef88026f..e993eba710 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp @@ -3,6 +3,7 @@ #include "OpenSHC/OS.func.hpp" #include "OpenSHC/Map/LogicHelpers/Logic1.hpp" #include "OpenSHC/Map/LogicHelpers/Logic2.hpp" +#include "OpenSHC/Map/LogicHelpers/MiscDisplay.hpp" #include "OpenSHC/Map/MapConstants.hpp" #include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" @@ -19,7 +20,7 @@ namespace Rendering { int randomTile = (MACRO_CALL(OpenSHC::OS_Func::_rand)() << 15 | MACRO_CALL(OpenSHC::OS_Func::_rand)()) % Map::MC_MAP_TILES_COUNT; if ((DAT_TileMapState::instance.LogicLayer[randomTile] & Map::LogicHelpers::L_SEA) != 0 - && (DAT_TileMapState::instance.MiscDisplayLayer[randomTile] & 0x3c0) == 0 + && (DAT_TileMapState::instance.MiscDisplayLayer[randomTile] & Map::LogicHelpers::MD_SEA_EDGES) == 0 && (DAT_TileMapState::instance.Logic2Layer[randomTile] & Map::LogicHelpers::L2_PLATEAU_HIGH) == 0) { this->landscapeAnimationRandomTileArray[i] = randomTile; this->landscapeSeaWhiteCapsAnimationFrames[i] = 0; diff --git a/src/OpenSHC/Rendering/ViewportRenderState/clearAllFloatingLayerElements.cpp b/src/OpenSHC/Rendering/ViewportRenderState/clearAllFloatingLayerElements.cpp index ece09939f0..19dda40f3d 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/clearAllFloatingLayerElements.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/clearAllFloatingLayerElements.cpp @@ -10,7 +10,7 @@ namespace Rendering { { for (int floaterIndex = 1; floaterIndex < this->availableFloaterIndex; floaterIndex++) { DAT_TileMapState::instance.FloatingLayer[this->floatersArray[floaterIndex].tile] = 0; - this->floatersArray[floaterIndex].id = 0; + this->floatersArray[floaterIndex].nextFloaterID = 0; } this->availableFloaterIndex = 1; } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/createFloatingLayerElement.cpp b/src/OpenSHC/Rendering/ViewportRenderState/createFloatingLayerElement.cpp index ecad642fc4..03890501b6 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/createFloatingLayerElement.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/createFloatingLayerElement.cpp @@ -19,21 +19,21 @@ namespace Rendering { } if (DAT_TileMapState::instance.FloatingLayer[tile] == 0) { - this->floatersArray[newFloaterIndex].id = 0; + this->floatersArray[newFloaterIndex].nextFloaterID = 0; } else { uint floaterID = DAT_TileMapState::instance.FloatingLayer[tile]; if (countof(this->floatersArray) - 1 < floaterID) { return; } - for (; floaterID != 0; floaterID = this->floatersArray[floaterID].id) { + for (; floaterID != 0; floaterID = this->floatersArray[floaterID].nextFloaterID) { if (this->floatersArray[floaterID].imageID == imageID && this->floatersArray[floaterID].gmID == gmID) { return; } } - this->floatersArray[newFloaterIndex].id = DAT_TileMapState::instance.FloatingLayer[tile]; + this->floatersArray[newFloaterIndex].nextFloaterID = DAT_TileMapState::instance.FloatingLayer[tile]; } - DAT_TileMapState::instance.FloatingLayer[tile] = (ushort)newFloaterIndex; + DAT_TileMapState::instance.FloatingLayer[tile] = newFloaterIndex; this->floatersArray[newFloaterIndex].gmID = gmID; this->floatersArray[newFloaterIndex].imageID = imageID; this->floatersArray[newFloaterIndex].originX diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp index fb490af9fe..a2ac9fe4b3 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp @@ -14,7 +14,7 @@ namespace Rendering { // FUNCTION: STRONGHOLDCRUSADER 0x004E3870 void ViewportRenderState::renderBuildingAnimation( - int buildingID, int screenX, int screenY, undefined4 param_4, int clipToBuilding) + int buildingID, int screenX, int screenY, int tile, BOOLEnum clipToBuilding) { if (DAT_BuildingsState::instance.buildings[buildingID].renderAnimation == 0) { return; @@ -22,14 +22,14 @@ namespace Rendering { if (DAT_BuildingsState::instance.buildings[buildingID].animationFrame == 0) { return; } - if (DAT_TileMapState::instance.disableElevationRendering != 0) { + if (DAT_TileMapState::instance.disableElevationRendering != FALSE) { return; } if (DAT_BuildingsState::instance.buildings[buildingID].drawBridgeState1 != 0) { return; } - if (clipToBuilding != 0) { + if (clipToBuilding != FALSE) { MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::temporarySaveMapSurfaceHeightRangeUnk, DAT_TextureRenderCoreObject::ptr) (); @@ -56,7 +56,7 @@ namespace Rendering { DAT_BuildingsState::instance.buildings[buildingID].spriteOffetX + screenX, DAT_BuildingsState::instance.buildings[buildingID].spriteOffetY + screenY); } - if (clipToBuilding != 0) { + if (clipToBuilding != FALSE) { MACRO_CALL_MEMBER( OpenSHC::UI::Rendering::TextureRenderCore_Func::restoreMapSurfaceHeightRangeFromTemporaryUnk, DAT_TextureRenderCoreObject::ptr) diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp index 3adba965c0..2034ba9336 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp @@ -32,7 +32,7 @@ namespace Rendering { MACRO_CALL(OpenSHC::OS_Func::_sprintf) (text, s_Mouse__x_d__y_d__off_d_005ab88c, DAT_ViewportRenderState::instance.viewportState.mouseX, DAT_ViewportRenderState::instance.viewportState.mouseY, - DAT_ViewportRenderState::instance.viewportState.mouseTile); + DAT_ViewportRenderState::instance.viewportState.mouseFlatTile); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) (text, textX, y + 16, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); @@ -51,21 +51,21 @@ namespace Rendering { MACRO_CALL(OpenSHC::OS_Func::_sprintf) (text, s_Logic_Layer___x__x_005ab840, DAT_TileMapState::instance.LogicLayer[this->viewportState.mouseAtomRefFloorTile], - DAT_TileMapState::instance.LogicLayer[this->viewportState.mouseTile]); + DAT_TileMapState::instance.LogicLayer[this->viewportState.mouseFlatTile]); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) (text, textX, y + 80, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) (text, s_Logic2_Layer___x__x_005ab828, - (char)DAT_TileMapState::instance.Logic2Layer[this->viewportState.mouseAtomRefFloorTile], - (char)DAT_TileMapState::instance.Logic2Layer[this->viewportState.mouseTile]); + DAT_TileMapState::instance.Logic2Layer[this->viewportState.mouseAtomRefFloorTile], + DAT_TileMapState::instance.Logic2Layer[this->viewportState.mouseFlatTile]); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) (text, textX + 20, y + 80, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, TRUE, 0); MACRO_CALL(OpenSHC::OS_Func::_sprintf) (text, s_Damage_Layer___d__d_005ab810, - (char)DAT_TileMapState::instance.DamageLayer[this->viewportState.mouseAtomRefFloorTile], - (char)DAT_TileMapState::instance.DamageLayer[this->viewportState.mouseTile]); + DAT_TileMapState::instance.DamageLayer[this->viewportState.mouseAtomRefFloorTile], + DAT_TileMapState::instance.DamageLayer[this->viewportState.mouseFlatTile]); MACRO_CALL_MEMBER(OpenSHC::Text::TextManager_Func::renderTextToScreen, DAT_TextManagerObject::ptr) (text, textX, y + 96, OpenSHC::Text::TTA_LEFT, Colors::COL_FFFFFF, 18, FALSE, 0); } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp index bdf28a68e3..f9fa2c248f 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp @@ -5,6 +5,7 @@ #include "OpenSHC/Game/GameMode2.hpp" #include "OpenSHC/IO/Graphics/GmID.hpp" #include "OpenSHC/Map/Buildings/Building.hpp" +#include "OpenSHC/Map/Buildings/BuildingTargetMarker.hpp" #include "OpenSHC/Map/Buildings/BuildingType.hpp" #include "OpenSHC/Map/Buildings/BuildingTypeShort.hpp" #include "OpenSHC/Map/MapType2.hpp" @@ -36,8 +37,6 @@ namespace Rendering { // FUNCTION: STRONGHOLDCRUSADER 0x004E2AD0 void ViewportRenderState::renderGmOverlayBuilding2(int buildingID, int screenX, int screenY, int tile) { - BuildingTypeShort buildingType; - int heightOffset = 0; if (DAT_BuildingDefinedData::instance .BuildingHeights[DAT_BuildingsState::instance.buildings[buildingID].buildingType] @@ -104,8 +103,8 @@ namespace Rendering { DAT_TileMapState::instance.cursorOverlayAnimationFrame + 296, 0); } } - short const bannerState = DAT_BuildingsState::instance.buildings[buildingID].field_0xc2; - if (bannerState == 1) { + short const targetMarker = DAT_BuildingsState::instance.buildings[buildingID].targetMarker; + if (targetMarker == OpenSHC::Map::Buildings::BTM_UNIT_TARGET) { int const maskImage = DAT_TileMapState::instance.cursorOverlayAnimationFrame + 16; int const overlayImage = DAT_TileMapState::instance.cursorOverlayAnimationFrame; MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGMWithAlphaMask, @@ -115,8 +114,8 @@ namespace Rendering { .BuildingHeights[DAT_BuildingsState::instance.buildings[buildingID].buildingType] - heightOffset - 42, OpenSHC::IO::Graphics::GID_FLOATS_NEW, maskImage, 0); - DAT_BuildingsState::instance.buildings[buildingID].field_0xc2 = 0; - } else if (bannerState == 2) { + DAT_BuildingsState::instance.buildings[buildingID].targetMarker = OpenSHC::Map::Buildings::BTM_NONE; + } else if (targetMarker == OpenSHC::Map::Buildings::BTM_ENGINEER_TARGET) { int const maskImage = DAT_TileMapState::instance.cursorOverlayAnimationFrame + 132; int const overlayImage = DAT_TileMapState::instance.cursorOverlayAnimationFrame + 116; MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGMWithAlphaMask, @@ -126,7 +125,7 @@ namespace Rendering { .BuildingHeights[DAT_BuildingsState::instance.buildings[buildingID].buildingType] - heightOffset - 42, OpenSHC::IO::Graphics::GID_FLOATS_NEW, maskImage, 0); - DAT_BuildingsState::instance.buildings[buildingID].field_0xc2 = 0; + DAT_BuildingsState::instance.buildings[buildingID].targetMarker = OpenSHC::Map::Buildings::BTM_NONE; } } int frame; @@ -536,11 +535,11 @@ namespace Rendering { if (DAT_BuildingsState::instance.buildings[buildingID].animationFrame == 0) { return; } - if (DAT_TileMapState::instance.disableElevationRendering != 0) { + if (DAT_TileMapState::instance.disableElevationRendering != FALSE) { return; } DAT_CurrentlyRenderedSpriteID::instance = (GmID)DAT_BuildingsState::instance.buildings[buildingID].spriteID2; - buildingType = DAT_BuildingsState::instance.buildings[buildingID].buildingType; + BuildingTypeShort buildingType = DAT_BuildingsState::instance.buildings[buildingID].buildingType; DAT_RenderedUnitOwner::instance = 0; if (buildingType == OpenSHC::Map::Buildings::BT_KILLINGPIT && DAT_BuildingsState::instance.buildings[buildingID].owner diff --git a/src/OpenSHC/Rendering/ViewportRenderState/saveFocusTileAndCenterPreview.cpp b/src/OpenSHC/Rendering/ViewportRenderState/saveFocusTileAndCenterPreview.cpp index 83bb327b04..3c26782e18 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/saveFocusTileAndCenterPreview.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/saveFocusTileAndCenterPreview.cpp @@ -8,7 +8,7 @@ namespace Rendering { { MACRO_CALL_MEMBER(OpenSHC::Rendering::ViewportRenderState_Func::updateBuildingPreviewPosition, this) (this->screenPixelWidth / 2 + this->windowX, this->screenPixelHeight / 2 + this->windowY); - this->field_0x18b738 = this->viewportState.mouseTile; + this->field_0x18b738 = this->viewportState.mouseFlatTile; } } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp b/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp index 721cee4d4c..ec2ef92624 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp @@ -9,16 +9,16 @@ namespace OpenSHC { namespace Rendering { // FUNCTION: STRONGHOLDCRUSADER 0x004E26D0 - void ViewportRenderState::scheduleUnitForBatchedRendering(undefined4 unitIDOrStatus, undefined4 drawX, - undefined4 drawY, undefined4 imageID, undefined4 blendStrength, undefined4 gmID, int param_7) + void ViewportRenderState::scheduleUnitForBatchedRendering( + int unitIDOrStatus, int drawX, int drawY, int imageID, int blendStrength, int gmID, int batchesEarlier) { int batch; - if (param_7 == 1) { + if (batchesEarlier == 1) { batch = this->unitBatchedRenderCounterUntil6 + 4; if (Enums::VC_UNIT_BATCH_COUNT < batch) { batch -= Enums::VC_UNIT_BATCH_COUNT; } - } else if (param_7 == 2) { + } else if (batchesEarlier == 2) { batch = this->unitBatchedRenderCounterUntil6 + 3; if (Enums::VC_UNIT_BATCH_COUNT < batch) { batch -= Enums::VC_UNIT_BATCH_COUNT; diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp index 1d5427eb54..d3ce8fe17a 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp @@ -24,9 +24,10 @@ namespace Rendering { int maxViewportX = (((Map::MC_MAP_SIZE_400 - mapBorder) / 2 - this->viewportState.viewportHeight) + 4) * Enums::VC_TILE_PIXEL_WIDTH; - int maxViewportY = ((401 - this->viewportState.viewportWidth) - mapBorder) * Enums::VC_TILE_ROW_PIXEL_HEIGHT; + int maxViewportY = ((Map::MC_MAP_SIZE_400 + 1 - this->viewportState.viewportWidth) - mapBorder) + * Enums::VC_TILE_ROW_PIXEL_HEIGHT; int minViewportX = (mapBorder / 2 + 1) * Enums::VC_TILE_PIXEL_WIDTH; - int minViewportY = mapBorder * Enums::VC_TILE_ROW_PIXEL_HEIGHT + 16; + int minViewportY = mapBorder * Enums::VC_TILE_ROW_PIXEL_HEIGHT + Enums::VC_TILE_PIXEL_HEIGHT; if (this->viewportState.isZoomedOutUnk != 0) { minViewportX = (mapBorder / 2 - 4) * Enums::VC_TILE_PIXEL_WIDTH; } @@ -57,8 +58,8 @@ namespace Rendering { this->viewportState.viewportY = maxViewportY - Enums::VC_TILE_ROW_PIXEL_HEIGHT; } } else if (DAT_TileMapState::instance.mapOrientation == Map::MC_MAP_EAST) { - if (this->viewportState.viewportX < minViewportX + 16) { - this->viewportState.viewportX = minViewportX + 16; + if (this->viewportState.viewportX < minViewportX + Enums::VC_TILE_PIXEL_WIDTH / 2) { + this->viewportState.viewportX = minViewportX + Enums::VC_TILE_PIXEL_WIDTH / 2; } if (this->viewportState.viewportY > maxViewportY - Enums::VC_TILE_ROW_PIXEL_HEIGHT) { this->viewportState.viewportY = maxViewportY - Enums::VC_TILE_ROW_PIXEL_HEIGHT; @@ -82,16 +83,20 @@ namespace Rendering { if (this->viewportState.isZoomedOutUnk == 0) { this->viewportState.currentCameraOffsetX - = (DAT_ViewportRenderState::instance.viewportState.viewportX & 0x1f) + 150; + = (DAT_ViewportRenderState::instance.viewportState.viewportX & (Enums::VC_TILE_PIXEL_WIDTH - 1)) + + Enums::VC_MAP_SURFACE_MARGIN_X; this->viewportState.currentCameraOffsetY - = (DAT_ViewportRenderState::instance.viewportState.viewportY & 0xf) + 8; + = (DAT_ViewportRenderState::instance.viewportState.viewportY & (Enums::VC_TILE_PIXEL_HEIGHT - 1)) + + Enums::VC_TILE_ROW_PIXEL_HEIGHT; } else { - this->viewportState.currentCameraOffsetX - = (DAT_ViewportRenderState::instance.viewportState.viewportX >> 1 & 0xf) + 150; - this->viewportState.currentCameraOffsetY - = (DAT_ViewportRenderState::instance.viewportState.viewportY >> 1 & 7) + 8; + this->viewportState.currentCameraOffsetX = (DAT_ViewportRenderState::instance.viewportState.viewportX >> 1 + & (Enums::VC_TILE_PIXEL_WIDTH / 2 - 1)) + + Enums::VC_MAP_SURFACE_MARGIN_X; + this->viewportState.currentCameraOffsetY = (DAT_ViewportRenderState::instance.viewportState.viewportY >> 1 + & (Enums::VC_TILE_PIXEL_HEIGHT / 2 - 1)) + + Enums::VC_TILE_ROW_PIXEL_HEIGHT; } - this->viewportState.currentCameraOffsetY += 8; + this->viewportState.currentCameraOffsetY += Enums::VC_TILE_ROW_PIXEL_HEIGHT; } } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp index abb64575a8..4678d5edb3 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp @@ -11,14 +11,14 @@ namespace Rendering { this->viewportState.mouseTileX = 0; for (this->viewportState.mouseTileY = 0; this->viewportState.mouseTileY < Map::MC_MAP_XY_LIMIT; this->viewportState.mouseTileY++) { - if (this->viewportState.mouseTile + if (this->viewportState.mouseFlatTile < this->translationMatrix[this->viewportState.mouseTileY + 1].firstTileOfRow) { break; } } - this->viewportState.mouseTileX - = this->viewportState.mouseTile - this->translationMatrix[this->viewportState.mouseTileY].firstTileOfRow; + this->viewportState.mouseTileX = this->viewportState.mouseFlatTile + - this->translationMatrix[this->viewportState.mouseTileY].firstTileOfRow; this->viewportState.mouseTileX += this->translationMatrix[this->viewportState.mouseTileY].distanceToCenter; } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/updateWaterAnimationFrames.cpp b/src/OpenSHC/Rendering/ViewportRenderState/updateWaterAnimationFrames.cpp index 9ef2dfedeb..722b29bcf2 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/updateWaterAnimationFrames.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/updateWaterAnimationFrames.cpp @@ -8,40 +8,40 @@ namespace Rendering { { DWORD now = timeGetTime(); - this->field_0x18b764 = 0; - if ((int)(now - this->previousIntervalTime_04) >= this->interval_04_180) { - this->previousIntervalTime_04 = now; - this->field_0x18b764 = 1; + this->slowAnimationTicked = FALSE; + if ((int)(now - this->slowAnimationPreviousTime) >= this->slowAnimationInterval) { + this->slowAnimationPreviousTime = now; + this->slowAnimationTicked = TRUE; for (int i = 0; i < countof(this->landscapeSeaWhiteCapsAnimationFrames); ++i) { this->landscapeSeaWhiteCapsAnimationFrames[i]++; } } - if ((int)(now - this->previousIntervalTime_01) >= this->interval_01_80) { - this->previousIntervalTime_01 = now; - this->unknownCounterUntil_0x10++; - if (this->unknownCounterUntil_0x10 >= 16) { - this->unknownCounterUntil_0x10 = 0; + if ((int)(now - this->animationFrame16PreviousTime) >= this->animationFrame16Interval) { + this->animationFrame16PreviousTime = now; + this->animationFrame16++; + if (this->animationFrame16 >= 16) { + this->animationFrame16 = 0; } } - if ((int)(now - this->previousIntervalTime_02) >= this->interval_02_100) { - this->previousIntervalTime_02 = now; - this->unknownCounterUntil_0x20++; - if (this->unknownCounterUntil_0x20 >= 32) { - this->unknownCounterUntil_0x20 = 0; + if ((int)(now - this->animationFrame32PreviousTime) >= this->animationFrame32Interval) { + this->animationFrame32PreviousTime = now; + this->animationFrame32++; + if (this->animationFrame32 >= 32) { + this->animationFrame32 = 0; } } - if ((int)(now - this->previousIntervalTime_03) >= this->interval_03_160) { - this->previousIntervalTime_03 = now; - this->unknownCounterUntil_0x24++; - if (this->unknownCounterUntil_0x24 >= 36) { - this->unknownCounterUntil_0x24 = 0; + if ((int)(now - this->animationFrame36PreviousTime) >= this->animationFrame36Interval) { + this->animationFrame36PreviousTime = now; + this->animationFrame36++; + if (this->animationFrame36 >= 36) { + this->animationFrame36 = 0; } - this->unknownCounterUntil_0x200++; - if (this->unknownCounterUntil_0x200 >= 512) { - this->unknownCounterUntil_0x200 = 0; + this->animationFrame512++; + if (this->animationFrame512 >= 512) { + this->animationFrame512 = 0; } } } From 4b58b9ee85591430065bca8d27e78e3866362cea Mon Sep 17 00:00:00 2001 From: Gynt Date: Sun, 15 Nov 2026 22:30:44 +0100 Subject: [PATCH 12/13] style(ViewportRenderState): BuildingTargetMarker from Map::Buildings::Enums Main's Ghidra sync moved the enum into Map/Buildings/Enums. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01XmXCmb1ZyWXFVVKYYu4FWo --- .../ViewportRenderState/renderGmOverlayBuilding2.cpp | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp index f9fa2c248f..bbeb71daa5 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp @@ -5,9 +5,9 @@ #include "OpenSHC/Game/GameMode2.hpp" #include "OpenSHC/IO/Graphics/GmID.hpp" #include "OpenSHC/Map/Buildings/Building.hpp" -#include "OpenSHC/Map/Buildings/BuildingTargetMarker.hpp" #include "OpenSHC/Map/Buildings/BuildingType.hpp" #include "OpenSHC/Map/Buildings/BuildingTypeShort.hpp" +#include "OpenSHC/Map/Buildings/Enums/BuildingTargetMarker.hpp" #include "OpenSHC/Map/MapType2.hpp" #include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" #include "OpenSHC/UI/Enums/MenuViewType.hpp" @@ -104,7 +104,7 @@ namespace Rendering { } } short const targetMarker = DAT_BuildingsState::instance.buildings[buildingID].targetMarker; - if (targetMarker == OpenSHC::Map::Buildings::BTM_UNIT_TARGET) { + if (targetMarker == OpenSHC::Map::Buildings::Enums::BTM_UNIT_TARGET) { int const maskImage = DAT_TileMapState::instance.cursorOverlayAnimationFrame + 16; int const overlayImage = DAT_TileMapState::instance.cursorOverlayAnimationFrame; MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGMWithAlphaMask, @@ -114,8 +114,9 @@ namespace Rendering { .BuildingHeights[DAT_BuildingsState::instance.buildings[buildingID].buildingType] - heightOffset - 42, OpenSHC::IO::Graphics::GID_FLOATS_NEW, maskImage, 0); - DAT_BuildingsState::instance.buildings[buildingID].targetMarker = OpenSHC::Map::Buildings::BTM_NONE; - } else if (targetMarker == OpenSHC::Map::Buildings::BTM_ENGINEER_TARGET) { + DAT_BuildingsState::instance.buildings[buildingID].targetMarker + = OpenSHC::Map::Buildings::Enums::BTM_NONE; + } else if (targetMarker == OpenSHC::Map::Buildings::Enums::BTM_ENGINEER_TARGET) { int const maskImage = DAT_TileMapState::instance.cursorOverlayAnimationFrame + 132; int const overlayImage = DAT_TileMapState::instance.cursorOverlayAnimationFrame + 116; MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::renderGMWithAlphaMask, @@ -125,7 +126,8 @@ namespace Rendering { .BuildingHeights[DAT_BuildingsState::instance.buildings[buildingID].buildingType] - heightOffset - 42, OpenSHC::IO::Graphics::GID_FLOATS_NEW, maskImage, 0); - DAT_BuildingsState::instance.buildings[buildingID].targetMarker = OpenSHC::Map::Buildings::BTM_NONE; + DAT_BuildingsState::instance.buildings[buildingID].targetMarker + = OpenSHC::Map::Buildings::Enums::BTM_NONE; } } int frame; From b51d31d14e2e57b0949ccb8671374a944faf01e0 Mon Sep 17 00:00:00 2001 From: Gynt Date: Sun, 15 Nov 2026 22:49:01 +0100 Subject: [PATCH 13/13] style(ViewportRenderState): short-form boolean tests Tested as booleans (style guide rule 5), every store checked in the original binary where the field is not already BOOLEnum: - disableElevationRendering, clipToBuilding: BOOLEnum. - Building::useOffsetGraphics, displayOwnerFlag: only ever stored 0/1. - ViewportState::isZoomedOutUnk: a toggle, short form already on main. - DAT_BinaryTileMap400x400: filled by setTileSystemMemoryLookupArrays with SETG, cleared to 0 here. - Bitmask tests in assignRandomTiles and tweakValidTilesToExcludeMapBorders. Counters, image frames, IDs, renderAnimation (also stored 2) and drawBridgeState1 (2, 3) keep their comparisons. Co-Authored-By: Claude Opus 5.5 (1M context) Claude-Session: https://claude.ai/code/session_01XmXCmb1ZyWXFVVKYYu4FWo --- .../ViewportRenderState/assignRandomTiles.cpp | 6 +++--- .../renderBuildingAnimation.cpp | 8 ++++---- .../renderGmOverlayBuilding2.cpp | 18 +++++++++--------- .../setViewportBasedOnMapSize.cpp | 6 +++--- .../tweakValidTilesToExcludeMapBorders.cpp | 7 +++---- .../ViewportRenderState/xyAreValid.cpp | 2 +- 6 files changed, 23 insertions(+), 24 deletions(-) diff --git a/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp b/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp index e993eba710..f156390f94 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp @@ -19,9 +19,9 @@ namespace Rendering { if (this->landscapeAnimationRandomTileArray[i] == 0) { int randomTile = (MACRO_CALL(OpenSHC::OS_Func::_rand)() << 15 | MACRO_CALL(OpenSHC::OS_Func::_rand)()) % Map::MC_MAP_TILES_COUNT; - if ((DAT_TileMapState::instance.LogicLayer[randomTile] & Map::LogicHelpers::L_SEA) != 0 - && (DAT_TileMapState::instance.MiscDisplayLayer[randomTile] & Map::LogicHelpers::MD_SEA_EDGES) == 0 - && (DAT_TileMapState::instance.Logic2Layer[randomTile] & Map::LogicHelpers::L2_PLATEAU_HIGH) == 0) { + if ((DAT_TileMapState::instance.LogicLayer[randomTile] & Map::LogicHelpers::L_SEA) + && !(DAT_TileMapState::instance.MiscDisplayLayer[randomTile] & Map::LogicHelpers::MD_SEA_EDGES) + && !(DAT_TileMapState::instance.Logic2Layer[randomTile] & Map::LogicHelpers::L2_PLATEAU_HIGH)) { this->landscapeAnimationRandomTileArray[i] = randomTile; this->landscapeSeaWhiteCapsAnimationFrames[i] = 0; } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp index a2ac9fe4b3..6ba7cc3c25 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp @@ -22,20 +22,20 @@ namespace Rendering { if (DAT_BuildingsState::instance.buildings[buildingID].animationFrame == 0) { return; } - if (DAT_TileMapState::instance.disableElevationRendering != FALSE) { + if (DAT_TileMapState::instance.disableElevationRendering) { return; } if (DAT_BuildingsState::instance.buildings[buildingID].drawBridgeState1 != 0) { return; } - if (clipToBuilding != FALSE) { + if (clipToBuilding) { MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::temporarySaveMapSurfaceHeightRangeUnk, DAT_TextureRenderCoreObject::ptr) (); MACRO_CALL_MEMBER(OpenSHC::UI::Rendering::TextureRenderCore_Func::setMapSurfaceHeightRange, DAT_TextureRenderCoreObject::ptr) - ((screenY - 39 < 0) ? 0 : screenY - 39, Enums::VC_MAP_SURFACE_HEIGHT); + (screenY - 39 < 0 ? 0 : screenY - 39, Enums::VC_MAP_SURFACE_HEIGHT); } DAT_RenderedUnitOwner::instance = DAT_BuildingsState::instance.buildings[buildingID].playerColorUnk; @@ -56,7 +56,7 @@ namespace Rendering { DAT_BuildingsState::instance.buildings[buildingID].spriteOffetX + screenX, DAT_BuildingsState::instance.buildings[buildingID].spriteOffetY + screenY); } - if (clipToBuilding != FALSE) { + if (clipToBuilding) { MACRO_CALL_MEMBER( OpenSHC::UI::Rendering::TextureRenderCore_Func::restoreMapSurfaceHeightRangeFromTemporaryUnk, DAT_TextureRenderCoreObject::ptr) diff --git a/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp b/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp index bbeb71daa5..a54c7848b5 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp @@ -131,7 +131,7 @@ namespace Rendering { } } int frame; - if (DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics == 0) { + if (!DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics) { switch (DAT_BuildingsState::instance.buildings[buildingID].buildingType) { case OpenSHC::Map::Buildings::BT_GATEHOUSELARGE: if (5 @@ -519,9 +519,9 @@ namespace Rendering { } } } - if ((DAT_BuildingsState::instance.buildings[buildingID].displayOwnerFlag != 0) - && (DAT_BuildingsState::instance.buildings[buildingID].buildingType - == OpenSHC::Map::Buildings::BT_OXTETHER)) { + if (DAT_BuildingsState::instance.buildings[buildingID].displayOwnerFlag + && DAT_BuildingsState::instance.buildings[buildingID].buildingType + == OpenSHC::Map::Buildings::BT_OXTETHER) { DAT_RenderedUnitOwner::instance = DAT_BuildingsState::instance.buildings[buildingID].playerColorUnk; frame = DAT_BuildingsState::instance.buildings[buildingID].overlayImageID; DAT_CurrentlyRenderedSpriteID::instance = OpenSHC::IO::Graphics::GID_ANIM_FLAG_SMALL; @@ -537,7 +537,7 @@ namespace Rendering { if (DAT_BuildingsState::instance.buildings[buildingID].animationFrame == 0) { return; } - if (DAT_TileMapState::instance.disableElevationRendering != FALSE) { + if (DAT_TileMapState::instance.disableElevationRendering) { return; } DAT_CurrentlyRenderedSpriteID::instance = (GmID)DAT_BuildingsState::instance.buildings[buildingID].spriteID2; @@ -561,7 +561,7 @@ namespace Rendering { } buildingType = DAT_BuildingsState::instance.buildings[buildingID].buildingType; if (buildingType == OpenSHC::Map::Buildings::BT_TOWER2) { - if (DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics == 0) { + if (!DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics) { int frame = DAT_BuildingsState::instance.buildings[buildingID].extraAnimationSprite2; if (frame != 0) { MACRO_CALL_MEMBER( @@ -576,7 +576,7 @@ namespace Rendering { } } } else if (buildingType == OpenSHC::Map::Buildings::BT_TOWER3) { - if (DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics == 0) { + if (!DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics) { int frame = DAT_BuildingsState::instance.buildings[buildingID].extraAnimationSprite2; if (frame != 0) { MACRO_CALL_MEMBER( @@ -591,7 +591,7 @@ namespace Rendering { } } } else if (buildingType == OpenSHC::Map::Buildings::BT_TOWER4) { - if (DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics == 0) { + if (!DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics) { int frame = DAT_BuildingsState::instance.buildings[buildingID].extraAnimationSprite2; if (frame != 0) { MACRO_CALL_MEMBER( @@ -606,7 +606,7 @@ namespace Rendering { } } } else if (buildingType == OpenSHC::Map::Buildings::BT_TOWER5) { - if (DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics == 0) { + if (!DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics) { int frame = DAT_BuildingsState::instance.buildings[buildingID].extraAnimationSprite2; if (frame != 0) { MACRO_CALL_MEMBER( diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp index d3ce8fe17a..29926bbf8c 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp @@ -28,7 +28,7 @@ namespace Rendering { * Enums::VC_TILE_ROW_PIXEL_HEIGHT; int minViewportX = (mapBorder / 2 + 1) * Enums::VC_TILE_PIXEL_WIDTH; int minViewportY = mapBorder * Enums::VC_TILE_ROW_PIXEL_HEIGHT + Enums::VC_TILE_PIXEL_HEIGHT; - if (this->viewportState.isZoomedOutUnk != 0) { + if (this->viewportState.isZoomedOutUnk) { minViewportX = (mapBorder / 2 - 4) * Enums::VC_TILE_PIXEL_WIDTH; } @@ -69,7 +69,7 @@ namespace Rendering { if (DAT_TileMapState::instance.mapSize == Map::MC_MAP_SIZE_160 && DAT_WindowAndDirectDraw::instance.currentGameResolution == OpenSHC::Rendering::SRE_1024x768 - && this->viewportState.isZoomedOutUnk != 0) { + && this->viewportState.isZoomedOutUnk) { minViewportY -= 10; maxViewportY -= 10; } @@ -81,7 +81,7 @@ namespace Rendering { this->viewportState.viewportY = (minViewportY - maxViewportY) / 2 + maxViewportY; } - if (this->viewportState.isZoomedOutUnk == 0) { + if (!this->viewportState.isZoomedOutUnk) { this->viewportState.currentCameraOffsetX = (DAT_ViewportRenderState::instance.viewportState.viewportX & (Enums::VC_TILE_PIXEL_WIDTH - 1)) + Enums::VC_MAP_SURFACE_MARGIN_X; diff --git a/src/OpenSHC/Rendering/ViewportRenderState/tweakValidTilesToExcludeMapBorders.cpp b/src/OpenSHC/Rendering/ViewportRenderState/tweakValidTilesToExcludeMapBorders.cpp index f22164afb6..4af749e13d 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/tweakValidTilesToExcludeMapBorders.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/tweakValidTilesToExcludeMapBorders.cpp @@ -13,14 +13,13 @@ namespace Rendering { { for (int y = 0; y < Map::MC_MAP_XY_LIMIT; y++) { for (int x = 0; x < Map::MC_MAP_XY_LIMIT; x++) { - if (this->DAT_BinaryTileMap400x400[y * Map::MC_MAP_XY_LIMIT + x] == 0) { + if (!this->DAT_BinaryTileMap400x400[y * Map::MC_MAP_XY_LIMIT + x]) { continue; } int tile = this->translationMatrix[y].addXgetTile + x; this->tileTranslationMatrix_YComponent[tile] = (short)y; - if ((DAT_TileMapState::instance.LogicLayer[tile] - & (Map::LogicHelpers::L_BORDER | Map::LogicHelpers::L_BORDER_EDGE)) - != 0) { + if (DAT_TileMapState::instance.LogicLayer[tile] + & (Map::LogicHelpers::L_BORDER | Map::LogicHelpers::L_BORDER_EDGE)) { this->DAT_BinaryTileMap400x400[y * Map::MC_MAP_XY_LIMIT + x] = 0; } } diff --git a/src/OpenSHC/Rendering/ViewportRenderState/xyAreValid.cpp b/src/OpenSHC/Rendering/ViewportRenderState/xyAreValid.cpp index 8adc8ce448..74449a56cc 100644 --- a/src/OpenSHC/Rendering/ViewportRenderState/xyAreValid.cpp +++ b/src/OpenSHC/Rendering/ViewportRenderState/xyAreValid.cpp @@ -12,7 +12,7 @@ namespace Rendering { BOOLEnum ViewportRenderState::xyAreValid(uint x, uint y) { return x <= OpenSHC::Map::MC_MAP_XY_LIMIT_MIN_1 && y <= OpenSHC::Map::MC_MAP_XY_LIMIT_MIN_1 - && this->DAT_BinaryTileMap400x400[y * OpenSHC::Map::MC_MAP_XY_LIMIT + x] != 0; + && this->DAT_BinaryTileMap400x400[y * OpenSHC::Map::MC_MAP_XY_LIMIT + x]; } }