diff --git a/Client/mods/deathmatch/logic/CClientGame.cpp b/Client/mods/deathmatch/logic/CClientGame.cpp index 0d057bf424..0e8f9a5249 100644 --- a/Client/mods/deathmatch/logic/CClientGame.cpp +++ b/Client/mods/deathmatch/logic/CClientGame.cpp @@ -551,6 +551,12 @@ CClientGame::~CClientGame() discord->UpdatePresence(); } + if (m_pPlayerMap) + { + m_pPlayerMap->ResetCustomMapImage(); + m_pPlayerMap->ResetMapOpacity(); + } + // Destroy our stuff SAFE_DELETE(m_pManager); // Will trigger onClientResourceStop diff --git a/Client/mods/deathmatch/logic/CPlayerMap.cpp b/Client/mods/deathmatch/logic/CPlayerMap.cpp index fe089cd23b..09acc7ecfc 100644 --- a/Client/mods/deathmatch/logic/CPlayerMap.cpp +++ b/Client/mods/deathmatch/logic/CPlayerMap.cpp @@ -12,6 +12,7 @@ #include "StdInc.h" using SharedUtil::CalcMTASAPath; +using SharedUtil::FileExists; using std::list; enum @@ -61,6 +62,12 @@ CPlayerMap::CPlayerMap(CClientManager* pManager) m_mapImageTexture = nullptr; m_playerMarkerTexture = nullptr; + // Custom map image variables + m_ucCustomMapOpacity = 255; + m_bHasCustomMapOpacity = false; + m_pCustomOpacityResource = nullptr; + m_pRadarMapDisabledResource = nullptr; + // Create all map textures CreateAllTextures(); @@ -109,6 +116,20 @@ CPlayerMap::~CPlayerMap() // Delete our images SAFE_RELEASE(m_mapImageTexture); SAFE_RELEASE(m_playerMarkerTexture); + + // Release custom map textures + for (int i = 0; i < 2; i++) + { + if (m_customMapData[i].bHasCustomMap && m_customMapData[i].pTexture && !m_customMapData[i].pTextureElement) + { + SAFE_RELEASE(m_customMapData[i].pTexture); + } + m_customMapData[i].pTexture = nullptr; + m_customMapData[i].pTextureElement = nullptr; + m_customMapData[i].pResource = nullptr; + m_customMapData[i].bHasCustomMap = false; + } + for (uint i = 0; i < m_markerTextureList.size(); i++) SAFE_RELEASE(m_markerTextureList[i]); m_markerTextureList.clear(); @@ -118,7 +139,7 @@ CPlayerMap::~CPlayerMap() void CPlayerMap::CreateOrUpdateMapTexture() { const std::uint32_t mapSize = MAP_IMAGE_SIZES[m_playerMapImageIndex]; - const SString fileName("MTA\\cgui\\images\\map_%d.png", mapSize); + const SString fileName("MTA\\cgui\\images\\radar\\map_%d.png", mapSize); auto* newTexture = g_pCore->GetGraphics()->GetRenderItemManager()->CreateTexture(CalcMTASAPath(fileName), nullptr, false, mapSize, mapSize, RFORMAT_DXT1); if (!newTexture) @@ -156,6 +177,7 @@ void CPlayerMap::CreateAllTextures() { // Create the map texture m_playerMapImageIndex = g_pCore->GetCVars()->GetValue("mapimage"); + m_defaultMapImageIndex = m_playerMapImageIndex; CreateOrUpdateMapTexture(); // Create the player blip texture @@ -163,6 +185,9 @@ void CPlayerMap::CreateAllTextures() // Create the other marker textures CreateMarkerTextures(); + + // Try to load a user custom map if it exists + LoadUserCustomMapIfExists(); } catch (const std::exception& e) { @@ -292,9 +317,26 @@ void CPlayerMap::DoRender() // Render if showing and textures are all loaded if (isMapShowing && !m_failedToLoadTextures) { + // Check if the current size texture element is still valid + std::size_t currentIdx = m_playerMapImageIndex; + if (m_customMapData[currentIdx].bHasCustomMap && m_customMapData[currentIdx].pTextureElement) + { + if (m_customMapData[currentIdx].pTextureElement->IsBeingDeleted()) + { + // Delete the texture, reset + m_customMapData[currentIdx].pTexture = nullptr; + m_customMapData[currentIdx].bHasCustomMap = false; + m_customMapData[currentIdx].strPath = ""; + m_customMapData[currentIdx].pResource = nullptr; + m_customMapData[currentIdx].pTextureElement = nullptr; + + // Try to load a user custom map if it exists + LoadUserCustomMapIfExists(); + } + } + // Get the alpha value from the settings - int mapAlpha; - g_pCore->GetCVars()->Get("mapalpha", mapAlpha); + uchar mapAlpha = GetMapOpacity(); const SColorARGB mapColor(mapAlpha, 255, 255, 255); // Update the image if the user changed it via a setting @@ -302,10 +344,16 @@ void CPlayerMap::DoRender() if (mapImageIndex != m_playerMapImageIndex) { UpdateOrRevertMapTexture(mapImageIndex); + if (!m_customMapData[m_playerMapImageIndex].bHasCustomMap) + LoadUserCustomMapIfExists(); } - g_pCore->GetGraphics()->DrawTexture(m_mapImageTexture, static_cast(m_iMapMinX), static_cast(m_iMapMinY), - m_fMapSize / m_mapImageTexture->m_uiSizeX, m_fMapSize / m_mapImageTexture->m_uiSizeY, 0.0f, 0.0f, 0.0f, mapColor); + CTextureItem* pMapTexture = m_customMapData[m_playerMapImageIndex].bHasCustomMap + ? m_customMapData[m_playerMapImageIndex].pTexture + : m_mapImageTexture; + + g_pCore->GetGraphics()->DrawTexture(pMapTexture, static_cast(m_iMapMinX), static_cast(m_iMapMinY), + m_fMapSize / pMapTexture->m_uiSizeX, m_fMapSize / pMapTexture->m_uiSizeY, 0.0f, 0.0f, 0.0f, mapColor); // Grab the info for the local player blip CVector2D vecLocalPos; @@ -752,3 +800,164 @@ SString CPlayerMap::GetBoundKeyName(const SString& strCommand) return strCommand; return pCommandBind->boundKey->szKey; } +bool CPlayerMap::SetCustomMapImage(const std::string& strTexturePath, ECustomMapResolution resolution, CResource* pResource) +{ + if (!pResource) + return false; + + std::size_t idx = MapResolutionToIndex(resolution); + std::uint32_t uiSize = MapResolutionToSize(resolution); + SString strFullPath = pResource->GetResourceDirectoryPath() + strTexturePath; + + CTextureItem* pNewTexture = g_pCore->GetGraphics()->GetRenderItemManager()->CreateTexture(strFullPath, nullptr, false, uiSize, uiSize, RFORMAT_DXT1); + + if (!pNewTexture) + throw std::invalid_argument("Failed to load texture from path: " + strTexturePath); + + // Release old texture if it existed and was not element-based + if (!m_customMapData[idx].pTextureElement && m_customMapData[idx].pTexture) + { + SAFE_RELEASE(m_customMapData[idx].pTexture); + m_customMapData[idx].pTexture = nullptr; + } + + m_customMapData[idx].pTexture = pNewTexture; + m_customMapData[idx].strPath = strFullPath; + m_customMapData[idx].bHasCustomMap = true; + m_customMapData[idx].pResource = pResource; + m_customMapData[idx].pTextureElement = nullptr; + + return true; +} + +bool CPlayerMap::SetCustomMapImageFromTexture(CClientTexture* pTexture, ECustomMapResolution resolution, CResource* pResource) +{ + if (!pTexture || !pResource) + return false; + + CTextureItem* pTextureItem = pTexture->GetTextureItem(); + if (!pTextureItem) + throw std::invalid_argument("Invalid texture element"); + + std::size_t idx = MapResolutionToIndex(resolution); + + m_customMapData[idx].pTexture = pTextureItem; + m_customMapData[idx].strPath = ""; + m_customMapData[idx].bHasCustomMap = true; + m_customMapData[idx].pResource = pResource; + m_customMapData[idx].pTextureElement = pTexture; + + return true; +} + +void CPlayerMap::ResetCustomMapImage(std::optional resolution) +{ + // If resolution is not provided, reset both sizes + if (!resolution.has_value()) + { + ResetCustomMapImage(ECustomMapResolution::Res_1024); + ResetCustomMapImage(ECustomMapResolution::Res_2048); + return; + } + + std::size_t idx = MapResolutionToIndex(resolution.value()); + + if (!m_customMapData[idx].pTextureElement && m_customMapData[idx].pTexture) + { + SAFE_RELEASE(m_customMapData[idx].pTexture); + m_customMapData[idx].pTexture = nullptr; + } + + m_customMapData[idx].bHasCustomMap = false; + m_customMapData[idx].strPath = ""; + m_customMapData[idx].pResource = nullptr; + m_customMapData[idx].pTextureElement = nullptr; + + // Try to load the user custom map if it exists + if (idx == m_playerMapImageIndex) + LoadUserCustomMapIfExists(); +} + +bool CPlayerMap::SetMapOpacity(uchar ucOpacity, CResource* pResource) +{ + m_ucCustomMapOpacity = static_cast(Clamp(0, static_cast(ucOpacity), 255)); + m_bHasCustomMapOpacity = true; + m_pCustomOpacityResource = pResource; + return true; +} + +void CPlayerMap::ResetMapOpacity() +{ + m_bHasCustomMapOpacity = false; + m_ucCustomMapOpacity = 255; + m_pCustomOpacityResource = nullptr; +} + +uchar CPlayerMap::GetMapOpacity() const +{ + if (m_bHasCustomMapOpacity) + return m_ucCustomMapOpacity; + + int mapAlpha; + g_pCore->GetCVars()->Get("mapalpha", mapAlpha); + return static_cast(Clamp(0, mapAlpha, 255)); +} + +void CPlayerMap::LoadUserCustomMapIfExists() +{ + std::size_t idx = m_playerMapImageIndex; + + // If already has a script-set custom map for this size, do not override + if (m_customMapData[idx].bHasCustomMap && m_customMapData[idx].pResource != nullptr) + return; + + const std::uint32_t mapSize = MAP_IMAGE_SIZES[idx]; + const SString customFileName = CalcMTASAPath(SString("MTA\\cgui\\images\\radar\\map_%d-custom.png", mapSize)); + + if (FileExists(customFileName)) + { + CTextureItem* pCustomTexture = g_pCore->GetGraphics()->GetRenderItemManager()->CreateTexture(customFileName, nullptr, false, mapSize, mapSize, RFORMAT_DXT1); + + if (pCustomTexture) + { + // Release old texture if it existed and was not element-based + if (!m_customMapData[idx].pTextureElement && m_customMapData[idx].pTexture) + SAFE_RELEASE(m_customMapData[idx].pTexture); + + m_customMapData[idx].pTexture = pCustomTexture; + m_customMapData[idx].strPath = customFileName; + m_customMapData[idx].bHasCustomMap = true; + m_customMapData[idx].pResource = nullptr; + m_customMapData[idx].pTextureElement = nullptr; + } + } +} + +void CPlayerMap::OnResourceStopping(CResource* pResource) +{ + // Check both size custom maps + for (int i = 0; i < 2; i++) + { + if (m_customMapData[i].bHasCustomMap && m_customMapData[i].pResource == pResource) + { + if (!m_customMapData[i].pTextureElement && m_customMapData[i].pTexture) + SAFE_RELEASE(m_customMapData[i].pTexture); + + m_customMapData[i].pTexture = nullptr; + m_customMapData[i].pTextureElement = nullptr; + m_customMapData[i].bHasCustomMap = false; + m_customMapData[i].strPath = ""; + m_customMapData[i].pResource = nullptr; + } + } + + // If the current map size had a custom map, try to load the user custom map + LoadUserCustomMapIfExists(); + + if (m_bHasCustomMapOpacity && m_pCustomOpacityResource == pResource) + { + m_bHasCustomMapOpacity = false; + m_ucCustomMapOpacity = 255; + m_pCustomOpacityResource = nullptr; + } +} diff --git a/Client/mods/deathmatch/logic/CPlayerMap.h b/Client/mods/deathmatch/logic/CPlayerMap.h index d03f40892e..1693402b9a 100644 --- a/Client/mods/deathmatch/logic/CPlayerMap.h +++ b/Client/mods/deathmatch/logic/CPlayerMap.h @@ -16,6 +16,38 @@ #include #include +class CResource; +class CClientTexture; + +enum class ECustomMapResolution : std::uint32_t +{ + Res_1024 = 1024, + Res_2048 = 2048 +}; + +inline std::size_t MapResolutionToIndex(ECustomMapResolution resolution) +{ + return resolution == ECustomMapResolution::Res_1024 ? 0 : 1; +} + +inline std::uint32_t MapResolutionToSize(ECustomMapResolution resolution) +{ + return static_cast(resolution); +} + +inline std::optional UIntToMapResolution(std::uint32_t value) +{ + switch (value) + { + case static_cast(ECustomMapResolution::Res_1024): + return ECustomMapResolution::Res_1024; + case static_cast(ECustomMapResolution::Res_2048): + return ECustomMapResolution::Res_2048; + default: + return std::nullopt; + } +} + class CPlayerMap { public: @@ -37,6 +69,17 @@ class CPlayerMap void ToggleHelpText(); + bool SetCustomMapImage(const std::string& strTexturePath, ECustomMapResolution resolution, CResource* pResource = nullptr); + bool SetCustomMapImageFromTexture(CClientTexture* pTexture, ECustomMapResolution resolution, CResource* pResource = nullptr); + void ResetCustomMapImage(std::optional resolution = std::nullopt); + bool SetMapOpacity(uchar ucOpacity, CResource* pResource = nullptr); + void ResetMapOpacity(); + uchar GetMapOpacity() const; + bool HasCustomMapImage(ECustomMapResolution resolution) const { + return m_customMapData[MapResolutionToIndex(resolution)].bHasCustomMap; + } + void OnResourceStopping(CResource* pResource); + protected: void InternalSetPlayerMapEnabled(bool bEnabled); @@ -46,6 +89,7 @@ class CPlayerMap void CreateOrUpdateMapTexture(); void UpdateOrRevertMapTexture(std::size_t imageIndex); void CreateAllTextures(); + void LoadUserCustomMapIfExists(); public: bool IsAttachedToLocalPlayer() const { return m_bIsAttachedToLocal; }; @@ -125,4 +169,18 @@ class CPlayerMap bool m_bRadarVisible; bool m_bDebugVisible; bool m_bTextVisible; + struct CustomMapData + { + bool bHasCustomMap = false; + CTextureItem* pTexture = nullptr; + std::string strPath = ""; + CClientTexture* pTextureElement = nullptr; + CResource* pResource = nullptr; + }; + CustomMapData m_customMapData[2]; // [0] = 1024, [1] = 2048 + std::size_t m_defaultMapImageIndex; + uchar m_ucCustomMapOpacity; + bool m_bHasCustomMapOpacity; + CResource* m_pCustomOpacityResource; + CResource* m_pRadarMapDisabledResource; }; diff --git a/Client/mods/deathmatch/logic/CResource.cpp b/Client/mods/deathmatch/logic/CResource.cpp index d1d9be1f8e..25024b0567 100644 --- a/Client/mods/deathmatch/logic/CResource.cpp +++ b/Client/mods/deathmatch/logic/CResource.cpp @@ -370,6 +370,14 @@ void CResource::Stop() { m_bStarting = false; m_bStopping = true; + + if (g_pClientGame) + { + CPlayerMap* pPlayerMap = g_pClientGame->GetPlayerMap(); + if (pPlayerMap) + pPlayerMap->OnResourceStopping(this); + } + CLuaArguments Arguments; Arguments.PushResource(this); m_pResourceEntity->CallEvent("onClientResourceStop", Arguments, true); diff --git a/Client/mods/deathmatch/logic/CStaticFunctionDefinitions.cpp b/Client/mods/deathmatch/logic/CStaticFunctionDefinitions.cpp index 6e91ea3b3a..d76f2064e8 100644 --- a/Client/mods/deathmatch/logic/CStaticFunctionDefinitions.cpp +++ b/Client/mods/deathmatch/logic/CStaticFunctionDefinitions.cpp @@ -7997,6 +7997,33 @@ bool CStaticFunctionDefinitions::GetPlayerMapBoundingBox(CVector& vecMin, CVecto return false; } +bool CStaticFunctionDefinitions::SetPlayerMapImage(const std::string& strTexturePath, ECustomMapResolution resolution, CResource* pResource) +{ + return m_pPlayerMap->SetCustomMapImage(strTexturePath, resolution, pResource); +} + +bool CStaticFunctionDefinitions::SetPlayerMapImageFromTexture(CClientTexture* pTexture, ECustomMapResolution resolution, CResource* pResource) +{ + return m_pPlayerMap->SetCustomMapImageFromTexture(pTexture, resolution, pResource); +} + +bool CStaticFunctionDefinitions::ResetPlayerMapImage(std::optional resolution) +{ + m_pPlayerMap->ResetCustomMapImage(resolution); + return true; +} + +bool CStaticFunctionDefinitions::SetPlayerMapOpacity(uchar ucOpacity, CResource* pResource) +{ + return m_pPlayerMap->SetMapOpacity(ucOpacity, pResource); +} + +bool CStaticFunctionDefinitions::ResetPlayerMapOpacity() +{ + m_pPlayerMap->ResetMapOpacity(); + return true; +} + bool CStaticFunctionDefinitions::FxAddBlood(CVector& vecPosition, CVector& vecDirection, int iCount, float fBrightness) { g_pGame->GetFx()->AddBlood(vecPosition, vecDirection, iCount, fBrightness); diff --git a/Client/mods/deathmatch/logic/CStaticFunctionDefinitions.h b/Client/mods/deathmatch/logic/CStaticFunctionDefinitions.h index 766a09a9ff..d20c1b1aac 100644 --- a/Client/mods/deathmatch/logic/CStaticFunctionDefinitions.h +++ b/Client/mods/deathmatch/logic/CStaticFunctionDefinitions.h @@ -724,6 +724,11 @@ class CStaticFunctionDefinitions static bool IsPlayerMapForced(bool& bForced); static bool IsPlayerMapVisible(bool& bVisible); static bool GetPlayerMapBoundingBox(CVector& vecMin, CVector& vecMax); + static bool SetPlayerMapImage(const std::string& strTexturePath, ECustomMapResolution resolution, CResource* pResource); + static bool SetPlayerMapImageFromTexture(CClientTexture* pTexture, ECustomMapResolution resolution, CResource* pResource); + static bool ResetPlayerMapImage(std::optional resolution = std::nullopt); + static bool SetPlayerMapOpacity(uchar ucOpacity, CResource* pResource); + static bool ResetPlayerMapOpacity(); // Fx funcs static bool FxAddBlood(CVector& vecPosition, CVector& vecDirection, int iCount, float fBrightness); diff --git a/Client/mods/deathmatch/logic/luadefs/CLuaPlayerDefs.cpp b/Client/mods/deathmatch/logic/luadefs/CLuaPlayerDefs.cpp index b4813e21a7..49a0c25b27 100644 --- a/Client/mods/deathmatch/logic/luadefs/CLuaPlayerDefs.cpp +++ b/Client/mods/deathmatch/logic/luadefs/CLuaPlayerDefs.cpp @@ -10,6 +10,8 @@ *****************************************************************************/ #include "StdInc.h" +#include "CLuaPlayerDefs.h" +#include "CPlayerMap.h" #include "lua/CLuaFunctionParser.h" void CLuaPlayerDefs::LoadFunctions() @@ -53,6 +55,10 @@ void CLuaPlayerDefs::LoadFunctions() {"isPlayerMapVisible", IsPlayerMapVisible}, {"getPlayerMapBoundingBox", GetPlayerMapBoundingBox}, {"getPlayerMapOpacity", ArgumentParser}, + {"setPlayerMapImage", ArgumentParser}, + {"resetPlayerMapImage", ArgumentParser}, + {"setPlayerMapOpacity", ArgumentParser}, + {"resetPlayerMapOpacity", ArgumentParser}, {"getPlayerHudComponentProperty", ArgumentParser}, }; @@ -78,6 +84,10 @@ void CLuaPlayerDefs::AddClass(lua_State* luaVM) lua_classfunction(luaVM, "forceMap", "forcePlayerMap"); lua_classfunction(luaVM, "isMapForced", "isPlayerMapForced"); lua_classfunction(luaVM, "isMapVisible", "isPlayerMapVisible"); + lua_classfunction(luaVM, "setMapImage", "setPlayerMapImage"); + lua_classfunction(luaVM, "resetMapImage", "resetPlayerMapImage"); + lua_classfunction(luaVM, "setMapOpacity", "setPlayerMapOpacity"); + lua_classfunction(luaVM, "resetMapOpacity", "resetPlayerMapOpacity"); lua_classfunction(luaVM, "isHudComponentVisible", "isPlayerHudComponentVisible"); lua_classfunction(luaVM, "toggleControl", "toggleControl"); lua_classfunction(luaVM, "setHudComponentProperty", "setPlayerHudComponentProperty"); @@ -1053,3 +1063,61 @@ std::variant, CLuaMultiR return false; } + +bool CLuaPlayerDefs::SetPlayerMapImage(lua_State* luaVM, std::variant texturePathOrElement, std::optional size) +{ + CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaVM); + if (!pLuaMain) + return false; + + CResource* pResource = pLuaMain->GetResource(); + + if (!size.has_value()) + return false; + + auto resolution = UIntToMapResolution(size.value()); + if (!resolution.has_value()) + throw std::invalid_argument("Invalid map size (must be 1024 or 2048)"); + + if (std::holds_alternative(texturePathOrElement)) + { + CClientTexture* pTexture = std::get(texturePathOrElement); + return CStaticFunctionDefinitions::SetPlayerMapImageFromTexture(pTexture, resolution.value(), pResource); + } + else + { + std::string strPath = std::get(texturePathOrElement); + return CStaticFunctionDefinitions::SetPlayerMapImage(strPath, resolution.value(), pResource); + } +} + +bool CLuaPlayerDefs::ResetPlayerMapImage(std::optional size) +{ + if (size.has_value()) + { + auto resolution = UIntToMapResolution(*size); + if (!resolution.has_value()) + throw std::invalid_argument("Invalid map size (must be 1024 or 2048)"); + + return CStaticFunctionDefinitions::ResetPlayerMapImage(resolution.value()); + } + else + { + return CStaticFunctionDefinitions::ResetPlayerMapImage(std::nullopt); + } +} + +bool CLuaPlayerDefs::SetPlayerMapOpacity(lua_State* luaVM, uchar opacity) +{ + CLuaMain* pLuaMain = m_pLuaManager->GetVirtualMachine(luaVM); + if (!pLuaMain) + return false; + + CResource* pResource = pLuaMain->GetResource(); + return CStaticFunctionDefinitions::SetPlayerMapOpacity(opacity, pResource); +} + +bool CLuaPlayerDefs::ResetPlayerMapOpacity() +{ + return CStaticFunctionDefinitions::ResetPlayerMapOpacity(); +} diff --git a/Client/mods/deathmatch/logic/luadefs/CLuaPlayerDefs.h b/Client/mods/deathmatch/logic/luadefs/CLuaPlayerDefs.h index 1bc08998a4..d14072f8d1 100644 --- a/Client/mods/deathmatch/logic/luadefs/CLuaPlayerDefs.h +++ b/Client/mods/deathmatch/logic/luadefs/CLuaPlayerDefs.h @@ -55,4 +55,8 @@ class CLuaPlayerDefs : public CLuaDefs LUA_DECLARE(IsPlayerMapVisible); LUA_DECLARE(GetPlayerMapBoundingBox); static unsigned char GetPlayerMapOpacity(); + static bool SetPlayerMapImage(lua_State* luaVM, std::variant texturePathOrElement, std::optional size); + static bool ResetPlayerMapImage(std::optional size); + static bool SetPlayerMapOpacity(lua_State* luaVM, uchar opacity); + static bool ResetPlayerMapOpacity(); }; diff --git a/Shared/data/MTA San Andreas/MTA/cgui/images/radar/README.txt b/Shared/data/MTA San Andreas/MTA/cgui/images/radar/README.txt new file mode 100644 index 0000000000..f35adbc69a --- /dev/null +++ b/Shared/data/MTA San Andreas/MTA/cgui/images/radar/README.txt @@ -0,0 +1,14 @@ +MTA:SA F11 Radar Map - Custom Images + +You can replace the F11 map images by creating custom versions with the "-custom" suffix: + +Default files: +- map_1024.png (1024x1024) +- map_2048.png (2048x2048) + +To use custom images, create: +- map_1024-custom.png (1024x1024) +- map_2048-custom.png (2048x2048) + +Place them in this folder. MTA will use -custom files if they exist. +Server scripts can override these with setPlayerMapImage(). diff --git a/Shared/data/MTA San Andreas/MTA/cgui/images/map_1024.png b/Shared/data/MTA San Andreas/MTA/cgui/images/radar/map_1024.png similarity index 100% rename from Shared/data/MTA San Andreas/MTA/cgui/images/map_1024.png rename to Shared/data/MTA San Andreas/MTA/cgui/images/radar/map_1024.png diff --git a/Shared/data/MTA San Andreas/MTA/cgui/images/map_2048.png b/Shared/data/MTA San Andreas/MTA/cgui/images/radar/map_2048.png similarity index 100% rename from Shared/data/MTA San Andreas/MTA/cgui/images/map_2048.png rename to Shared/data/MTA San Andreas/MTA/cgui/images/radar/map_2048.png