1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-28 23:06:24 +02:00
vcmi/client/adventureMap/CMinimap.cpp

239 lines
5.3 KiB
C++
Raw Normal View History

/*
2023-02-01 16:42:03 +02:00
* CMinimap.cpp, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#include "StdInc.h"
#include "CMinimap.h"
#include "CAdventureMapInterface.h"
#include "../widgets/Images.h"
#include "../CGameInfo.h"
#include "../CPlayerInterface.h"
#include "../gui/CGuiHandler.h"
#include "../render/Colors.h"
#include "../renderSDL/SDL_PixelAccess.h"
#include "../render/Canvas.h"
2023-02-10 15:29:30 +02:00
#include "../windows/InfoWindows.h"
#include "../../CCallback.h"
#include "../../lib/CGeneralTextHandler.h"
#include "../../lib/TerrainHandler.h"
#include "../../lib/mapObjects/CGHeroInstance.h"
#include "../../lib/mapping/CMapDefines.h"
2023-02-10 15:29:30 +02:00
ColorRGBA CMinimapInstance::getTileColor(const int3 & pos) const
{
const TerrainTile * tile = LOCPLINT->cb->getTile(pos, false);
// if tile is not visible it will be black on minimap
if(!tile)
2023-02-10 15:29:30 +02:00
return CSDL_Ext::fromSDL(Colors::BLACK);
// if object at tile is owned - it will be colored as its owner
2014-10-01 15:19:03 +03:00
for (const CGObjectInstance *obj : tile->blockingObjects)
{
2013-03-03 20:06:03 +03:00
PlayerColor player = obj->getOwner();
if(player == PlayerColor::NEUTRAL)
2023-02-10 15:29:30 +02:00
return CSDL_Ext::fromSDL(*graphics->neutralColor);
2013-03-03 20:06:03 +03:00
if (player < PlayerColor::PLAYER_LIMIT)
2023-02-10 15:29:30 +02:00
return CSDL_Ext::fromSDL(graphics->playerColors[player.getNum()]);
}
if (tile->blocked && (!tile->visitable))
2023-02-10 15:29:30 +02:00
return tile->terType->minimapBlocked;
else
2023-02-10 15:29:30 +02:00
return tile->terType->minimapUnblocked;
}
void CMinimapInstance::refreshTile(const int3 &tile)
{
2023-02-10 15:29:30 +02:00
if (level == tile.z)
minimap->drawPoint(Point(tile.x, tile.y), getTileColor(tile));
}
2023-02-10 15:29:30 +02:00
void CMinimapInstance::redrawMinimap()
{
int3 mapSizes = LOCPLINT->cb->getMapSize();
2023-02-10 15:29:30 +02:00
for (int y = 0; y < mapSizes.y; ++y)
for (int x = 0; x < mapSizes.x; ++x)
minimap->drawPoint(Point(x, y), getTileColor(int3(x, y, level)));
}
CMinimapInstance::CMinimapInstance(CMinimap *Parent, int Level):
2015-01-13 21:57:41 +02:00
parent(Parent),
2023-02-10 15:29:30 +02:00
minimap(new Canvas(Point(LOCPLINT->cb->getMapSize().x, LOCPLINT->cb->getMapSize().y))),
2015-01-13 21:57:41 +02:00
level(Level)
{
pos.w = parent->pos.w;
pos.h = parent->pos.h;
2023-02-10 15:29:30 +02:00
redrawMinimap();
}
void CMinimapInstance::showAll(SDL_Surface * to)
{
2023-02-10 15:29:30 +02:00
Canvas target(to);
target.drawScaled(*minimap, pos.topLeft(), pos.dimensions());
}
CMinimap::CMinimap(const Rect & position)
: CIntObject(LCLICK | RCLICK | HOVER | MOVE, position.topLeft()),
2023-02-10 15:29:30 +02:00
level(0)
{
OBJECT_CONSTRUCTION_CAPTURING(255-DISPOSE);
pos.w = position.w;
pos.h = position.h;
aiShield = std::make_shared<CPicture>("AIShield");
aiShield->disable();
}
2023-02-10 15:29:30 +02:00
int3 CMinimap::pixelToTile(const Point & cursorPos) const
{
// 0 = top-left corner, 1 = bottom-right corner
2023-02-10 15:29:30 +02:00
double dx = static_cast<double>(cursorPos.x) / pos.w;
double dy = static_cast<double>(cursorPos.y) / pos.h;
int3 mapSizes = LOCPLINT->cb->getMapSize();
int tileX(std::round(mapSizes.x * dx));
int tileY(std::round(mapSizes.y * dy));
return int3(tileX, tileY, level);
}
2023-02-10 15:29:30 +02:00
Point CMinimap::tileToPixels(const int3 &tile) const
{
int3 mapSizes = LOCPLINT->cb->getMapSize();
2023-02-10 15:29:30 +02:00
double stepX = static_cast<double>(pos.w) / mapSizes.x;
double stepY = static_cast<double>(pos.h) / mapSizes.y;
int x = static_cast<int>(stepX * tile.x);
int y = static_cast<int>(stepY * tile.y);
return Point(x,y);
}
void CMinimap::moveAdvMapSelection()
{
2023-02-10 15:29:30 +02:00
int3 newLocation = pixelToTile(GH.getCursorPosition() - pos.topLeft());
adventureInt->centerOnTile(newLocation);
if (!(adventureInt->active & GENERAL))
GH.totalRedraw(); //redraw this as well as inactive adventure map
else
redraw();//redraw only this
}
void CMinimap::clickLeft(tribool down, bool previousState)
{
if(down)
moveAdvMapSelection();
}
void CMinimap::clickRight(tribool down, bool previousState)
{
2023-02-10 15:29:30 +02:00
if (down)
CRClickPopup::createAndPush(CGI->generaltexth->zelp[291].second);
}
void CMinimap::hover(bool on)
{
if(on)
GH.statusbar->write(CGI->generaltexth->zelp[291].first);
else
GH.statusbar->clear();
}
void CMinimap::mouseMoved(const Point & cursorPosition)
{
2023-02-02 16:22:19 +02:00
if(mouseState(MouseButton::LEFT))
moveAdvMapSelection();
}
void CMinimap::showAll(SDL_Surface * to)
{
CSDL_Ext::CClipRectGuard guard(to, pos);
CIntObject::showAll(to);
if(minimap)
{
2023-02-10 15:29:30 +02:00
Canvas target(to);
int3 mapSizes = LOCPLINT->cb->getMapSize();
//draw radar
Rect radar =
{
2023-02-10 23:29:13 +02:00
screenArea.x * pos.w / mapSizes.x,
screenArea.y * pos.h / mapSizes.y,
screenArea.w * pos.w / mapSizes.x - 1,
screenArea.h * pos.h / mapSizes.y - 1
};
2023-02-10 15:29:30 +02:00
Canvas clippedTarget(target, pos);
clippedTarget.drawBorderDashed(radar, CSDL_Ext::fromSDL(Colors::PURPLE));
}
}
void CMinimap::update()
{
if(aiShield->recActions & UPDATE) //AI turn is going on. There is no need to update minimap
return;
OBJECT_CONSTRUCTION_CUSTOM_CAPTURING(255-DISPOSE);
minimap = std::make_shared<CMinimapInstance>(this, level);
redraw();
}
void CMinimap::onMapViewMoved(const Rect & visibleArea, int mapLevel)
{
if (screenArea == visibleArea && level == mapLevel)
2023-02-10 15:29:30 +02:00
return;
screenArea = visibleArea;
if(level != mapLevel)
{
level = mapLevel;
update();
}
else
redraw();
}
void CMinimap::setAIRadar(bool on)
{
if(on)
{
aiShield->enable();
minimap.reset();
}
else
{
aiShield->disable();
update();
}
2023-03-22 00:57:08 +02:00
redraw();
}
2023-04-16 00:48:49 +02:00
void CMinimap::updateTiles(std::unordered_set<int3> positions)
{
if(minimap)
2023-04-16 00:48:49 +02:00
{
for (auto const & tile : positions)
minimap->refreshTile(tile);
}
2023-03-16 18:36:31 +02:00
redraw();
}