diff --git a/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp b/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp new file mode 100644 index 0000000000..e938c2822b --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/Constructor_ViewportRenderState.cpp @@ -0,0 +1,43 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E1FA0 + ViewportRenderState* ViewportRenderState::Constructor_ViewportRenderState() + { + this->viewportState.viewportX = Enums::VC_TILE_PIXEL_WIDTH; + this->viewportState.viewportY = Enums::VC_TILE_ROW_PIXEL_HEIGHT; + this->viewportState.previousMouseTile = -1; + + DWORD now = timeGetTime(); + this->animationFrame32PreviousTime = now; + this->animationFrame16PreviousTime = now; + this->slowAnimationPreviousTime = now; + this->animationFrame36PreviousTime = now; + + this->viewportState.isZoomedOutUnk = 0; + this->DAT_MapEditorDisplayLayer = 0; + this->animationFrame32 = 0; + this->animationFrame512 = 0; + this->animationFrame36 = 0; + this->slowAnimationTicked = FALSE; + this->animationFrame16 = 0; + this->viewportState.field_0x94 = 0; + + this->animationFrame36Interval = 160; + this->slowAnimationInterval = 180; + this->animationFrame16Interval = 80; + this->animationFrame32Interval = 100; + this->availableFloaterIndex = 1; + + 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 new file mode 100644 index 0000000000..f156390f94 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/assignRandomTiles.cpp @@ -0,0 +1,35 @@ +#include "../ViewportRenderState.func.hpp" + +#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" + +#include "OpenSHC/Globals/DAT_TileMapState.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E5B80 + void ViewportRenderState::assignRandomTiles() + { + 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)()) + % Map::MC_MAP_TILES_COUNT; + 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; + } + } else if (Enums::VC_SEA_WHITE_CAP_FRAME_COUNT <= 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..19dda40f3d --- /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].nextFloaterID = 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..03890501b6 --- /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 (countof(this->floatersArray) <= this->availableFloaterIndex) { + return; + } + + if (DAT_TileMapState::instance.FloatingLayer[tile] == 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].nextFloaterID) { + if (this->floatersArray[floaterID].imageID == imageID && this->floatersArray[floaterID].gmID == gmID) { + return; + } + } + this->floatersArray[newFloaterIndex].nextFloaterID = DAT_TileMapState::instance.FloatingLayer[tile]; + } + + DAT_TileMapState::instance.FloatingLayer[tile] = 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++; + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp b/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp new file mode 100644 index 0000000000..3269a1e769 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/focusOnTile.cpp @@ -0,0 +1,49 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/Map/MapConstants.hpp" +#include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" + +#include "OpenSHC/Globals/DAT_TileMapState.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E5E20 + void ViewportRenderState::focusOnTile(int tile) + { + int screenPointIndex = Enums::VC_SCREEN_POINT_TABLE_START; + 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 == Map::MC_MAP_SOUTH) { + screenPointIndex = Enums::VC_SCREEN_POINT_TABLE_START + 2 * Enums::VC_SCREEN_POINT_TABLE_SIZE; + } else if (DAT_TileMapState::instance.mapOrientation == Map::MC_MAP_EAST) { + screenPointIndex = Enums::VC_SCREEN_POINT_TABLE_START + 3 * Enums::VC_SCREEN_POINT_TABLE_SIZE; + } + } + + int rowLength = Enums::VC_SCREEN_POINT_LONG_ROW; + int tileX = 0; + int tileY; + bool found = false; + 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++; + } + if (found) { + break; + } + } + + 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 new file mode 100644 index 0000000000..6ba7cc3c25 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderBuildingAnimation.cpp @@ -0,0 +1,68 @@ +#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" +#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, int tile, BOOLEnum clipToBuilding) + { + if (DAT_BuildingsState::instance.buildings[buildingID].renderAnimation == 0) { + return; + } + if (DAT_BuildingsState::instance.buildings[buildingID].animationFrame == 0) { + return; + } + if (DAT_TileMapState::instance.disableElevationRendering) { + return; + } + if (DAT_BuildingsState::instance.buildings[buildingID].drawBridgeState1 != 0) { + return; + } + + 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); + } + + 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) { + 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..2034ba9336 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderDebugDataMousePointing.cpp @@ -0,0 +1,74 @@ +#include "../ViewportRenderState.func.hpp" + +#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" +#include "OpenSHC/string-literals.hpp" + +#include "OpenSHC/Globals/DAT_TextManagerObject.hpp" +#include "OpenSHC/Globals/DAT_TileMapState.hpp" +#include "OpenSHC/Globals/DAT_ViewportRenderState.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]; + + int textX = x + 2; + + MACRO_CALL(OpenSHC::OS_Func::_sprintf) + (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, s_Mouse__x_d__y_d__off_d_005ab88c, DAT_ViewportRenderState::instance.viewportState.mouseX, + DAT_ViewportRenderState::instance.viewportState.mouseY, + 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); + + MACRO_CALL(OpenSHC::OS_Func::_sprintf) + (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, 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, s_Logic_Layer___x__x_005ab840, + DAT_TileMapState::instance.LogicLayer[this->viewportState.mouseAtomRefFloorTile], + 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, + 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, + 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 new file mode 100644 index 0000000000..a54c7848b5 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/renderGmOverlayBuilding2.cpp @@ -0,0 +1,650 @@ +#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/Buildings/Enums/BuildingTargetMarker.hpp" +#include "OpenSHC/Map/MapType2.hpp" +#include "OpenSHC/Rendering/Enums/ViewportConstants.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) + { + 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 targetMarker = DAT_BuildingsState::instance.buildings[buildingID].targetMarker; + 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, + 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].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, + 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].targetMarker + = OpenSHC::Map::Buildings::Enums::BTM_NONE; + } + } + int frame; + if (!DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics) { + 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 + && 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; + 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) { + return; + } + DAT_CurrentlyRenderedSpriteID::instance = (GmID)DAT_BuildingsState::instance.buildings[buildingID].spriteID2; + 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 + != 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, Enums::VC_MAP_SURFACE_HEIGHT); + } + } + buildingType = DAT_BuildingsState::instance.buildings[buildingID].buildingType; + if (buildingType == OpenSHC::Map::Buildings::BT_TOWER2) { + if (!DAT_BuildingsState::instance.buildings[buildingID].useOffsetGraphics) { + 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) { + 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) { + 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) { + 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/resetupViewport.cpp b/src/OpenSHC/Rendering/ViewportRenderState/resetupViewport.cpp new file mode 100644 index 0000000000..2e52bac849 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/resetupViewport.cpp @@ -0,0 +1,40 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/Rendering/Enums/ViewportConstants.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 * 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 + || 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 * 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/saveFocusTileAndCenterPreview.cpp b/src/OpenSHC/Rendering/ViewportRenderState/saveFocusTileAndCenterPreview.cpp new file mode 100644 index 0000000000..3c26782e18 --- /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.mouseFlatTile; + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp b/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp new file mode 100644 index 0000000000..ec2ef92624 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/scheduleUnitForBatchedRendering.cpp @@ -0,0 +1,100 @@ +#include "../ViewportRenderState.func.hpp" + +#include "OpenSHC/Rendering/Enums/ViewportConstants.hpp" + +#include "OpenSHC/Globals/DAT_CurrentlyRenderedSpriteID.hpp" +#include "OpenSHC/Globals/DAT_RenderedUnitOwner.hpp" + +namespace OpenSHC { +namespace Rendering { + + // FUNCTION: STRONGHOLDCRUSADER 0x004E26D0 + void ViewportRenderState::scheduleUnitForBatchedRendering( + int unitIDOrStatus, int drawX, int drawY, int imageID, int blendStrength, int gmID, int batchesEarlier) + { + int batch; + if (batchesEarlier == 1) { + batch = this->unitBatchedRenderCounterUntil6 + 4; + if (Enums::VC_UNIT_BATCH_COUNT < batch) { + batch -= Enums::VC_UNIT_BATCH_COUNT; + } + } else if (batchesEarlier == 2) { + batch = this->unitBatchedRenderCounterUntil6 + 3; + if (Enums::VC_UNIT_BATCH_COUNT < batch) { + batch -= Enums::VC_UNIT_BATCH_COUNT; + } + } else { + batch = this->unitBatchedRenderCounterUntil6; + } + + switch (batch) { + case 1: + 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; + 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++; + } + break; + case 2: + 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; + 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++; + } + break; + case 3: + 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; + 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++; + } + break; + case 4: + 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; + 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++; + } + break; + case 5: + 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; + 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++; + } + break; + } + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp new file mode 100644 index 0000000000..29926bbf8c --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/setViewportBasedOnMapSize.cpp @@ -0,0 +1,103 @@ +#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" +#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 = Map::MC_MAP_SIZE_400 - DAT_TileMapState::instance.mapSize; + if (mapBorder == Map::MC_MAP_SIZE_400) { + mapBorder = 0; + } + mapBorder /= 2; + + int maxViewportX = (((Map::MC_MAP_SIZE_400 - mapBorder) / 2 - this->viewportState.viewportHeight) + 4) + * Enums::VC_TILE_PIXEL_WIDTH; + 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 + Enums::VC_TILE_PIXEL_HEIGHT; + if (this->viewportState.isZoomedOutUnk) { + minViewportX = (mapBorder / 2 - 4) * Enums::VC_TILE_PIXEL_WIDTH; + } + + 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 != 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 == 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 == Map::MC_MAP_EAST) { + 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; + } + } + } + + if (DAT_TileMapState::instance.mapSize == Map::MC_MAP_SIZE_160 + && DAT_WindowAndDirectDraw::instance.currentGameResolution == OpenSHC::Rendering::SRE_1024x768 + && this->viewportState.isZoomedOutUnk) { + minViewportY -= 10; + 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) { + this->viewportState.currentCameraOffsetX + = (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 & (Enums::VC_TILE_PIXEL_HEIGHT - 1)) + + Enums::VC_TILE_ROW_PIXEL_HEIGHT; + } else { + 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 += Enums::VC_TILE_ROW_PIXEL_HEIGHT; + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY.cpp new file mode 100644 index 0000000000..8bf979be94 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY.cpp @@ -0,0 +1,26 @@ +#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; + } + +} +} diff --git a/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp new file mode 100644 index 0000000000..4678d5edb3 --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/setupMouseTileXY2.cpp @@ -0,0 +1,26 @@ +#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.mouseFlatTile + < this->translationMatrix[this->viewportState.mouseTileY + 1].firstTileOfRow) { + break; + } + } + + 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/tweakValidTilesToExcludeMapBorders.cpp b/src/OpenSHC/Rendering/ViewportRenderState/tweakValidTilesToExcludeMapBorders.cpp new file mode 100644 index 0000000000..4af749e13d --- /dev/null +++ b/src/OpenSHC/Rendering/ViewportRenderState/tweakValidTilesToExcludeMapBorders.cpp @@ -0,0 +1,30 @@ +#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]) { + 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)) { + 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..722b29bcf2 --- /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->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->animationFrame16PreviousTime) >= this->animationFrame16Interval) { + this->animationFrame16PreviousTime = now; + this->animationFrame16++; + if (this->animationFrame16 >= 16) { + this->animationFrame16 = 0; + } + } + + if ((int)(now - this->animationFrame32PreviousTime) >= this->animationFrame32Interval) { + this->animationFrame32PreviousTime = now; + this->animationFrame32++; + if (this->animationFrame32 >= 32) { + this->animationFrame32 = 0; + } + } + + if ((int)(now - this->animationFrame36PreviousTime) >= this->animationFrame36Interval) { + this->animationFrame36PreviousTime = now; + this->animationFrame36++; + if (this->animationFrame36 >= 36) { + this->animationFrame36 = 0; + } + this->animationFrame512++; + if (this->animationFrame512 >= 512) { + this->animationFrame512 = 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]; } } diff --git a/status/addresses-SHC-3BB0A8C1.txt b/status/addresses-SHC-3BB0A8C1.txt index 3a97b43162..6ec8017690 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 | 100.0% | Reimplemented -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,19 +36971,19 @@ 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 -SHC_3BB0A8C1_0x004E7770 | 0.0% | Pending +SHC_3BB0A8C1_0x004E7770 | 100.0% | Reimplemented SHC_3BB0A8C1_0x004E7800 | 100.0% | Reimplemented @@ -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