2017-07-13 10:26:03 +02:00
|
|
|
/*
|
2022-12-11 23:16:23 +02:00
|
|
|
* BattleInterface.cpp, part of VCMI engine
|
2017-07-13 10:26:03 +02:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
*
|
|
|
|
*/
|
2011-12-14 00:35:28 +03:00
|
|
|
#include "StdInc.h"
|
2022-12-09 13:38:46 +02:00
|
|
|
#include "BattleInterface.h"
|
2011-12-14 00:35:28 +03:00
|
|
|
|
2022-12-09 13:38:46 +02:00
|
|
|
#include "BattleAnimationClasses.h"
|
|
|
|
#include "BattleActionsController.h"
|
|
|
|
#include "BattleInterfaceClasses.h"
|
|
|
|
#include "CreatureAnimation.h"
|
|
|
|
#include "BattleProjectileController.h"
|
|
|
|
#include "BattleEffectsController.h"
|
|
|
|
#include "BattleObstacleController.h"
|
|
|
|
#include "BattleSiegeController.h"
|
|
|
|
#include "BattleFieldController.h"
|
2022-12-21 17:06:47 +02:00
|
|
|
#include "BattleWindow.h"
|
2022-12-09 13:38:46 +02:00
|
|
|
#include "BattleStacksController.h"
|
|
|
|
#include "BattleRenderer.h"
|
2014-07-13 20:53:37 +03:00
|
|
|
|
|
|
|
#include "../CGameInfo.h"
|
2011-12-14 00:35:28 +03:00
|
|
|
#include "../CMessage.h"
|
2014-07-13 20:53:37 +03:00
|
|
|
#include "../CMusicHandler.h"
|
|
|
|
#include "../CPlayerInterface.h"
|
2022-12-11 22:09:57 +02:00
|
|
|
#include "../gui/Canvas.h"
|
2023-01-05 19:34:37 +02:00
|
|
|
#include "../gui/CursorHandler.h"
|
2014-07-13 20:53:37 +03:00
|
|
|
#include "../gui/CGuiHandler.h"
|
|
|
|
#include "../windows/CAdvmapInterface.h"
|
|
|
|
|
2011-12-14 00:35:28 +03:00
|
|
|
#include "../../CCallback.h"
|
2017-03-17 17:48:44 +02:00
|
|
|
#include "../../lib/CStack.h"
|
2012-09-29 13:59:43 +03:00
|
|
|
#include "../../lib/CConfigHandler.h"
|
2014-07-13 20:53:37 +03:00
|
|
|
#include "../../lib/CGeneralTextHandler.h"
|
|
|
|
#include "../../lib/CHeroHandler.h"
|
2011-12-14 00:35:28 +03:00
|
|
|
#include "../../lib/CondSh.h"
|
2022-11-27 02:26:02 +02:00
|
|
|
#include "../../lib/mapObjects/CGTownInstance.h"
|
2014-07-13 20:53:37 +03:00
|
|
|
#include "../../lib/NetPacks.h"
|
2012-02-20 00:03:43 +03:00
|
|
|
#include "../../lib/UnlockGuard.h"
|
2023-01-09 01:17:37 +02:00
|
|
|
#include "../../lib/TerrainHandler.h"
|
2009-01-15 19:01:08 +02:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
CondSh<BattleAction *> BattleInterface::givenCommand(nullptr);
|
2009-03-28 20:46:20 +02:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
BattleInterface::BattleInterface(const CCreatureSet *army1, const CCreatureSet *army2,
|
2018-07-25 00:36:48 +02:00
|
|
|
const CGHeroInstance *hero1, const CGHeroInstance *hero2,
|
2022-12-10 00:25:11 +02:00
|
|
|
std::shared_ptr<CPlayerInterface> att,
|
|
|
|
std::shared_ptr<CPlayerInterface> defen,
|
|
|
|
std::shared_ptr<CPlayerInterface> spectatorInt)
|
|
|
|
: attackingHeroInstance(hero1)
|
|
|
|
, defendingHeroInstance(hero2)
|
|
|
|
, attackerInt(att)
|
|
|
|
, defenderInt(defen)
|
|
|
|
, curInt(att)
|
|
|
|
, myTurn(false)
|
|
|
|
, moveSoundHander(-1)
|
2009-09-10 14:28:34 +03:00
|
|
|
{
|
2022-12-10 00:25:11 +02:00
|
|
|
for ( auto & event : animationEvents)
|
|
|
|
event.setn(false);
|
|
|
|
|
2017-06-03 07:25:10 +02:00
|
|
|
if(spectatorInt)
|
2018-07-25 00:36:48 +02:00
|
|
|
{
|
2017-06-03 07:25:10 +02:00
|
|
|
curInt = spectatorInt;
|
2018-07-25 00:36:48 +02:00
|
|
|
}
|
2017-06-03 07:25:10 +02:00
|
|
|
else if(!curInt)
|
2013-06-23 00:47:51 +03:00
|
|
|
{
|
|
|
|
//May happen when we are defending during network MP game -> attacker interface is just not present
|
2014-03-07 16:21:09 +03:00
|
|
|
curInt = defenderInt;
|
2013-06-23 00:47:51 +03:00
|
|
|
}
|
2010-01-28 19:23:01 +02:00
|
|
|
|
2017-06-14 03:53:26 +02:00
|
|
|
givenCommand.setn(nullptr);
|
2010-01-28 19:23:01 +02:00
|
|
|
|
2013-11-09 19:25:20 +03:00
|
|
|
//hot-seat -> check tactics for both players (defender may be local human)
|
2018-07-25 00:36:48 +02:00
|
|
|
if(attackerInt && attackerInt->cb->battleGetTacticDist())
|
2011-12-14 00:35:28 +03:00
|
|
|
tacticianInterface = attackerInt;
|
2018-07-25 00:36:48 +02:00
|
|
|
else if(defenderInt && defenderInt->cb->battleGetTacticDist())
|
2011-12-14 00:35:28 +03:00
|
|
|
tacticianInterface = defenderInt;
|
2010-01-28 19:23:01 +02:00
|
|
|
|
2013-11-09 19:25:20 +03:00
|
|
|
//if we found interface of player with tactics, then enter tactics mode
|
|
|
|
tacticsMode = static_cast<bool>(tacticianInterface);
|
2010-01-28 19:23:01 +02:00
|
|
|
|
2011-12-14 00:35:28 +03:00
|
|
|
//initializing armies
|
|
|
|
this->army1 = army1;
|
|
|
|
this->army2 = army2;
|
2009-09-17 15:59:04 +03:00
|
|
|
|
2022-12-13 13:58:16 +02:00
|
|
|
const CGTownInstance *town = curInt->cb->battleGetDefendedTown();
|
|
|
|
if(town && town->hasFort())
|
|
|
|
siegeController.reset(new BattleSiegeController(*this, town));
|
2022-11-27 02:26:02 +02:00
|
|
|
|
2022-12-21 17:06:47 +02:00
|
|
|
windowObject = std::make_shared<BattleWindow>(*this);
|
2022-12-13 13:58:16 +02:00
|
|
|
projectilesController.reset(new BattleProjectileController(*this));
|
|
|
|
stacksController.reset( new BattleStacksController(*this));
|
|
|
|
actionsController.reset( new BattleActionsController(*this));
|
|
|
|
effectsController.reset(new BattleEffectsController(*this));
|
|
|
|
obstacleController.reset(new BattleObstacleController(*this));
|
2009-09-10 14:28:34 +03:00
|
|
|
|
2011-12-14 00:35:28 +03:00
|
|
|
CCS->musich->stopMusic();
|
2022-12-16 23:22:04 +02:00
|
|
|
setAnimationCondition(EAnimationEvents::OPENING, true);
|
2019-03-22 22:39:53 +02:00
|
|
|
battleIntroSoundChannel = CCS->soundh->playSoundFromSet(CCS->soundh->battleIntroSounds);
|
2022-12-21 20:01:50 +02:00
|
|
|
auto onIntroPlayed = [this]()
|
2012-08-06 10:34:37 +03:00
|
|
|
{
|
2019-03-22 22:39:53 +02:00
|
|
|
if(LOCPLINT->battleInt)
|
|
|
|
{
|
2022-12-21 20:01:50 +02:00
|
|
|
boost::unique_lock<boost::recursive_mutex> un(*CPlayerInterface::pim);
|
2022-12-28 16:51:44 +02:00
|
|
|
onIntroSoundPlayed();
|
2019-03-22 22:39:53 +02:00
|
|
|
}
|
2012-08-06 10:34:37 +03:00
|
|
|
};
|
|
|
|
|
2022-12-21 17:02:53 +02:00
|
|
|
GH.pushInt(windowObject);
|
|
|
|
windowObject->blockUI(true);
|
|
|
|
windowObject->updateQueue();
|
2022-12-30 11:55:22 +02:00
|
|
|
|
|
|
|
if (battleIntroSoundChannel != -1)
|
|
|
|
CCS->soundh->setCallback(battleIntroSoundChannel, onIntroPlayed);
|
|
|
|
else
|
|
|
|
onIntroSoundPlayed();
|
2009-09-10 14:28:34 +03:00
|
|
|
}
|
|
|
|
|
2022-12-28 16:51:44 +02:00
|
|
|
void BattleInterface::onIntroSoundPlayed()
|
|
|
|
{
|
|
|
|
setAnimationCondition(EAnimationEvents::OPENING, false);
|
|
|
|
CCS->musich->playMusicFromSet("battle", true, true);
|
|
|
|
if(tacticsMode)
|
|
|
|
tacticNextStack(nullptr);
|
|
|
|
activateStack();
|
|
|
|
battleIntroSoundChannel = -1;
|
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
BattleInterface::~BattleInterface()
|
2009-09-10 14:28:34 +03:00
|
|
|
{
|
2018-07-25 00:36:48 +02:00
|
|
|
CPlayerInterface::battleInt = nullptr;
|
2022-11-20 19:11:34 +02:00
|
|
|
givenCommand.cond.notify_all(); //that two lines should make any stacksController->getActiveStack() waiting thread to finish
|
2012-02-20 00:03:43 +03:00
|
|
|
|
2016-10-28 23:37:20 +02:00
|
|
|
if (adventureInt && adventureInt->selection)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2022-12-01 22:06:42 +02:00
|
|
|
//FIXME: this should be moved to adventureInt which should restore correct track based on selection/active player
|
2023-01-01 17:10:47 +02:00
|
|
|
const auto * terrain = LOCPLINT->cb->getTile(adventureInt->selection->visitablePos())->terType;
|
2023-01-01 22:42:28 +02:00
|
|
|
CCS->musich->playMusicFromSet("terrain", terrain->getJsonKey(), true, false);
|
2022-12-16 22:37:44 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// may happen if user decided to close game while in battle
|
|
|
|
if (getAnimationCondition(EAnimationEvents::ACTION) == true)
|
|
|
|
logGlobal->error("Shutting down BattleInterface during animation playback!");
|
|
|
|
setAnimationCondition(EAnimationEvents::ACTION, false);
|
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::setPrintCellBorders(bool set)
|
2009-09-10 14:28:34 +03:00
|
|
|
{
|
2012-01-12 18:23:00 +03:00
|
|
|
Settings cellBorders = settings.write["battle"]["cellBorders"];
|
|
|
|
cellBorders->Bool() = set;
|
|
|
|
|
2022-11-20 19:11:34 +02:00
|
|
|
fieldController->redrawBackgroundWithHexes();
|
2011-12-14 00:35:28 +03:00
|
|
|
GH.totalRedraw();
|
2009-09-10 14:28:34 +03:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::setPrintStackRange(bool set)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2012-01-12 18:23:00 +03:00
|
|
|
Settings stackRange = settings.write["battle"]["stackRange"];
|
|
|
|
stackRange->Bool() = set;
|
|
|
|
|
2022-11-20 19:11:34 +02:00
|
|
|
fieldController->redrawBackgroundWithHexes();
|
2011-12-14 00:35:28 +03:00
|
|
|
GH.totalRedraw();
|
|
|
|
}
|
2009-09-10 14:28:34 +03:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::setPrintMouseShadow(bool set)
|
2009-09-10 14:28:34 +03:00
|
|
|
{
|
2012-01-12 18:23:00 +03:00
|
|
|
Settings shadow = settings.write["battle"]["mouseShadow"];
|
|
|
|
shadow->Bool() = set;
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
2009-09-10 14:28:34 +03:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::stackReset(const CStack * stack)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2022-11-20 19:11:34 +02:00
|
|
|
stacksController->stackReset(stack);
|
|
|
|
}
|
2014-03-07 16:21:09 +03:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::stackAdded(const CStack * stack)
|
2022-11-20 19:11:34 +02:00
|
|
|
{
|
2022-12-14 12:04:37 +02:00
|
|
|
stacksController->stackAdded(stack, false);
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::stackRemoved(uint32_t stackID)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2022-11-20 19:11:34 +02:00
|
|
|
stacksController->stackRemoved(stackID);
|
|
|
|
fieldController->redrawBackgroundWithHexes();
|
2022-12-21 17:02:53 +02:00
|
|
|
windowObject->updateQueue();
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
|
|
|
|
2022-12-14 12:04:37 +02:00
|
|
|
void BattleInterface::stackActivated(const CStack *stack)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2022-11-20 19:11:34 +02:00
|
|
|
stacksController->stackActivated(stack);
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
|
|
|
|
2022-12-18 18:26:43 +02:00
|
|
|
void BattleInterface::stackMoved(const CStack *stack, std::vector<BattleHex> destHex, int distance, bool teleport)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2022-12-18 18:26:43 +02:00
|
|
|
if (teleport)
|
|
|
|
stacksController->stackTeleported(stack, destHex, distance);
|
|
|
|
else
|
|
|
|
stacksController->stackMoved(stack, destHex, distance);
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::stacksAreAttacked(std::vector<StackAttackedInfo> attackedInfos)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2022-11-20 19:11:34 +02:00
|
|
|
stacksController->stacksAreAttacked(attackedInfos);
|
2017-09-27 16:35:30 +02:00
|
|
|
|
|
|
|
std::array<int, 2> killedBySide = {0, 0};
|
|
|
|
|
|
|
|
for(const StackAttackedInfo & attackedInfo : attackedInfos)
|
2009-11-08 16:44:58 +02:00
|
|
|
{
|
2017-09-27 16:35:30 +02:00
|
|
|
ui8 side = attackedInfo.defender->side;
|
|
|
|
killedBySide.at(side) += attackedInfo.amountKilled;
|
|
|
|
}
|
|
|
|
|
|
|
|
for(ui8 side = 0; side < 2; side++)
|
|
|
|
{
|
|
|
|
if(killedBySide.at(side) > killedBySide.at(1-side))
|
2022-12-08 19:41:02 +02:00
|
|
|
setHeroAnimation(side, EHeroAnimType::DEFEAT);
|
2017-09-27 16:35:30 +02:00
|
|
|
else if(killedBySide.at(side) < killedBySide.at(1-side))
|
2022-12-08 19:41:02 +02:00
|
|
|
setHeroAnimation(side, EHeroAnimType::VICTORY);
|
2009-11-08 16:44:58 +02:00
|
|
|
}
|
2009-03-21 18:03:07 +02:00
|
|
|
}
|
|
|
|
|
2022-12-11 12:29:11 +02:00
|
|
|
void BattleInterface::stackAttacking( const StackAttackInfo & attackInfo )
|
2009-03-21 18:03:07 +02:00
|
|
|
{
|
2022-12-11 12:29:11 +02:00
|
|
|
stacksController->stackAttacking(attackInfo);
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
2011-01-18 19:23:31 +02:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::newRoundFirst( int round )
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2022-12-16 23:22:04 +02:00
|
|
|
waitForAnimationCondition(EAnimationEvents::OPENING, false);
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
2011-01-18 19:23:31 +02:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::newRound(int number)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2022-12-21 17:02:53 +02:00
|
|
|
console->addText(CGI->generaltexth->allTexts[412]);
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::giveCommand(EActionType action, BattleHex tile, si32 additional)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
const CStack * actor = nullptr;
|
|
|
|
if(action != EActionType::HERO_SPELL && action != EActionType::RETREAT && action != EActionType::SURRENDER)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2022-11-20 19:11:34 +02:00
|
|
|
actor = stacksController->getActiveStack();
|
2009-01-15 19:01:08 +02:00
|
|
|
}
|
2012-04-03 02:23:14 +03:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
auto side = curInt->cb->playerToSide(curInt->playerID);
|
|
|
|
if(!side)
|
|
|
|
{
|
|
|
|
logGlobal->error("Player %s is not in battle", curInt->playerID.getStr());
|
|
|
|
return;
|
|
|
|
}
|
2012-04-03 02:23:14 +03:00
|
|
|
|
2022-11-20 19:11:34 +02:00
|
|
|
auto ba = new BattleAction(); //is deleted in CPlayerInterface::stacksController->getActiveStack()()
|
2017-07-20 06:08:49 +02:00
|
|
|
ba->side = side.get();
|
2011-12-14 00:35:28 +03:00
|
|
|
ba->actionType = action;
|
2017-07-20 06:08:49 +02:00
|
|
|
ba->aimToHex(tile);
|
|
|
|
ba->actionSubtype = additional;
|
|
|
|
|
|
|
|
sendCommand(ba, actor);
|
|
|
|
}
|
2011-01-18 19:23:31 +02:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::sendCommand(BattleAction *& command, const CStack * actor)
|
2017-07-20 06:08:49 +02:00
|
|
|
{
|
|
|
|
command->stackNumber = actor ? actor->unitId() : ((command->side == BattleSide::ATTACKER) ? -1 : -2);
|
|
|
|
|
|
|
|
if(!tacticsMode)
|
2010-03-02 13:40:29 +02:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
logGlobal->trace("Setting command for %s", (actor ? actor->nodeName() : "hero"));
|
2011-12-14 00:35:28 +03:00
|
|
|
myTurn = false;
|
2022-11-20 19:11:34 +02:00
|
|
|
stacksController->setActiveStack(nullptr);
|
2017-07-20 06:08:49 +02:00
|
|
|
givenCommand.setn(command);
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
curInt->cb->battleMakeTacticAction(command);
|
|
|
|
vstd::clear_pointer(command);
|
2022-11-20 19:11:34 +02:00
|
|
|
stacksController->setActiveStack(nullptr);
|
2012-04-03 02:23:14 +03:00
|
|
|
//next stack will be activated when action ends
|
2010-03-02 13:40:29 +02:00
|
|
|
}
|
2009-01-15 19:01:08 +02:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
const CGHeroInstance * BattleInterface::getActiveHero()
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2022-11-20 19:11:34 +02:00
|
|
|
const CStack *attacker = stacksController->getActiveStack();
|
2017-07-01 10:34:00 +02:00
|
|
|
if(!attacker)
|
2009-01-15 19:01:08 +02:00
|
|
|
{
|
2013-06-26 14:18:27 +03:00
|
|
|
return nullptr;
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
|
|
|
|
2017-07-01 10:34:00 +02:00
|
|
|
if(attacker->side == BattleSide::ATTACKER)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
|
|
|
return attackingHeroInstance;
|
|
|
|
}
|
2012-02-16 20:10:58 +03:00
|
|
|
|
2011-12-14 00:35:28 +03:00
|
|
|
return defendingHeroInstance;
|
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::stackIsCatapulting(const CatapultAttack & ca)
|
2009-09-15 15:20:11 +03:00
|
|
|
{
|
2022-11-17 18:50:12 +02:00
|
|
|
if (siegeController)
|
|
|
|
siegeController->stackIsCatapulting(ca);
|
|
|
|
}
|
2016-02-10 06:10:32 +02:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::gateStateChanged(const EGateState state)
|
2022-11-17 18:50:12 +02:00
|
|
|
{
|
|
|
|
if (siegeController)
|
|
|
|
siegeController->gateStateChanged(state);
|
2009-09-15 15:20:11 +03:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::battleFinished(const BattleResult& br)
|
2009-01-15 19:01:08 +02:00
|
|
|
{
|
2022-12-15 23:24:03 +02:00
|
|
|
assert(getAnimationCondition(EAnimationEvents::ACTION) == false);
|
2022-12-10 00:25:11 +02:00
|
|
|
waitForAnimationCondition(EAnimationEvents::ACTION, false);
|
2022-11-20 19:11:34 +02:00
|
|
|
stacksController->setActiveStack(nullptr);
|
2009-01-15 19:01:08 +02:00
|
|
|
|
2022-12-18 22:32:07 +02:00
|
|
|
CCS->curh->set(Cursor::Map::POINTER);
|
2022-12-29 22:11:47 +02:00
|
|
|
curInt->waitWhileDialog();
|
2022-12-30 00:52:23 +02:00
|
|
|
|
2017-06-03 07:25:10 +02:00
|
|
|
if(settings["session"]["spectate"].Bool() && settings["session"]["spectate-skip-battle-result"].Bool())
|
|
|
|
{
|
2022-12-21 17:02:53 +02:00
|
|
|
windowObject->close();
|
2017-06-03 07:25:10 +02:00
|
|
|
return;
|
|
|
|
}
|
2012-02-16 20:10:58 +03:00
|
|
|
|
2022-12-25 17:44:40 +02:00
|
|
|
GH.pushInt(std::make_shared<BattleResultWindow>(br, *(this->curInt)));
|
2017-03-19 04:15:31 +02:00
|
|
|
curInt->waitWhileDialog(); // Avoid freeze when AI end turn after battle. Check bug #1897
|
2018-07-25 00:36:48 +02:00
|
|
|
CPlayerInterface::battleInt = nullptr;
|
2009-04-16 17:01:27 +03:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::spellCast(const BattleSpellCast * sc)
|
2009-08-26 17:09:55 +03:00
|
|
|
{
|
2022-12-21 17:02:53 +02:00
|
|
|
windowObject->blockUI(true);
|
2022-12-12 21:17:36 +02:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
const SpellID spellID = sc->spellID;
|
|
|
|
const CSpell * spell = spellID.toSpell();
|
2022-12-11 12:29:11 +02:00
|
|
|
auto targetedTile = sc->tile;
|
2017-07-20 06:08:49 +02:00
|
|
|
|
2022-12-01 22:06:42 +02:00
|
|
|
assert(spell);
|
2017-07-20 06:08:49 +02:00
|
|
|
if(!spell)
|
|
|
|
return;
|
2009-08-26 17:09:55 +03:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
const std::string & castSoundPath = spell->getCastSound();
|
2015-02-07 10:13:24 +02:00
|
|
|
|
2016-10-28 23:37:20 +02:00
|
|
|
if (!castSoundPath.empty())
|
2022-12-11 12:29:11 +02:00
|
|
|
{
|
2022-12-14 14:48:02 +02:00
|
|
|
auto group = spell->animationInfo.projectile.empty() ?
|
|
|
|
EAnimationEvents::HIT:
|
2022-12-25 17:44:40 +02:00
|
|
|
EAnimationEvents::BEFORE_HIT;//FIXME: recheck whether this should be on projectile spawning
|
2022-12-14 14:48:02 +02:00
|
|
|
|
|
|
|
executeOnAnimationCondition(group, true, [=]() {
|
2022-12-11 12:29:11 +02:00
|
|
|
CCS->soundh->playSound(castSoundPath);
|
|
|
|
});
|
|
|
|
}
|
2014-11-27 20:06:11 +02:00
|
|
|
|
2022-12-01 22:06:42 +02:00
|
|
|
if ( sc->activeCast )
|
2014-11-27 20:06:11 +02:00
|
|
|
{
|
2022-12-01 22:06:42 +02:00
|
|
|
const CStack * casterStack = curInt->cb->battleGetStackByID(sc->casterStack);
|
2014-11-27 20:33:57 +02:00
|
|
|
|
2022-12-01 22:06:42 +02:00
|
|
|
if(casterStack != nullptr )
|
2014-11-27 20:06:11 +02:00
|
|
|
{
|
2022-12-11 12:29:11 +02:00
|
|
|
executeOnAnimationCondition(EAnimationEvents::BEFORE_HIT, true, [=]()
|
|
|
|
{
|
2022-12-12 22:04:25 +02:00
|
|
|
stacksController->addNewAnim(new CastAnimation(*this, casterStack, targetedTile, curInt->cb->battleGetStackByPos(targetedTile), spell));
|
2022-12-22 00:25:35 +02:00
|
|
|
displaySpellCast(spell, casterStack->getPosition());
|
2022-12-11 12:29:11 +02:00
|
|
|
});
|
2022-12-01 22:06:42 +02:00
|
|
|
}
|
|
|
|
else
|
2009-08-26 17:09:55 +03:00
|
|
|
{
|
2022-12-13 18:49:35 +02:00
|
|
|
auto hero = sc->side ? defendingHero : attackingHero;
|
|
|
|
assert(hero);
|
2017-09-05 19:45:29 +02:00
|
|
|
|
2022-12-11 12:29:11 +02:00
|
|
|
executeOnAnimationCondition(EAnimationEvents::BEFORE_HIT, true, [=]()
|
|
|
|
{
|
2022-12-13 18:49:35 +02:00
|
|
|
stacksController->addNewAnim(new HeroCastAnimation(*this, hero, targetedTile, curInt->cb->battleGetStackByPos(targetedTile), spell));
|
2022-12-11 12:29:11 +02:00
|
|
|
});
|
2014-11-26 23:27:38 +02:00
|
|
|
}
|
2015-03-22 11:18:58 +02:00
|
|
|
}
|
2017-09-08 13:25:12 +02:00
|
|
|
|
2022-12-11 12:29:11 +02:00
|
|
|
executeOnAnimationCondition(EAnimationEvents::HIT, true, [=](){
|
2022-12-22 00:25:35 +02:00
|
|
|
displaySpellHit(spell, targetedTile);
|
2022-12-11 12:29:11 +02:00
|
|
|
});
|
2015-03-22 11:18:58 +02:00
|
|
|
|
2015-09-14 04:45:05 +02:00
|
|
|
//queuing affect animation
|
2017-07-20 06:08:49 +02:00
|
|
|
for(auto & elem : sc->affectedCres)
|
2014-11-26 23:27:38 +02:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
auto stack = curInt->cb->battleGetStackByID(elem, false);
|
2022-12-11 12:29:11 +02:00
|
|
|
assert(stack);
|
2017-07-20 06:08:49 +02:00
|
|
|
if(stack)
|
2022-12-11 12:29:11 +02:00
|
|
|
{
|
|
|
|
executeOnAnimationCondition(EAnimationEvents::HIT, true, [=](){
|
2022-12-22 00:25:35 +02:00
|
|
|
displaySpellEffect(spell, stack->getPosition());
|
2022-12-11 12:29:11 +02:00
|
|
|
});
|
|
|
|
}
|
2015-09-14 04:45:05 +02:00
|
|
|
}
|
2015-02-07 10:13:24 +02:00
|
|
|
|
2022-12-17 17:35:15 +02:00
|
|
|
for(auto & elem : sc->reflectedCres)
|
2015-09-14 04:45:05 +02:00
|
|
|
{
|
2022-12-17 17:35:15 +02:00
|
|
|
auto stack = curInt->cb->battleGetStackByID(elem, false);
|
2022-12-11 12:29:11 +02:00
|
|
|
assert(stack);
|
2022-12-17 17:35:15 +02:00
|
|
|
executeOnAnimationCondition(EAnimationEvents::HIT, true, [=](){
|
|
|
|
effectsController->displayEffect(EBattleEffect::MAGIC_MIRROR, stack->getPosition());
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2023-01-07 14:27:12 +02:00
|
|
|
if (!sc->resistedCres.empty())
|
|
|
|
{
|
|
|
|
executeOnAnimationCondition(EAnimationEvents::HIT, true, [=](){
|
|
|
|
CCS->soundh->playSound("MAGICRES");
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2022-12-17 17:35:15 +02:00
|
|
|
for(auto & elem : sc->resistedCres)
|
|
|
|
{
|
|
|
|
auto stack = curInt->cb->battleGetStackByID(elem, false);
|
|
|
|
assert(stack);
|
|
|
|
executeOnAnimationCondition(EAnimationEvents::HIT, true, [=](){
|
|
|
|
effectsController->displayEffect(EBattleEffect::RESISTANCE, stack->getPosition());
|
|
|
|
});
|
2014-11-26 23:27:38 +02:00
|
|
|
}
|
|
|
|
|
2011-12-14 00:35:28 +03:00
|
|
|
//mana absorption
|
2016-10-28 23:37:20 +02:00
|
|
|
if (sc->manaGained > 0)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2023-01-05 14:16:01 +02:00
|
|
|
Point leftHero = Point(15, 30);
|
|
|
|
Point rightHero = Point(755, 30);
|
2022-12-11 12:29:11 +02:00
|
|
|
bool side = sc->side;
|
|
|
|
|
|
|
|
executeOnAnimationCondition(EAnimationEvents::AFTER_HIT, true, [=](){
|
2022-12-25 21:39:55 +02:00
|
|
|
stacksController->addNewAnim(new EffectAnimation(*this, side ? "SP07_A.DEF" : "SP07_B.DEF", leftHero));
|
|
|
|
stacksController->addNewAnim(new EffectAnimation(*this, side ? "SP07_B.DEF" : "SP07_A.DEF", rightHero));
|
2022-12-11 12:29:11 +02:00
|
|
|
});
|
2009-01-15 19:01:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::battleStacksEffectsSet(const SetStackEffect & sse)
|
2009-01-15 19:01:08 +02:00
|
|
|
{
|
2022-11-20 19:11:34 +02:00
|
|
|
if(stacksController->getActiveStack() != nullptr)
|
|
|
|
fieldController->redrawBackgroundWithHexes();
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
2011-05-26 17:47:45 +03:00
|
|
|
|
2022-12-12 23:31:18 +02:00
|
|
|
void BattleInterface::setHeroAnimation(ui8 side, EHeroAnimType phase)
|
2017-09-27 16:35:30 +02:00
|
|
|
{
|
|
|
|
if(side == BattleSide::ATTACKER)
|
2017-10-07 23:04:43 +02:00
|
|
|
{
|
|
|
|
if(attackingHero)
|
|
|
|
attackingHero->setPhase(phase);
|
|
|
|
}
|
2017-09-27 16:35:30 +02:00
|
|
|
else
|
2017-10-07 23:04:43 +02:00
|
|
|
{
|
|
|
|
if(defendingHero)
|
|
|
|
defendingHero->setPhase(phase);
|
|
|
|
}
|
2017-09-27 16:35:30 +02:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::displayBattleLog(const std::vector<MetaString> & battleLog)
|
2017-07-20 06:08:49 +02:00
|
|
|
{
|
|
|
|
for(const auto & line : battleLog)
|
|
|
|
{
|
|
|
|
std::string formatted = line.toString();
|
|
|
|
boost::algorithm::trim(formatted);
|
2022-12-21 17:02:53 +02:00
|
|
|
appendBattleLog(formatted);
|
2017-07-20 06:08:49 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-22 00:25:35 +02:00
|
|
|
void BattleInterface::displaySpellAnimationQueue(const CSpell * spell, const CSpell::TAnimationQueue & q, BattleHex destinationTile, bool isHit)
|
2015-03-22 15:47:20 +02:00
|
|
|
{
|
2021-02-20 03:57:50 +02:00
|
|
|
for(const CSpell::TAnimation & animation : q)
|
2015-03-22 15:47:20 +02:00
|
|
|
{
|
Entities redesign and a few ERM features
* Made most Handlers derived from CHandlerBase and moved service API there.
* Declared existing Entity APIs.
* Added basic script context caching
* Started Lua script module
* Started Lua spell effect API
* Started script state persistence
* Started battle info callback binding
* CommitPackage removed
* Extracted spells::Caster to own header; Expanded Spell API.
* implemented !!MC:S, !!FU:E, !!FU:P, !!MA, !!VR:H, !!VR:C
* !!BU:C, !!BU:E, !!BU:G, !!BU:M implemented
* Allow use of "MC:S@varName@" to declare normal variable (technically v-variable with string key)
* Re-enabled VERM macros.
* !?GM0 added
* !?TM implemented
* Added !!MF:N
* Started !?OB, !!BM, !!HE, !!OW, !!UN
* Added basic support of w-variables
* Added support for ERM indirect variables
* Made !?FU regular trigger
* !!re (ERA loop receiver) implemented
* Fixed ERM receivers with zero args.
2018-03-17 16:58:30 +02:00
|
|
|
if(animation.pause > 0)
|
2022-12-12 22:04:25 +02:00
|
|
|
stacksController->addNewAnim(new DummyAnimation(*this, animation.pause));
|
2022-12-22 00:25:35 +02:00
|
|
|
|
|
|
|
if (!animation.effectName.empty())
|
|
|
|
{
|
|
|
|
const CStack * destStack = getCurrentPlayerInterface()->cb->battleGetStackByPos(destinationTile, false);
|
|
|
|
|
|
|
|
if (destStack)
|
|
|
|
stacksController->addNewAnim(new ColorTransformAnimation(*this, destStack, animation.effectName, spell ));
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!animation.resourceName.empty())
|
2022-12-01 22:06:42 +02:00
|
|
|
{
|
2022-12-02 01:55:09 +02:00
|
|
|
int flags = 0;
|
|
|
|
|
|
|
|
if (isHit)
|
2022-12-25 21:39:55 +02:00
|
|
|
flags |= EffectAnimation::FORCE_ON_TOP;
|
2022-12-02 01:55:09 +02:00
|
|
|
|
|
|
|
if (animation.verticalPosition == VerticalPosition::BOTTOM)
|
2022-12-25 21:39:55 +02:00
|
|
|
flags |= EffectAnimation::ALIGN_TO_BOTTOM;
|
2022-12-02 01:55:09 +02:00
|
|
|
|
|
|
|
if (!destinationTile.isValid())
|
2022-12-25 21:39:55 +02:00
|
|
|
flags |= EffectAnimation::SCREEN_FILL;
|
2022-12-02 01:55:09 +02:00
|
|
|
|
2022-12-01 22:06:42 +02:00
|
|
|
if (!destinationTile.isValid())
|
2022-12-25 21:39:55 +02:00
|
|
|
stacksController->addNewAnim(new EffectAnimation(*this, animation.resourceName, flags));
|
2022-12-01 22:06:42 +02:00
|
|
|
else
|
2022-12-25 21:39:55 +02:00
|
|
|
stacksController->addNewAnim(new EffectAnimation(*this, animation.resourceName, destinationTile, flags));
|
2022-12-01 22:06:42 +02:00
|
|
|
}
|
2016-01-26 08:37:55 +02:00
|
|
|
}
|
2015-03-22 15:47:20 +02:00
|
|
|
}
|
|
|
|
|
2022-12-22 00:25:35 +02:00
|
|
|
void BattleInterface::displaySpellCast(const CSpell * spell, BattleHex destinationTile)
|
2014-11-27 23:36:14 +02:00
|
|
|
{
|
2021-02-20 03:57:50 +02:00
|
|
|
if(spell)
|
2022-12-22 00:25:35 +02:00
|
|
|
displaySpellAnimationQueue(spell, spell->animationInfo.cast, destinationTile, false);
|
2021-02-20 03:57:50 +02:00
|
|
|
}
|
2014-11-27 23:36:14 +02:00
|
|
|
|
2022-12-22 00:25:35 +02:00
|
|
|
void BattleInterface::displaySpellEffect(const CSpell * spell, BattleHex destinationTile)
|
2021-02-20 03:57:50 +02:00
|
|
|
{
|
|
|
|
if(spell)
|
2022-12-22 00:25:35 +02:00
|
|
|
displaySpellAnimationQueue(spell, spell->animationInfo.affect, destinationTile, false);
|
2014-11-27 23:36:14 +02:00
|
|
|
}
|
|
|
|
|
2022-12-22 00:25:35 +02:00
|
|
|
void BattleInterface::displaySpellHit(const CSpell * spell, BattleHex destinationTile)
|
2014-11-27 23:36:14 +02:00
|
|
|
{
|
2021-02-20 03:57:50 +02:00
|
|
|
if(spell)
|
2022-12-22 00:25:35 +02:00
|
|
|
displaySpellAnimationQueue(spell, spell->animationInfo.hit, destinationTile, true);
|
2014-11-27 23:36:14 +02:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::setAnimSpeed(int set)
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2012-01-12 18:23:00 +03:00
|
|
|
Settings speed = settings.write["battle"]["animationSpeed"];
|
2023-01-27 23:16:02 +02:00
|
|
|
speed->Float() = float(set);
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
2011-02-23 05:57:45 +02:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
int BattleInterface::getAnimSpeed() const
|
2011-12-14 00:35:28 +03:00
|
|
|
{
|
2017-06-03 07:25:10 +02:00
|
|
|
if(settings["session"]["spectate"].Bool() && !settings["session"]["spectate-battle-speed"].isNull())
|
2020-10-01 10:38:06 +02:00
|
|
|
return static_cast<int>(vstd::round(settings["session"]["spectate-battle-speed"].Float() *100));
|
2017-06-03 07:25:10 +02:00
|
|
|
|
2020-10-01 10:38:06 +02:00
|
|
|
return static_cast<int>(vstd::round(settings["battle"]["animationSpeed"].Float() *100));
|
2013-07-06 19:10:20 +03:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
CPlayerInterface *BattleInterface::getCurrentPlayerInterface() const
|
2013-11-03 19:44:47 +03:00
|
|
|
{
|
|
|
|
return curInt.get();
|
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::trySetActivePlayer( PlayerColor player )
|
2013-07-06 19:10:20 +03:00
|
|
|
{
|
2022-11-20 19:11:34 +02:00
|
|
|
if ( attackerInt && attackerInt->playerID == player )
|
|
|
|
curInt = attackerInt;
|
2013-07-21 13:10:38 +03:00
|
|
|
|
2022-11-20 19:11:34 +02:00
|
|
|
if ( defenderInt && defenderInt->playerID == player )
|
|
|
|
curInt = defenderInt;
|
2009-09-20 15:47:40 +03:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::activateStack()
|
2009-09-20 15:47:40 +03:00
|
|
|
{
|
2022-11-20 19:11:34 +02:00
|
|
|
stacksController->activateStack();
|
2013-11-02 23:07:45 +03:00
|
|
|
|
2022-11-20 19:11:34 +02:00
|
|
|
const CStack * s = stacksController->getActiveStack();
|
2022-11-03 20:01:20 +02:00
|
|
|
if(!s)
|
|
|
|
return;
|
2009-09-24 16:23:52 +03:00
|
|
|
|
2022-11-20 19:11:34 +02:00
|
|
|
myTurn = true;
|
2022-12-21 17:02:53 +02:00
|
|
|
windowObject->updateQueue();
|
2022-12-21 20:01:50 +02:00
|
|
|
windowObject->blockUI(false);
|
2022-11-20 19:11:34 +02:00
|
|
|
fieldController->redrawBackgroundWithHexes();
|
2022-11-20 22:56:42 +02:00
|
|
|
actionsController->activateStack();
|
2012-05-05 00:16:39 +03:00
|
|
|
GH.fakeMouseMove();
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
2009-09-20 15:47:40 +03:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::endAction(const BattleAction* action)
|
2012-02-16 20:10:58 +03:00
|
|
|
{
|
2016-10-28 23:37:20 +02:00
|
|
|
const CStack *stack = curInt->cb->battleGetStackByID(action->stackNumber);
|
2013-05-19 18:14:23 +03:00
|
|
|
|
2022-11-20 19:11:34 +02:00
|
|
|
stacksController->endAction(action);
|
2022-12-21 17:02:53 +02:00
|
|
|
windowObject->updateQueue();
|
2011-12-14 00:35:28 +03:00
|
|
|
|
2022-12-12 21:17:36 +02:00
|
|
|
//stack ended movement in tactics phase -> select the next one
|
|
|
|
if (tacticsMode)
|
2022-11-18 17:54:10 +02:00
|
|
|
tacticNextStack(stack);
|
2012-04-03 02:23:14 +03:00
|
|
|
|
2022-12-12 21:17:36 +02:00
|
|
|
//we have activated next stack after sending request that has been just realized -> blockmap due to movement has changed
|
|
|
|
if(action->actionType == EActionType::HERO_SPELL)
|
2022-11-20 19:11:34 +02:00
|
|
|
fieldController->redrawBackgroundWithHexes();
|
2009-01-15 19:01:08 +02:00
|
|
|
}
|
|
|
|
|
2022-12-21 17:02:53 +02:00
|
|
|
void BattleInterface::appendBattleLog(const std::string & newEntry)
|
2009-01-15 19:01:08 +02:00
|
|
|
{
|
2022-12-21 17:02:53 +02:00
|
|
|
console->addText(newEntry);
|
2009-01-15 19:01:08 +02:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::startAction(const BattleAction* action)
|
2009-01-15 19:01:08 +02:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
if(action->actionType == EActionType::END_TACTIC_PHASE)
|
2009-01-15 19:01:08 +02:00
|
|
|
{
|
2022-12-21 17:02:53 +02:00
|
|
|
windowObject->tacticPhaseEnded();
|
2011-12-14 00:35:28 +03:00
|
|
|
return;
|
2009-01-15 19:01:08 +02:00
|
|
|
}
|
2011-12-14 00:35:28 +03:00
|
|
|
|
|
|
|
const CStack *stack = curInt->cb->battleGetStackByID(action->stackNumber);
|
|
|
|
|
2016-10-28 23:37:20 +02:00
|
|
|
if (stack)
|
2009-01-15 19:01:08 +02:00
|
|
|
{
|
2022-12-21 17:02:53 +02:00
|
|
|
windowObject->updateQueue();
|
2009-01-15 19:01:08 +02:00
|
|
|
}
|
2011-12-14 00:35:28 +03:00
|
|
|
else
|
2009-01-15 19:01:08 +02:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
assert(action->actionType == EActionType::HERO_SPELL); //only cast spell is valid action without acting stack number
|
2009-01-15 19:01:08 +02:00
|
|
|
}
|
|
|
|
|
2022-11-20 19:11:34 +02:00
|
|
|
stacksController->startAction(action);
|
2010-08-30 02:12:34 +03:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
if(action->actionType == EActionType::HERO_SPELL) //when hero casts spell
|
2011-12-14 00:35:28 +03:00
|
|
|
return;
|
2017-09-27 16:35:30 +02:00
|
|
|
|
2016-10-28 23:37:20 +02:00
|
|
|
if (!stack)
|
2010-08-30 02:12:34 +03:00
|
|
|
{
|
2017-08-11 13:38:10 +02:00
|
|
|
logGlobal->error("Something wrong with stackNumber in actionStarted. Stack number: %d", action->stackNumber);
|
2011-12-14 00:35:28 +03:00
|
|
|
return;
|
2009-01-15 19:01:08 +02:00
|
|
|
}
|
|
|
|
|
2022-11-24 16:30:04 +02:00
|
|
|
effectsController->startAction(action);
|
2011-12-14 00:35:28 +03:00
|
|
|
}
|
2011-01-08 21:38:42 +02:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::tacticPhaseEnd()
|
2009-01-15 19:01:08 +02:00
|
|
|
{
|
2022-11-20 19:11:34 +02:00
|
|
|
stacksController->setActiveStack(nullptr);
|
2011-12-14 00:35:28 +03:00
|
|
|
tacticsMode = false;
|
2009-01-15 19:01:08 +02:00
|
|
|
}
|
|
|
|
|
2011-12-14 00:35:28 +03:00
|
|
|
static bool immobile(const CStack *s)
|
2009-01-15 19:01:08 +02:00
|
|
|
{
|
2011-12-14 00:35:28 +03:00
|
|
|
return !s->Speed(0, true); //should bound stacks be immobile?
|
2009-01-15 19:01:08 +02:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::tacticNextStack(const CStack * current)
|
2009-01-15 19:01:08 +02:00
|
|
|
{
|
2016-10-28 23:37:20 +02:00
|
|
|
if (!current)
|
2022-11-20 19:11:34 +02:00
|
|
|
current = stacksController->getActiveStack();
|
2012-04-03 02:23:14 +03:00
|
|
|
|
2012-03-01 14:57:38 +03:00
|
|
|
//no switching stacks when the current one is moving
|
2022-12-15 23:24:03 +02:00
|
|
|
assert(getAnimationCondition(EAnimationEvents::ACTION) == false);
|
2022-12-10 00:25:11 +02:00
|
|
|
waitForAnimationCondition(EAnimationEvents::ACTION, false);
|
2012-03-01 14:57:38 +03:00
|
|
|
|
2011-12-14 00:35:28 +03:00
|
|
|
TStacks stacksOfMine = tacticianInterface->cb->battleGetStacks(CBattleCallback::ONLY_MINE);
|
2016-10-28 23:37:20 +02:00
|
|
|
vstd::erase_if (stacksOfMine, &immobile);
|
|
|
|
if (stacksOfMine.empty())
|
2016-08-09 17:15:58 +02:00
|
|
|
{
|
2022-11-18 17:54:10 +02:00
|
|
|
tacticPhaseEnd();
|
2016-08-09 17:15:58 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-06-29 16:05:48 +03:00
|
|
|
auto it = vstd::find(stacksOfMine, current);
|
2016-10-28 23:37:20 +02:00
|
|
|
if (it != stacksOfMine.end() && ++it != stacksOfMine.end())
|
2011-12-14 00:35:28 +03:00
|
|
|
stackActivated(*it);
|
|
|
|
else
|
|
|
|
stackActivated(stacksOfMine.front());
|
2012-04-04 11:03:52 +03:00
|
|
|
|
2009-01-15 19:01:08 +02:00
|
|
|
}
|
2009-08-24 15:55:05 +03:00
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::obstaclePlaced(const std::vector<std::shared_ptr<const CObstacleInstance>> oi)
|
2012-05-05 00:16:39 +03:00
|
|
|
{
|
2022-11-17 19:36:25 +02:00
|
|
|
obstacleController->obstaclePlaced(oi);
|
2012-05-05 00:16:39 +03:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
const CGHeroInstance *BattleInterface::currentHero() const
|
2012-08-26 12:07:48 +03:00
|
|
|
{
|
2022-12-13 13:58:16 +02:00
|
|
|
if (attackingHeroInstance && attackingHeroInstance->tempOwner == curInt->playerID)
|
2012-08-26 12:07:48 +03:00
|
|
|
return attackingHeroInstance;
|
2022-12-13 13:58:16 +02:00
|
|
|
|
|
|
|
if (defendingHeroInstance && defendingHeroInstance->tempOwner == curInt->playerID)
|
2012-08-26 12:07:48 +03:00
|
|
|
return defendingHeroInstance;
|
2022-12-13 13:58:16 +02:00
|
|
|
|
|
|
|
return nullptr;
|
2012-08-26 12:07:48 +03:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
InfoAboutHero BattleInterface::enemyHero() const
|
2012-08-26 12:07:48 +03:00
|
|
|
{
|
|
|
|
InfoAboutHero ret;
|
2016-10-28 23:37:20 +02:00
|
|
|
if (attackingHeroInstance->tempOwner == curInt->playerID)
|
2012-08-26 12:07:48 +03:00
|
|
|
curInt->cb->getHeroInfo(defendingHeroInstance, ret);
|
|
|
|
else
|
|
|
|
curInt->cb->getHeroInfo(attackingHeroInstance, ret);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::requestAutofightingAIToTakeAction()
|
2013-06-23 00:47:51 +03:00
|
|
|
{
|
2013-06-23 14:25:48 +03:00
|
|
|
assert(curInt->isAutoFightOn);
|
2013-06-23 00:47:51 +03:00
|
|
|
|
2017-07-19 01:06:05 +02:00
|
|
|
boost::thread aiThread([&]()
|
2013-06-23 00:47:51 +03:00
|
|
|
{
|
2022-12-23 14:40:45 +02:00
|
|
|
auto ba = std::make_unique<BattleAction>(curInt->autofightingAI->activeStack(stacksController->getActiveStack()));
|
2013-06-23 00:47:51 +03:00
|
|
|
|
2022-04-04 09:16:32 +02:00
|
|
|
if(curInt->cb->battleIsFinished())
|
|
|
|
{
|
|
|
|
return; // battle finished with spellcast
|
|
|
|
}
|
|
|
|
|
2016-10-28 23:37:20 +02:00
|
|
|
if (curInt->isAutoFightOn)
|
2013-06-23 00:47:51 +03:00
|
|
|
{
|
2016-10-28 23:37:20 +02:00
|
|
|
if (tacticsMode)
|
2013-11-09 19:25:20 +03:00
|
|
|
{
|
|
|
|
// Always end tactics mode. Player interface is blocked currently, so it's not possible that
|
|
|
|
// the AI can take any action except end tactics phase (AI actions won't be triggered)
|
|
|
|
//TODO implement the possibility that the AI will be triggered for further actions
|
|
|
|
//TODO any solution to merge tactics phase & normal phase in the way it is handled by the player and battle interface?
|
2022-11-20 19:11:34 +02:00
|
|
|
stacksController->setActiveStack(nullptr);
|
2013-11-09 19:25:20 +03:00
|
|
|
tacticsMode = false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2017-06-14 03:53:26 +02:00
|
|
|
givenCommand.setn(ba.release());
|
2013-11-09 19:25:20 +03:00
|
|
|
}
|
2013-06-23 00:47:51 +03:00
|
|
|
}
|
2013-06-23 14:25:48 +03:00
|
|
|
else
|
|
|
|
{
|
2016-11-25 21:12:22 +02:00
|
|
|
boost::unique_lock<boost::recursive_mutex> un(*CPlayerInterface::pim);
|
2013-06-23 14:25:48 +03:00
|
|
|
activateStack();
|
|
|
|
}
|
2013-06-23 00:47:51 +03:00
|
|
|
});
|
2014-03-07 16:21:09 +03:00
|
|
|
|
2013-06-24 17:35:27 +03:00
|
|
|
aiThread.detach();
|
2013-06-23 00:47:51 +03:00
|
|
|
}
|
|
|
|
|
2022-12-09 13:26:17 +02:00
|
|
|
void BattleInterface::castThisSpell(SpellID spellID)
|
2022-11-20 22:56:42 +02:00
|
|
|
{
|
|
|
|
actionsController->castThisSpell(spellID);
|
|
|
|
}
|
2022-12-10 00:25:11 +02:00
|
|
|
|
|
|
|
void BattleInterface::setAnimationCondition( EAnimationEvents event, bool state)
|
|
|
|
{
|
2022-12-16 22:37:44 +02:00
|
|
|
logAnim->debug("setAnimationCondition: %d -> %s", static_cast<int>(event), state ? "ON" : "OFF");
|
2022-12-10 00:25:11 +02:00
|
|
|
|
|
|
|
size_t index = static_cast<size_t>(event);
|
|
|
|
animationEvents[index].setn(state);
|
|
|
|
|
2023-01-04 23:04:48 +02:00
|
|
|
decltype(awaitingEvents) executingEvents;
|
|
|
|
|
2022-12-10 00:25:11 +02:00
|
|
|
for (auto it = awaitingEvents.begin(); it != awaitingEvents.end();)
|
|
|
|
{
|
|
|
|
if (it->event == event && it->eventState == state)
|
|
|
|
{
|
2023-01-04 23:04:48 +02:00
|
|
|
executingEvents.push_back(*it);
|
2022-12-10 00:25:11 +02:00
|
|
|
it = awaitingEvents.erase(it);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
++it;
|
|
|
|
}
|
2023-01-04 23:04:48 +02:00
|
|
|
|
|
|
|
for (auto const & event : executingEvents)
|
|
|
|
event.action();
|
2022-12-10 00:25:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool BattleInterface::getAnimationCondition( EAnimationEvents event)
|
|
|
|
{
|
|
|
|
size_t index = static_cast<size_t>(event);
|
|
|
|
return animationEvents[index].get();
|
|
|
|
}
|
|
|
|
|
|
|
|
void BattleInterface::waitForAnimationCondition( EAnimationEvents event, bool state)
|
|
|
|
{
|
|
|
|
auto unlockPim = vstd::makeUnlockGuard(*CPlayerInterface::pim);
|
|
|
|
size_t index = static_cast<size_t>(event);
|
|
|
|
animationEvents[index].waitUntil(state);
|
|
|
|
}
|
|
|
|
|
|
|
|
void BattleInterface::executeOnAnimationCondition( EAnimationEvents event, bool state, const AwaitingAnimationAction & action)
|
|
|
|
{
|
|
|
|
awaitingEvents.push_back({action, event, state});
|
|
|
|
}
|