1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-16 10:19:47 +02:00
vcmi/client/battle/BattleInterfaceClasses.cpp

1195 lines
40 KiB
C++
Raw Normal View History

/*
* BattleInterfaceClasses.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 "BattleInterfaceClasses.h"
#include "BattleInterface.h"
#include "BattleActionsController.h"
#include "BattleRenderer.h"
#include "BattleSiegeController.h"
#include "BattleFieldController.h"
#include "BattleStacksController.h"
#include "BattleWindow.h"
#include "../CGameInfo.h"
#include "../CPlayerInterface.h"
#include "../gui/CursorHandler.h"
#include "../gui/CGuiHandler.h"
#include "../gui/Shortcut.h"
#include "../gui/MouseButton.h"
#include "../gui/WindowHandler.h"
#include "../media/IMusicPlayer.h"
#include "../render/Canvas.h"
#include "../render/IImage.h"
#include "../render/IFont.h"
#include "../render/Graphics.h"
#include "../widgets/Buttons.h"
#include "../widgets/Images.h"
2024-05-14 02:50:57 +02:00
#include "../widgets/Slider.h"
#include "../widgets/TextControls.h"
#include "../widgets/VideoWidget.h"
#include "../widgets/GraphicalPrimitiveCanvas.h"
#include "../windows/CMessage.h"
2024-01-07 17:38:37 +02:00
#include "../windows/CCreatureWindow.h"
#include "../windows/CSpellWindow.h"
#include "../render/CAnimation.h"
#include "../render/IRenderHandler.h"
#include "../adventureMap/CInGameConsole.h"
#include "../../CCallback.h"
#include "../../lib/CStack.h"
#include "../../lib/CConfigHandler.h"
#include "../../lib/CCreatureHandler.h"
#include "../../lib/gameState/InfoAboutArmy.h"
#include "../../lib/CGeneralTextHandler.h"
#include "../../lib/CTownHandler.h"
#include "../../lib/CHeroHandler.h"
#include "../../lib/StartInfo.h"
#include "../../lib/mapObjects/CGTownInstance.h"
#include "../../lib/networkPacks/PacksForClientBattle.h"
#include "../../lib/TextOperations.h"
void BattleConsole::showAll(Canvas & to)
{
CIntObject::showAll(to);
Point line1 (pos.x + pos.w/2, pos.y + 8);
Point line2 (pos.x + pos.w/2, pos.y + 24);
auto visibleText = getVisibleText();
if(visibleText.size() > 0)
to.drawText(line1, FONT_SMALL, Colors::WHITE, ETextAlignment::CENTER, visibleText[0]);
if(visibleText.size() > 1)
to.drawText(line2, FONT_SMALL, Colors::WHITE, ETextAlignment::CENTER, visibleText[1]);
}
std::vector<std::string> BattleConsole::getVisibleText() const
{
// high priority texts that hide battle log entries
for(const auto & text : {consoleText, hoverText})
{
if (text.empty())
continue;
auto result = CMessage::breakText(text, pos.w, FONT_SMALL);
if(result.size() > 2 && text.find('\n') != std::string::npos)
{
// Text has too many lines to fit into console, but has line breaks. Try ignore them and fit text that way
std::string cleanText = boost::algorithm::replace_all_copy(text, "\n", " ");
result = CMessage::breakText(cleanText, pos.w, FONT_SMALL);
}
if(result.size() > 2)
result.resize(2);
return result;
}
// log is small enough to fit entirely - display it as such
if (logEntries.size() < 3)
return logEntries;
return { logEntries[scrollPosition - 1], logEntries[scrollPosition] };
}
std::vector<std::string> BattleConsole::splitText(const std::string &text)
{
std::vector<std::string> lines;
std::vector<std::string> output;
boost::split(lines, text, boost::is_any_of("\n"));
for(const auto & line : lines)
{
if (graphics->fonts[FONT_SMALL]->getStringWidth(text) < pos.w)
{
output.push_back(line);
}
else
{
std::vector<std::string> substrings = CMessage::breakText(line, pos.w, FONT_SMALL);
output.insert(output.end(), substrings.begin(), substrings.end());
}
}
return output;
}
bool BattleConsole::addText(const std::string & text)
{
logGlobal->trace("CBattleConsole message: %s", text);
auto newLines = splitText(text);
logEntries.insert(logEntries.end(), newLines.begin(), newLines.end());
scrollPosition = (int)logEntries.size()-1;
redraw();
return true;
}
void BattleConsole::scrollUp(ui32 by)
{
if(scrollPosition > static_cast<int>(by))
scrollPosition -= by;
redraw();
}
void BattleConsole::scrollDown(ui32 by)
{
if(scrollPosition + by < logEntries.size())
scrollPosition += by;
redraw();
}
2024-05-14 02:50:57 +02:00
BattleConsole::BattleConsole(const BattleInterface & owner, std::shared_ptr<CPicture> backgroundSource, const Point & objectPos, const Point & imagePos, const Point &size)
: CIntObject(LCLICK)
, owner(owner)
, scrollPosition(-1)
, enteringText(false)
{
OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE;
pos += objectPos;
pos.w = size.x;
pos.h = size.y;
background = std::make_shared<CPicture>(backgroundSource->getSurface(), Rect(imagePos, size), 0, 0 );
}
void BattleConsole::deactivate()
{
if (enteringText)
LOCPLINT->cingconsole->endEnteringText(false);
CIntObject::deactivate();
}
2024-05-14 02:50:57 +02:00
void BattleConsole::clickPressed(const Point & cursorPosition)
{
if(owner.makingTurn() && !owner.openingPlaying())
{
GH.windows().createAndPushWindow<BattleConsoleWindow>(boost::algorithm::join(logEntries, "\n"));
}
}
void BattleConsole::setEnteringMode(bool on)
{
consoleText.clear();
if (on)
{
assert(enteringText == false);
GH.startTextInput(pos);
}
else
{
assert(enteringText == true);
GH.stopTextInput();
}
enteringText = on;
redraw();
}
void BattleConsole::setEnteredText(const std::string & text)
{
assert(enteringText == true);
consoleText = text;
redraw();
}
void BattleConsole::write(const std::string & Text)
{
hoverText = Text;
redraw();
}
void BattleConsole::clearIfMatching(const std::string & Text)
{
if (hoverText == Text)
clear();
}
void BattleConsole::clear()
{
write({});
}
BattleConsoleWindow::BattleConsoleWindow(const std::string & text)
2024-05-14 02:50:57 +02:00
: CWindowObject(BORDERED)
{
OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE;
pos.w = 429;
pos.h = 434;
updateShadow();
center();
backgroundTexture = std::make_shared<CFilledTexture>(ImagePath::builtin("DiBoxBck"), Rect(0, 0, pos.w, pos.h));
buttonOk = std::make_shared<CButton>(Point(183, 388), AnimationPath::builtin("IOKAY"), CButton::tooltip(), [this](){ close(); }, EShortcut::GLOBAL_ACCEPT);
Rect textArea(18, 17, 393, 354);
textBoxBackgroundBorder = std::make_shared<TransparentFilledRectangle>(textArea, ColorRGBA(0, 0, 0, 75), ColorRGBA(128, 100, 75));
textBox = std::make_shared<CTextBox>(text, textArea.resize(-5), CSlider::BROWN);
if(textBox->slider)
textBox->slider->scrollToMax();
}
const CGHeroInstance * BattleHero::instance()
{
return hero;
}
void BattleHero::tick(uint32_t msPassed)
{
size_t groupIndex = static_cast<size_t>(phase);
float timePassed = msPassed / 1000.f;
flagCurrentFrame += currentSpeed * timePassed;
currentFrame += currentSpeed * timePassed;
if(flagCurrentFrame >= flagAnimation->size(0))
flagCurrentFrame -= flagAnimation->size(0);
if(currentFrame >= animation->size(groupIndex))
{
currentFrame -= animation->size(groupIndex);
switchToNextPhase();
}
}
void BattleHero::render(Canvas & canvas)
{
size_t groupIndex = static_cast<size_t>(phase);
auto flagFrame = flagAnimation->getImage(flagCurrentFrame, 0, true);
auto heroFrame = animation->getImage(currentFrame, groupIndex, true);
Point heroPosition = pos.center() - parent->pos.topLeft() - heroFrame->dimensions() / 2;
Point flagPosition = pos.center() - parent->pos.topLeft() - flagFrame->dimensions() / 2;
if(defender)
flagPosition += Point(-4, -41);
else
flagPosition += Point(4, -41);
canvas.draw(flagFrame, flagPosition);
canvas.draw(heroFrame, heroPosition);
}
void BattleHero::pause()
{
currentSpeed = 0.f;
}
void BattleHero::play()
{
//H3 speed: 10 fps ( 100 ms per frame)
currentSpeed = 10.f;
}
float BattleHero::getFrame() const
{
return currentFrame;
}
void BattleHero::collectRenderableObjects(BattleRenderer & renderer)
{
auto hex = defender ? BattleHex(GameConstants::BFIELD_WIDTH-1) : BattleHex(0);
renderer.insert(EBattleFieldLayer::HEROES, hex, [this](BattleRenderer::RendererRef canvas)
{
render(canvas);
});
}
void BattleHero::onPhaseFinished(const std::function<void()> & callback)
{
phaseFinishedCallback = callback;
}
void BattleHero::setPhase(EHeroAnimType newPhase)
{
nextPhase = newPhase;
switchToNextPhase(); //immediately switch to next phase and then restore idling phase
nextPhase = EHeroAnimType::HOLDING;
}
void BattleHero::heroLeftClicked()
{
if(owner.actionsController->spellcastingModeActive()) //we are casting a spell
return;
if(!hero || !owner.makingTurn())
return;
if(owner.getBattle()->battleCanCastSpell(hero, spells::Mode::HERO) == ESpellCastProblem::OK) //check conditions
{
CCS->curh->set(Cursor::Map::POINTER);
GH.windows().createAndPushWindow<CSpellWindow>(hero, owner.getCurrentPlayerInterface());
}
}
void BattleHero::heroRightClicked()
{
if(settings["battle"]["stickyHeroInfoWindows"].Bool())
return;
Point windowPosition;
if(GH.screenDimensions().x < 1000)
{
windowPosition.x = (!defender) ? owner.fieldController->pos.left() + 1 : owner.fieldController->pos.right() - 79;
windowPosition.y = owner.fieldController->pos.y + 135;
}
else
{
windowPosition.x = (!defender) ? owner.fieldController->pos.left() - 93 : owner.fieldController->pos.right() + 15;
windowPosition.y = owner.fieldController->pos.y;
}
InfoAboutHero targetHero;
if(owner.makingTurn() || settings["session"]["spectate"].Bool())
{
auto h = defender ? owner.defendingHeroInstance : owner.attackingHeroInstance;
targetHero.initFromHero(h, InfoAboutHero::EInfoLevel::INBATTLE);
GH.windows().createAndPushWindow<HeroInfoWindow>(targetHero, &windowPosition);
}
}
void BattleHero::switchToNextPhase()
{
phase = nextPhase;
currentFrame = 0.f;
auto copy = phaseFinishedCallback;
phaseFinishedCallback.clear();
copy();
}
BattleHero::BattleHero(const BattleInterface & owner, const CGHeroInstance * hero, bool defender):
defender(defender),
hero(hero),
owner(owner),
phase(EHeroAnimType::HOLDING),
nextPhase(EHeroAnimType::HOLDING),
currentSpeed(0.f),
currentFrame(0.f),
flagCurrentFrame(0.f)
{
AnimationPath animationPath;
if(!hero->type->battleImage.empty())
animationPath = hero->type->battleImage;
else
if(hero->gender == EHeroGender::FEMALE)
animationPath = hero->type->heroClass->imageBattleFemale;
else
animationPath = hero->type->heroClass->imageBattleMale;
animation = GH.renderHandler().loadAnimation(animationPath);
animation->preload();
pos.w = 64;
pos.h = 136;
pos.x = owner.fieldController->pos.x + (defender ? (owner.fieldController->pos.w - pos.w) : 0);
pos.y = owner.fieldController->pos.y;
if(defender)
animation->verticalFlip();
if(defender)
flagAnimation = GH.renderHandler().loadAnimation(AnimationPath::builtin("CMFLAGR"));
else
flagAnimation = GH.renderHandler().loadAnimation(AnimationPath::builtin("CMFLAGL"));
flagAnimation->preload();
flagAnimation->playerColored(hero->tempOwner);
switchToNextPhase();
play();
addUsedEvents(TIME);
}
2024-05-19 22:31:35 +02:00
QuickSpellPanel::QuickSpellPanel(std::shared_ptr<CButton> initWidget, std::shared_ptr<CPlayerBattleCallback> battle)
: CWindowObject(NEEDS_ANIMATED_BACKGROUND), initWidget(initWidget), battle(battle)
2024-05-19 03:27:28 +02:00
{
OBJECT_CONSTRUCTION_CAPTURING(255-DISPOSE);
2024-05-19 04:23:53 +02:00
addUsedEvents(LCLICK | SHOW_POPUP | MOVE);
2024-05-19 03:27:28 +02:00
pos = Rect(0, 0, 52, 372);
background = std::make_shared<CFilledTexture>(ImagePath::builtin("DIBOXBCK"), pos);
rect = std::make_shared<TransparentFilledRectangle>(Rect(0, 0, pos.w + 1, pos.h + 1), ColorRGBA(0, 0, 0, 0), ColorRGBA(241, 216, 120, 255));
2024-05-19 21:29:23 +02:00
panelSelect = std::make_shared<QuickSpellPanelSelect>(this);
2024-05-19 20:45:55 +02:00
2024-05-19 21:29:23 +02:00
create();
}
void QuickSpellPanel::create()
{
2024-05-19 22:31:35 +02:00
OBJECT_CONSTRUCTION_CAPTURING(255-DISPOSE);
labels.clear();
buttons.clear();
buttonsDisabled.clear();
auto hero = battle->battleGetMyHero();
if(!hero)
return;
2024-05-19 03:27:28 +02:00
for(int i = 0; i < 10; i++) {
2024-05-19 22:31:35 +02:00
std::string spellIdentifier = persistentStorage["quickSpell"][std::to_string(i)].String();
SpellID id = SpellID::decode(spellIdentifier);
2024-05-19 20:45:55 +02:00
auto button = std::make_shared<CButton>(Point(2, 1 + 37 * i), AnimationPath::builtin("spellint"), CButton::tooltip(), [&](){ std::cout << "test"; });
2024-05-19 22:31:35 +02:00
button->setOverlay(std::make_shared<CAnimImage>(AnimationPath::builtin("spellint"), !spellIdentifier.empty() ? id.num + 1 : 0));
button->addPopupCallback([this, i](){
panelSelect->spellSlot = i;
2024-05-19 20:45:55 +02:00
panelSelect->setEnabled(true);
});
2024-05-19 03:27:28 +02:00
2024-05-19 22:31:35 +02:00
if(!id.hasValue() || !id.toSpell()->canBeCast(battle.get(), spells::Mode::HERO, hero))
2024-05-19 03:27:28 +02:00
{
buttonsDisabled.push_back(std::make_shared<TransparentFilledRectangle>(Rect(2, 1 + 37 * i, 48, 36), ColorRGBA(0, 0, 0, 128)));
}
2024-05-19 20:45:55 +02:00
labels.push_back(std::make_shared<CLabel>(7, 4 + 37 * i, EFonts::FONT_SMALL, ETextAlignment::TOPLEFT, Colors::WHITE, std::to_string(i)));
2024-05-19 03:27:28 +02:00
buttons.push_back(button);
}
}
void QuickSpellPanel::show(Canvas & to)
{
showAll(to);
CIntObject::show(to);
}
void QuickSpellPanel::clickReleased(const Point & cursorPosition)
{
2024-05-19 21:29:23 +02:00
if(!pos.isInside(cursorPosition) && (!(panelSelect->isActive() || panelSelect->wasEnabled) || !panelSelect->pos.isInside(cursorPosition)))
2024-05-19 04:23:53 +02:00
close();
if(initWidget->pos.isInside(cursorPosition))
{
initWidget->clickPressed(cursorPosition);
initWidget->clickReleased(cursorPosition);
}
2024-05-19 03:27:28 +02:00
}
void QuickSpellPanel::showPopupWindow(const Point & cursorPosition)
{
2024-05-19 21:29:23 +02:00
if(!pos.isInside(cursorPosition) && (!(panelSelect->isActive() || panelSelect->wasEnabled) || !panelSelect->pos.isInside(cursorPosition)))
2024-05-19 04:23:53 +02:00
close();
if(initWidget->pos.isInside(cursorPosition))
{
initWidget->showPopupWindow(cursorPosition);
}
}
void QuickSpellPanel::mouseMoved(const Point & cursorPosition, const Point & lastUpdateDistance)
{
2024-05-19 20:45:55 +02:00
if( (cursorPosition.x <= initWidget->pos.x - 20 ||
2024-05-19 04:23:53 +02:00
cursorPosition.x >= initWidget->pos.x + initWidget->pos.w + 20 ||
cursorPosition.y <= initWidget->pos.y - pos.h - 20 ||
2024-05-19 20:45:55 +02:00
(cursorPosition.y >= initWidget->pos.y && !initWidget->pos.isInside(cursorPosition))) &&
2024-05-19 21:29:23 +02:00
(!(panelSelect->isActive() || panelSelect->wasEnabled) || !panelSelect->pos.resize(20).isInside(cursorPosition))
2024-05-19 20:45:55 +02:00
)
2024-05-19 04:23:53 +02:00
close();
2024-05-19 21:29:23 +02:00
if(initWidget->pos.isInside(cursorPosition))
panelSelect->wasEnabled = false;
2024-05-19 03:27:28 +02:00
}
bool QuickSpellPanel::receiveEvent(const Point & position, int eventType) const
{
return true; // capture click also outside of window
}
2024-05-19 21:29:23 +02:00
QuickSpellPanelSelect::QuickSpellPanelSelect(QuickSpellPanel * Parent)
: parent(Parent), wasEnabled(false)
2024-05-19 20:45:55 +02:00
{
OBJECT_CONSTRUCTION_CAPTURING(255-DISPOSE);
setEnabled(false);
std::vector<ConstTransitivePtr<CSpell>> spellList;
for (auto const & s : VLC->spellh->objects)
if (s->isCombat() && !s->isSpecial() && !s->isCreatureAbility())
spellList.push_back(s);
auto ceil = [](int x, int y){ return(x + y - 1) / y; };
int columnsNeeded = ceil(spellList.size(), 10);
pos = Rect(-20 - columnsNeeded * 50, 0, columnsNeeded * 50 + 2, 372);
background = std::make_shared<CFilledTexture>(ImagePath::builtin("DIBOXBCK"), Rect(0, 0, pos.w, pos.h));
rect = std::make_shared<TransparentFilledRectangle>(Rect(0, 0, pos.w + 1, pos.h + 1), ColorRGBA(0, 0, 0, 0), ColorRGBA(241, 216, 120, 255));
for(int i = 0; i < spellList.size(); i++)
{
int y = i % 10;
int x = i / 10;
2024-05-19 22:31:35 +02:00
ConstTransitivePtr<CSpell> spell = spellList[i];
auto button = std::make_shared<CButton>(Point(2 + 50 * x, 1 + 37 * y), AnimationPath::builtin("spellint"), CButton::tooltip(), [this, spell](){
2024-05-19 21:29:23 +02:00
setEnabled(false);
GH.windows().totalRedraw();
wasEnabled = true;
2024-05-19 22:31:35 +02:00
Settings configID = persistentStorage.write["quickSpell"][std::to_string(spellSlot)];
configID->String() = spell->identifier;
2024-05-19 21:29:23 +02:00
parent->create();
});
2024-05-19 20:45:55 +02:00
button->setOverlay(std::make_shared<CAnimImage>(AnimationPath::builtin("spellint"), spellList[i]->getId().num + 1));
buttons.push_back(button);
}
}
HeroInfoBasicPanel::HeroInfoBasicPanel(const InfoAboutHero & hero, Point * position, bool initializeBackground)
: CIntObject(0)
{
OBJECT_CONSTRUCTION_CAPTURING(255-DISPOSE);
if (position != nullptr)
moveTo(*position);
if(initializeBackground)
{
background = std::make_shared<CPicture>(ImagePath::builtin("CHRPOP"));
background->getSurface()->setBlitMode(EImageBlitMode::OPAQUE);
background->colorize(hero.owner);
}
initializeData(hero);
}
void HeroInfoBasicPanel::initializeData(const InfoAboutHero & hero)
{
OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE;
auto attack = hero.details->primskills[0];
auto defense = hero.details->primskills[1];
auto power = hero.details->primskills[2];
auto knowledge = hero.details->primskills[3];
auto morale = hero.details->morale;
auto luck = hero.details->luck;
auto currentSpellPoints = hero.details->mana;
auto maxSpellPoints = hero.details->manaLimit;
icons.push_back(std::make_shared<CAnimImage>(AnimationPath::builtin("PortraitsLarge"), hero.getIconIndex(), 0, 10, 6));
//primary stats
labels.push_back(std::make_shared<CLabel>(9, 75, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[380] + ":"));
labels.push_back(std::make_shared<CLabel>(9, 87, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[381] + ":"));
labels.push_back(std::make_shared<CLabel>(9, 99, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[382] + ":"));
labels.push_back(std::make_shared<CLabel>(9, 111, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[383] + ":"));
labels.push_back(std::make_shared<CLabel>(69, 87, EFonts::FONT_TINY, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, std::to_string(attack)));
labels.push_back(std::make_shared<CLabel>(69, 99, EFonts::FONT_TINY, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, std::to_string(defense)));
labels.push_back(std::make_shared<CLabel>(69, 111, EFonts::FONT_TINY, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, std::to_string(power)));
labels.push_back(std::make_shared<CLabel>(69, 123, EFonts::FONT_TINY, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, std::to_string(knowledge)));
//morale+luck
labels.push_back(std::make_shared<CLabel>(9, 131, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[384] + ":"));
labels.push_back(std::make_shared<CLabel>(9, 143, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[385] + ":"));
icons.push_back(std::make_shared<CAnimImage>(AnimationPath::builtin("IMRL22"), morale + 3, 0, 47, 131));
icons.push_back(std::make_shared<CAnimImage>(AnimationPath::builtin("ILCK22"), luck + 3, 0, 47, 143));
//spell points
labels.push_back(std::make_shared<CLabel>(39, 174, EFonts::FONT_TINY, ETextAlignment::CENTER, Colors::WHITE, CGI->generaltexth->allTexts[387]));
labels.push_back(std::make_shared<CLabel>(39, 186, EFonts::FONT_TINY, ETextAlignment::CENTER, Colors::WHITE, std::to_string(currentSpellPoints) + "/" + std::to_string(maxSpellPoints)));
}
void HeroInfoBasicPanel::update(const InfoAboutHero & updatedInfo)
{
icons.clear();
labels.clear();
initializeData(updatedInfo);
}
void HeroInfoBasicPanel::show(Canvas & to)
{
showAll(to);
CIntObject::show(to);
}
2023-12-22 22:26:40 +02:00
2024-01-29 22:11:18 +02:00
StackInfoBasicPanel::StackInfoBasicPanel(const CStack * stack, bool initializeBackground)
2023-12-22 22:26:40 +02:00
: CIntObject(0)
{
OBJECT_CONSTRUCTION_CAPTURING(255-DISPOSE);
if(initializeBackground)
{
2023-12-23 04:32:42 +02:00
background = std::make_shared<CPicture>(ImagePath::builtin("CCRPOP"));
background->pos.y += 37;
2023-12-22 22:26:40 +02:00
background->getSurface()->setBlitMode(EImageBlitMode::OPAQUE);
2023-12-22 23:26:35 +02:00
background->colorize(stack->getOwner());
2023-12-23 04:32:42 +02:00
background2 = std::make_shared<CPicture>(ImagePath::builtin("CHRPOP"));
background2->getSurface()->setBlitMode(EImageBlitMode::OPAQUE);
background2->colorize(stack->getOwner());
2023-12-22 22:26:40 +02:00
}
2023-12-22 23:26:35 +02:00
initializeData(stack);
2023-12-22 22:26:40 +02:00
}
2023-12-22 23:26:35 +02:00
void StackInfoBasicPanel::initializeData(const CStack * stack)
2023-12-22 22:26:40 +02:00
{
OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE;
2023-12-22 23:26:35 +02:00
2023-12-23 04:06:48 +02:00
icons.push_back(std::make_shared<CAnimImage>(AnimationPath::builtin("TWCRPORT"), stack->creatureId() + 2, 0, 10, 6));
labels.push_back(std::make_shared<CLabel>(10 + 58, 6 + 64, FONT_MEDIUM, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, TextOperations::formatMetric(stack->getCount(), 4)));
2023-12-22 23:26:35 +02:00
2023-12-23 04:06:48 +02:00
auto attack = std::to_string(CGI->creatures()->getByIndex(stack->creatureIndex())->getAttack(stack->isShooter())) + "(" + std::to_string(stack->getAttack(stack->isShooter())) + ")";
auto defense = std::to_string(CGI->creatures()->getByIndex(stack->creatureIndex())->getDefense(stack->isShooter())) + "(" + std::to_string(stack->getDefense(stack->isShooter())) + ")";
auto damage = std::to_string(CGI->creatures()->getByIndex(stack->creatureIndex())->getMinDamage(stack->isShooter())) + "-" + std::to_string(stack->getMaxDamage(stack->isShooter()));
2023-12-23 15:51:26 +02:00
auto health = CGI->creatures()->getByIndex(stack->creatureIndex())->getMaxHealth();
2023-12-23 04:06:48 +02:00
auto morale = stack->moraleVal();
auto luck = stack->luckVal();
auto killed = stack->getKilled();
2023-12-24 02:06:02 +02:00
auto healthRemaining = TextOperations::formatMetric(std::max(stack->getAvailableHealth() - (stack->getCount() - 1) * health, (si64)0), 4);
2023-12-23 04:06:48 +02:00
//primary stats*/
2023-12-22 23:26:35 +02:00
labels.push_back(std::make_shared<CLabel>(9, 75, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[380] + ":"));
labels.push_back(std::make_shared<CLabel>(9, 87, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[381] + ":"));
2023-12-23 04:06:48 +02:00
labels.push_back(std::make_shared<CLabel>(9, 99, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[386] + ":"));
labels.push_back(std::make_shared<CLabel>(9, 111, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[389] + ":"));
2023-12-22 23:26:35 +02:00
2023-12-23 04:06:48 +02:00
labels.push_back(std::make_shared<CLabel>(69, 87, EFonts::FONT_TINY, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, attack));
labels.push_back(std::make_shared<CLabel>(69, 99, EFonts::FONT_TINY, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, defense));
labels.push_back(std::make_shared<CLabel>(69, 111, EFonts::FONT_TINY, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, damage));
2023-12-23 15:51:26 +02:00
labels.push_back(std::make_shared<CLabel>(69, 123, EFonts::FONT_TINY, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, std::to_string(health)));
2023-12-22 23:26:35 +02:00
//morale+luck
labels.push_back(std::make_shared<CLabel>(9, 131, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[384] + ":"));
labels.push_back(std::make_shared<CLabel>(9, 143, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[385] + ":"));
icons.push_back(std::make_shared<CAnimImage>(AnimationPath::builtin("IMRL22"), morale + 3, 0, 47, 131));
icons.push_back(std::make_shared<CAnimImage>(AnimationPath::builtin("ILCK22"), luck + 3, 0, 47, 143));
2023-12-23 04:06:48 +02:00
//extra information
2023-12-23 17:07:12 +02:00
labels.push_back(std::make_shared<CLabel>(9, 168, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, VLC->generaltexth->translate("vcmi.battleWindow.killed") + ":"));
2023-12-23 15:51:26 +02:00
labels.push_back(std::make_shared<CLabel>(9, 180, EFonts::FONT_TINY, ETextAlignment::TOPLEFT, Colors::WHITE, CGI->generaltexth->allTexts[389] + ":"));
2023-12-23 04:06:48 +02:00
labels.push_back(std::make_shared<CLabel>(69, 180, EFonts::FONT_TINY, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, std::to_string(killed)));
labels.push_back(std::make_shared<CLabel>(69, 192, EFonts::FONT_TINY, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, healthRemaining));
2023-12-23 15:51:26 +02:00
//spells
static const Point firstPos(15, 206); // position of 1st spell box
static const Point offset(0, 38); // offset of each spell box from previous
for(int i = 0; i < 3; i++)
icons.push_back(std::make_shared<CAnimImage>(AnimationPath::builtin("SpellInt"), 78, 0, firstPos.x + offset.x * i, firstPos.y + offset.y * i));
int printed=0; //how many effect pics have been printed
std::vector<SpellID> spells = stack->activeSpells();
for(SpellID effect : spells)
{
//not all effects have graphics (for eg. Acid Breath)
//for modded spells iconEffect is added to SpellInt.def
const bool hasGraphics = (effect < SpellID::THUNDERBOLT) || (effect >= SpellID::AFTER_LAST);
if (hasGraphics)
{
//FIXME: support permanent duration
int duration = stack->getFirstBonus(Selector::source(BonusSource::SPELL_EFFECT, BonusSourceID(effect)))->turnsRemain;
2023-12-23 15:51:26 +02:00
icons.push_back(std::make_shared<CAnimImage>(AnimationPath::builtin("SpellInt"), effect + 1, 0, firstPos.x + offset.x * printed, firstPos.y + offset.y * printed));
2023-12-23 17:07:12 +02:00
if(settings["general"]["enableUiEnhancements"].Bool())
labels.push_back(std::make_shared<CLabel>(firstPos.x + offset.x * printed + 46, firstPos.y + offset.y * printed + 36, EFonts::FONT_TINY, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, std::to_string(duration)));
2023-12-23 15:51:26 +02:00
if(++printed >= 3 || (printed == 2 && spells.size() > 3)) // interface limit reached
break;
}
}
if(spells.size() == 0)
labelsMultiline.push_back(std::make_shared<CMultiLineLabel>(Rect(firstPos.x, firstPos.y, 48, 36), EFonts::FONT_TINY, ETextAlignment::CENTER, Colors::WHITE, CGI->generaltexth->allTexts[674]));
if(spells.size() > 3)
2023-12-23 17:07:12 +02:00
labelsMultiline.push_back(std::make_shared<CMultiLineLabel>(Rect(firstPos.x + offset.x * 2, firstPos.y + offset.y * 2 - 4, 48, 36), EFonts::FONT_MEDIUM, ETextAlignment::CENTER, Colors::WHITE, "..."));
2023-12-22 22:26:40 +02:00
}
2023-12-22 23:26:35 +02:00
void StackInfoBasicPanel::update(const CStack * updatedInfo)
2023-12-22 22:26:40 +02:00
{
icons.clear();
labels.clear();
2023-12-23 15:51:26 +02:00
labelsMultiline.clear();
2023-12-22 22:26:40 +02:00
initializeData(updatedInfo);
}
2023-12-22 23:26:35 +02:00
void StackInfoBasicPanel::show(Canvas & to)
2023-12-22 22:26:40 +02:00
{
showAll(to);
CIntObject::show(to);
}
HeroInfoWindow::HeroInfoWindow(const InfoAboutHero & hero, Point * position)
: CWindowObject(RCLICK_POPUP | SHADOW_DISABLED, ImagePath::builtin("CHRPOP"))
{
OBJECT_CONSTRUCTION_CAPTURING(255-DISPOSE);
if (position != nullptr)
moveTo(*position);
background->colorize(hero.owner); //maybe add this functionality to base class?
content = std::make_shared<HeroInfoBasicPanel>(hero, nullptr, false);
}
BattleResultWindow::BattleResultWindow(const BattleResult & br, CPlayerInterface & _owner, bool allowReplay)
: owner(_owner)
{
OBJECT_CONSTRUCTION_CAPTURING(255-DISPOSE);
background = std::make_shared<CPicture>(ImagePath::builtin("CPRESULT"));
background->colorize(owner.playerID);
pos = center(background->pos);
exit = std::make_shared<CButton>(Point(384, 505), AnimationPath::builtin("iok6432.def"), std::make_pair("", ""), [&](){ bExitf();}, EShortcut::GLOBAL_ACCEPT);
exit->setBorderColor(Colors::METALLIC_GOLD);
2023-12-28 21:48:19 +02:00
if(allowReplay || owner.cb->getStartInfo()->extraOptionsInfo.unlimitedReplay)
{
repeat = std::make_shared<CButton>(Point(24, 505), AnimationPath::builtin("icn6432.def"), std::make_pair("", ""), [&](){ bRepeatf();}, EShortcut::GLOBAL_CANCEL);
repeat->setBorderColor(Colors::METALLIC_GOLD);
labels.push_back(std::make_shared<CLabel>(232, 520, FONT_MEDIUM, ETextAlignment::CENTER, Colors::WHITE, CGI->generaltexth->translate("vcmi.battleResultsWindow.applyResultsLabel")));
}
if(br.winner == 0) //attacker won
{
labels.push_back(std::make_shared<CLabel>(59, 124, FONT_SMALL, ETextAlignment::CENTER, Colors::WHITE, CGI->generaltexth->allTexts[410]));
}
else
{
labels.push_back(std::make_shared<CLabel>(59, 124, FONT_SMALL, ETextAlignment::CENTER, Colors::WHITE, CGI->generaltexth->allTexts[411]));
}
if(br.winner == 1)
{
labels.push_back(std::make_shared<CLabel>(412, 124, FONT_SMALL, ETextAlignment::CENTER, Colors::WHITE, CGI->generaltexth->allTexts[410]));
}
else
{
labels.push_back(std::make_shared<CLabel>(408, 124, FONT_SMALL, ETextAlignment::CENTER, Colors::WHITE, CGI->generaltexth->allTexts[411]));
}
labels.push_back(std::make_shared<CLabel>(232, 302, FONT_BIG, ETextAlignment::CENTER, Colors::YELLOW, CGI->generaltexth->allTexts[407]));
labels.push_back(std::make_shared<CLabel>(232, 332, FONT_SMALL, ETextAlignment::CENTER, Colors::WHITE, CGI->generaltexth->allTexts[408]));
labels.push_back(std::make_shared<CLabel>(232, 428, FONT_SMALL, ETextAlignment::CENTER, Colors::WHITE, CGI->generaltexth->allTexts[409]));
std::string sideNames[2] = {"N/A", "N/A"};
for(int i = 0; i < 2; i++)
{
auto heroInfo = owner.cb->getBattle(br.battleID)->battleGetHeroInfo(i);
const int xs[] = {21, 392};
if(heroInfo.portraitSource.isValid()) //attacking hero
{
icons.push_back(std::make_shared<CAnimImage>(AnimationPath::builtin("PortraitsLarge"), heroInfo.getIconIndex(), 0, xs[i], 38));
sideNames[i] = heroInfo.name;
}
else
{
auto stacks = owner.cb->getBattle(br.battleID)->battleGetAllStacks();
vstd::erase_if(stacks, [i](const CStack * stack) //erase stack of other side and not coming from garrison
{
return stack->unitSide() != i || !stack->base;
});
auto best = vstd::maxElementByFun(stacks, [](const CStack * stack)
{
return stack->unitType()->getAIValue();
});
if(best != stacks.end()) //should be always but to be safe...
{
icons.push_back(std::make_shared<CAnimImage>(AnimationPath::builtin("TWCRPORT"), (*best)->unitType()->getIconIndex(), 0, xs[i], 38));
sideNames[i] = (*best)->unitType()->getNamePluralTranslated();
}
}
}
//printing attacker and defender's names
labels.push_back(std::make_shared<CLabel>(89, 37, FONT_SMALL, ETextAlignment::TOPLEFT, Colors::WHITE, sideNames[0]));
labels.push_back(std::make_shared<CLabel>(381, 53, FONT_SMALL, ETextAlignment::BOTTOMRIGHT, Colors::WHITE, sideNames[1]));
//printing casualties
for(int step = 0; step < 2; ++step)
{
if(br.casualties[step].size()==0)
{
labels.push_back(std::make_shared<CLabel>(235, 360 + 97 * step, FONT_SMALL, ETextAlignment::CENTER, Colors::WHITE, CGI->generaltexth->allTexts[523]));
}
else
{
int xPos = 235 - ((int)br.casualties[step].size()*32 + ((int)br.casualties[step].size() - 1)*10)/2; //increment by 42 with each picture
int yPos = 344 + step * 97;
for(auto & elem : br.casualties[step])
{
auto creature = CGI->creatures()->getByIndex(elem.first);
if (creature->getId() == CreatureID::ARROW_TOWERS )
continue; // do not show destroyed towers in battle results
icons.push_back(std::make_shared<CAnimImage>(AnimationPath::builtin("CPRSMALL"), creature->getIconIndex(), 0, xPos, yPos));
std::ostringstream amount;
amount<<elem.second;
labels.push_back(std::make_shared<CLabel>(xPos + 16, yPos + 42, FONT_SMALL, ETextAlignment::CENTER, Colors::WHITE, amount.str()));
xPos += 42;
}
}
}
auto resources = getResources(br);
description = std::make_shared<CTextBox>(resources.resultText.toString(), Rect(69, 203, 330, 68), 0, FONT_SMALL, ETextAlignment::CENTER, Colors::WHITE);
2024-05-15 18:34:23 +02:00
videoPlayer = std::make_shared<VideoWidget>(Point(107, 70), resources.prologueVideo, resources.loopedVideo, false);
CCS->musich->playMusic(resources.musicName, false, true);
}
BattleResultResources BattleResultWindow::getResources(const BattleResult & br)
{
//printing result description
bool weAreAttacker = !(owner.cb->getBattle(br.battleID)->battleGetMySide());
bool weAreDefender = !weAreAttacker;
bool weWon = (br.winner == 0 && weAreAttacker) || (br.winner == 1 && !weAreAttacker);
bool isSiege = owner.cb->getBattle(br.battleID)->battleGetDefendedTown() != nullptr;
BattleResultResources resources;
if(weWon)
{
if(isSiege && weAreDefender)
{
resources.musicName = AudioPath::builtin("Music/Defend Castle");
resources.prologueVideo = VideoPath::builtin("DEFENDALL.BIK");
resources.loopedVideo = VideoPath::builtin("defendloop.bik");
}
else
{
resources.musicName = AudioPath::builtin("Music/Win Battle");
resources.prologueVideo = VideoPath();
resources.loopedVideo = VideoPath::builtin("WIN3.BIK");
}
switch(br.result)
{
case EBattleResult::NORMAL:
resources.resultText.appendTextID("core.genrltxt.304");
break;
case EBattleResult::ESCAPE:
resources.resultText.appendTextID("core.genrltxt.303");
break;
case EBattleResult::SURRENDER:
resources.resultText.appendTextID("core.genrltxt.302");
break;
default:
throw std::runtime_error("Invalid battle result!");
}
const CGHeroInstance * ourHero = owner.cb->getBattle(br.battleID)->battleGetMyHero();
if (ourHero)
{
resources.resultText.appendTextID("core.genrltxt.305");
resources.resultText.replaceTextID(ourHero->getNameTranslated());
resources.resultText.replaceNumber(br.exp[weAreAttacker ? 0 : 1]);
}
}
else // we lose
{
switch(br.result)
{
case EBattleResult::NORMAL:
resources.resultText.appendTextID("core.genrltxt.311");
resources.musicName = AudioPath::builtin("Music/LoseCombat");
resources.prologueVideo = VideoPath::builtin("LBSTART.BIK");
resources.loopedVideo = VideoPath::builtin("LBLOOP.BIK");
break;
case EBattleResult::ESCAPE:
resources.resultText.appendTextID("core.genrltxt.310");
resources.musicName = AudioPath::builtin("Music/Retreat Battle");
resources.prologueVideo = VideoPath::builtin("RTSTART.BIK");
resources.loopedVideo = VideoPath::builtin("RTLOOP.BIK");
break;
case EBattleResult::SURRENDER:
resources.resultText.appendTextID("core.genrltxt.309");
resources.musicName = AudioPath::builtin("Music/Surrender Battle");
resources.prologueVideo = VideoPath();
resources.loopedVideo = VideoPath::builtin("SURRENDER.BIK");
break;
default:
throw std::runtime_error("Invalid battle result!");
}
if(isSiege && weAreDefender)
{
resources.musicName = AudioPath::builtin("Music/LoseCastle");
resources.prologueVideo = VideoPath::builtin("LOSECSTL.BIK");
resources.loopedVideo = VideoPath::builtin("LOSECSLP.BIK");
}
}
return resources;
}
void BattleResultWindow::activate()
{
owner.showingDialog->setBusy();
CIntObject::activate();
}
void BattleResultWindow::buttonPressed(int button)
{
if (resultCallback)
resultCallback(button);
CPlayerInterface &intTmp = owner; //copy reference because "this" will be destructed soon
close();
if(GH.windows().topWindow<BattleWindow>())
GH.windows().popWindows(1); //pop battle interface if present
//Result window and battle interface are gone. We requested all dialogs to be closed before opening the battle,
//so we can be sure that there is no dialogs left on GUI stack.
intTmp.showingDialog->setFree();
}
void BattleResultWindow::bExitf()
{
buttonPressed(0);
}
void BattleResultWindow::bRepeatf()
{
buttonPressed(1);
}
StackQueue::StackQueue(bool Embedded, BattleInterface & owner)
: embedded(Embedded),
owner(owner)
{
OBJECT_CONSTRUCTION_CAPTURING(255-DISPOSE);
uint32_t queueSize = QUEUE_SIZE_BIG;
if(embedded)
{
int32_t queueSmallOutsideYOffset = 65;
bool queueSmallOutside = settings["battle"]["queueSmallOutside"].Bool() && (pos.y - queueSmallOutsideYOffset) >= 0;
queueSize = std::clamp(static_cast<int>(settings["battle"]["queueSmallSlots"].Float()), 1, queueSmallOutside ? GH.screenDimensions().x / 41 : 19);
pos.w = queueSize * 41;
pos.h = 49;
pos.x += parent->pos.w/2 - pos.w/2;
pos.y += queueSmallOutside ? -queueSmallOutsideYOffset : 10;
icons = GH.renderHandler().loadAnimation(AnimationPath::builtin("CPRSMALL"));
stateIcons = GH.renderHandler().loadAnimation(AnimationPath::builtin("VCMI/BATTLEQUEUE/STATESSMALL"));
}
else
{
pos.w = 800;
pos.h = 85;
pos.x += 0;
pos.y -= pos.h;
background = std::make_shared<CFilledTexture>(ImagePath::builtin("DIBOXBCK"), Rect(0, 0, pos.w, pos.h));
icons = GH.renderHandler().loadAnimation(AnimationPath::builtin("TWCRPORT"));
stateIcons = GH.renderHandler().loadAnimation(AnimationPath::builtin("VCMI/BATTLEQUEUE/STATESSMALL"));
//TODO: where use big icons?
//stateIcons = GH.renderHandler().loadAnimation("VCMI/BATTLEQUEUE/STATESBIG");
}
stateIcons->preload();
stackBoxes.resize(queueSize);
for (int i = 0; i < stackBoxes.size(); i++)
{
stackBoxes[i] = std::make_shared<StackBox>(this);
stackBoxes[i]->moveBy(Point(1 + (embedded ? 41 : 80) * i, 0));
}
}
void StackQueue::show(Canvas & to)
{
if (embedded)
showAll(to);
CIntObject::show(to);
}
void StackQueue::update()
{
std::vector<battle::Units> queueData;
owner.getBattle()->battleGetTurnOrder(queueData, stackBoxes.size(), 0);
size_t boxIndex = 0;
2023-12-23 20:57:19 +02:00
ui32 tmpTurn = -1;
for(size_t turn = 0; turn < queueData.size() && boxIndex < stackBoxes.size(); turn++)
{
for(size_t unitIndex = 0; unitIndex < queueData[turn].size() && boxIndex < stackBoxes.size(); boxIndex++, unitIndex++)
2023-12-23 20:57:19 +02:00
{
ui32 currentTurn = owner.round + turn;
2023-12-23 23:00:28 +02:00
stackBoxes[boxIndex]->setUnit(queueData[turn][unitIndex], turn, tmpTurn != currentTurn && owner.round != 0 && (!embedded || tmpTurn != -1) ? (std::optional<ui32>)currentTurn : std::nullopt);
2023-12-23 20:57:19 +02:00
tmpTurn = currentTurn;
}
}
for(; boxIndex < stackBoxes.size(); boxIndex++)
stackBoxes[boxIndex]->setUnit(nullptr);
}
int32_t StackQueue::getSiegeShooterIconID()
{
return owner.siegeController->getSiegedTown()->town->faction->getIndex();
}
std::optional<uint32_t> StackQueue::getHoveredUnitIdIfAny() const
{
for(const auto & stackBox : stackBoxes)
{
if(stackBox->isHovered())
{
return stackBox->getBoundUnitID();
}
}
return std::nullopt;
}
StackQueue::StackBox::StackBox(StackQueue * owner):
CIntObject(SHOW_POPUP | HOVER), owner(owner)
{
OBJECT_CONSTRUCTION_CAPTURING(255-DISPOSE);
background = std::make_shared<CPicture>(ImagePath::builtin(owner->embedded ? "StackQueueSmall" : "StackQueueLarge"));
pos.w = background->pos.w;
pos.h = background->pos.h;
if(owner->embedded)
{
icon = std::make_shared<CAnimImage>(owner->icons, 0, 0, 5, 2);
amount = std::make_shared<CLabel>(pos.w/2, pos.h - 7, FONT_SMALL, ETextAlignment::CENTER, Colors::WHITE);
2023-12-23 23:00:28 +02:00
roundRect = std::make_shared<TransparentFilledRectangle>(Rect(0, 0, 2, 48), ColorRGBA(0, 0, 0, 255), ColorRGBA(0, 255, 0, 255));
}
else
{
icon = std::make_shared<CAnimImage>(owner->icons, 0, 0, 9, 1);
amount = std::make_shared<CLabel>(pos.w/2, pos.h - 8, FONT_MEDIUM, ETextAlignment::CENTER, Colors::WHITE);
2023-12-23 20:57:19 +02:00
roundRect = std::make_shared<TransparentFilledRectangle>(Rect(0, 0, 15, 18), ColorRGBA(0, 0, 0, 255), ColorRGBA(241, 216, 120, 255));
round = std::make_shared<CLabel>(4, 2, FONT_SMALL, ETextAlignment::TOPLEFT, Colors::WHITE);
int icon_x = pos.w - 17;
int icon_y = pos.h - 18;
stateIcon = std::make_shared<CAnimImage>(owner->stateIcons, 0, 0, icon_x, icon_y);
stateIcon->visible = false;
}
2023-12-23 23:00:28 +02:00
roundRect->disable();
}
2023-12-23 20:57:19 +02:00
void StackQueue::StackBox::setUnit(const battle::Unit * unit, size_t turn, std::optional<ui32> currentTurn)
{
if(unit)
{
boundUnitID = unit->unitId();
background->colorize(unit->unitOwner());
icon->visible = true;
// temporary code for mod compatibility:
// first, set icon that should definitely exist (arrow tower icon in base vcmi mod)
// second, try to switch to icon that should be provided by mod
// if mod is not up to date and does have arrow tower icon yet - second setFrame call will fail and retain previously set image
// for 1.2 release & later next line should be moved into 'else' block
icon->setFrame(unit->creatureIconIndex(), 0);
if (unit->unitType()->getId() == CreatureID::ARROW_TOWERS)
icon->setFrame(owner->getSiegeShooterIconID(), 1);
2023-12-28 18:17:01 +02:00
roundRect->setEnabled(currentTurn.has_value());
if(!owner->embedded)
round->setEnabled(currentTurn.has_value());
amount->setText(TextOperations::formatMetric(unit->getCount(), 4));
2023-12-23 23:00:28 +02:00
if(currentTurn && !owner->embedded)
2023-12-23 20:57:19 +02:00
{
std::string tmp = std::to_string(*currentTurn);
int len = graphics->fonts[FONT_SMALL]->getStringWidth(tmp);
roundRect->pos.w = len + 6;
round->setText(tmp);
}
if(stateIcon)
{
if(unit->defended((int)turn) || (turn > 0 && unit->defended((int)turn - 1)))
{
stateIcon->setFrame(0, 0);
stateIcon->visible = true;
}
else if(unit->waited((int)turn))
{
stateIcon->setFrame(1, 0);
stateIcon->visible = true;
}
else
{
stateIcon->visible = false;
}
}
}
else
{
boundUnitID = std::nullopt;
background->colorize(PlayerColor::NEUTRAL);
icon->visible = false;
icon->setFrame(0);
amount->setText("");
if(stateIcon)
stateIcon->visible = false;
}
}
std::optional<uint32_t> StackQueue::StackBox::getBoundUnitID() const
{
return boundUnitID;
}
bool StackQueue::StackBox::isBoundUnitHighlighted() const
{
auto unitIdsToHighlight = owner->owner.stacksController->getHoveredStacksUnitIds();
return vstd::contains(unitIdsToHighlight, getBoundUnitID());
}
void StackQueue::StackBox::showAll(Canvas & to)
{
CIntObject::showAll(to);
if(isBoundUnitHighlighted())
to.drawBorder(background->pos, Colors::CYAN, 2);
}
void StackQueue::StackBox::show(Canvas & to)
{
CIntObject::show(to);
if(isBoundUnitHighlighted())
to.drawBorder(background->pos, Colors::CYAN, 2);
}
2024-01-07 17:38:37 +02:00
void StackQueue::StackBox::showPopupWindow(const Point & cursorPosition)
{
auto stacks = owner->owner.getBattle()->battleGetAllStacks();
for(const CStack * stack : stacks)
if(boundUnitID.has_value() && stack->unitId() == *boundUnitID)
GH.windows().createAndPushWindow<CStackWindow>(stack, true);
}