1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-04 09:42:40 +02:00
vcmi/client/battle/BattleInterface.cpp
2023-11-14 21:52:30 +01:00

832 lines
21 KiB
C++

/*
* BattleInterface.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 "BattleInterface.h"
#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"
#include "BattleWindow.h"
#include "BattleStacksController.h"
#include "BattleRenderer.h"
#include "../CGameInfo.h"
#include "../CMusicHandler.h"
#include "../CPlayerInterface.h"
#include "../gui/CursorHandler.h"
#include "../gui/CGuiHandler.h"
#include "../gui/WindowHandler.h"
#include "../windows/CTutorialWindow.h"
#include "../render/Canvas.h"
#include "../adventureMap/AdventureMapInterface.h"
#include "../../CCallback.h"
#include "../../lib/CStack.h"
#include "../../lib/CConfigHandler.h"
#include "../../lib/CGeneralTextHandler.h"
#include "../../lib/CHeroHandler.h"
#include "../../lib/CondSh.h"
#include "../../lib/gameState/InfoAboutArmy.h"
#include "../../lib/mapObjects/CGTownInstance.h"
#include "../../lib/networkPacks/PacksForClientBattle.h"
#include "../../lib/UnlockGuard.h"
#include "../../lib/TerrainHandler.h"
#include "../../lib/CThreadHelper.h"
BattleInterface::BattleInterface(const BattleID & battleID, const CCreatureSet *army1, const CCreatureSet *army2,
const CGHeroInstance *hero1, const CGHeroInstance *hero2,
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)
, battleID(battleID)
, battleOpeningDelayActive(true)
{
if(spectatorInt)
{
curInt = spectatorInt;
}
else if(!curInt)
{
//May happen when we are defending during network MP game -> attacker interface is just not present
curInt = defenderInt;
}
//hot-seat -> check tactics for both players (defender may be local human)
if(attackerInt && attackerInt->cb->getBattle(getBattleID())->battleGetTacticDist())
tacticianInterface = attackerInt;
else if(defenderInt && defenderInt->cb->getBattle(getBattleID())->battleGetTacticDist())
tacticianInterface = defenderInt;
//if we found interface of player with tactics, then enter tactics mode
tacticsMode = static_cast<bool>(tacticianInterface);
//initializing armies
this->army1 = army1;
this->army2 = army2;
const CGTownInstance *town = getBattle()->battleGetDefendedTown();
if(town && town->hasFort())
siegeController.reset(new BattleSiegeController(*this, town));
windowObject = std::make_shared<BattleWindow>(*this);
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));
adventureInt->onAudioPaused();
ongoingAnimationsState.set(true);
GH.windows().pushWindow(windowObject);
windowObject->blockUI(true);
windowObject->updateQueue();
playIntroSoundAndUnlockInterface();
}
void BattleInterface::playIntroSoundAndUnlockInterface()
{
auto onIntroPlayed = [this]()
{
if(LOCPLINT->battleInt)
onIntroSoundPlayed();
};
int battleIntroSoundChannel = CCS->soundh->playSoundFromSet(CCS->soundh->battleIntroSounds);
if (battleIntroSoundChannel != -1)
{
CCS->soundh->setCallback(battleIntroSoundChannel, onIntroPlayed);
if (settings["gameTweaks"]["skipBattleIntroMusic"].Bool())
openingEnd();
}
else // failed to play sound
{
onIntroSoundPlayed();
}
}
bool BattleInterface::openingPlaying()
{
return battleOpeningDelayActive;
}
void BattleInterface::onIntroSoundPlayed()
{
if (openingPlaying())
openingEnd();
CCS->musich->playMusicFromSet("battle", true, true);
}
void BattleInterface::openingEnd()
{
assert(openingPlaying());
if (!openingPlaying())
return;
onAnimationsFinished();
if(tacticsMode)
tacticNextStack(nullptr);
activateStack();
battleOpeningDelayActive = false;
CTutorialWindow::openWindowFirstTime(TutorialMode::TOUCH_BATTLE);
}
BattleInterface::~BattleInterface()
{
CPlayerInterface::battleInt = nullptr;
if (adventureInt)
adventureInt->onAudioResumed();
awaitingEvents.clear();
onAnimationsFinished();
}
void BattleInterface::redrawBattlefield()
{
fieldController->redrawBackgroundWithHexes();
GH.windows().totalRedraw();
}
void BattleInterface::stackReset(const CStack * stack)
{
stacksController->stackReset(stack);
}
void BattleInterface::stackAdded(const CStack * stack)
{
stacksController->stackAdded(stack, false);
}
void BattleInterface::stackRemoved(uint32_t stackID)
{
stacksController->stackRemoved(stackID);
fieldController->redrawBackgroundWithHexes();
windowObject->updateQueue();
}
void BattleInterface::stackActivated(const CStack *stack)
{
stacksController->stackActivated(stack);
}
void BattleInterface::stackMoved(const CStack *stack, std::vector<BattleHex> destHex, int distance, bool teleport)
{
if (teleport)
stacksController->stackTeleported(stack, destHex, distance);
else
stacksController->stackMoved(stack, destHex, distance);
}
void BattleInterface::stacksAreAttacked(std::vector<StackAttackedInfo> attackedInfos)
{
stacksController->stacksAreAttacked(attackedInfos);
std::array<int, 2> killedBySide = {0, 0};
for(const StackAttackedInfo & attackedInfo : attackedInfos)
{
ui8 side = attackedInfo.defender->unitSide();
killedBySide.at(side) += attackedInfo.amountKilled;
}
for(ui8 side = 0; side < 2; side++)
{
if(killedBySide.at(side) > killedBySide.at(1-side))
setHeroAnimation(side, EHeroAnimType::DEFEAT);
else if(killedBySide.at(side) < killedBySide.at(1-side))
setHeroAnimation(side, EHeroAnimType::VICTORY);
}
}
void BattleInterface::stackAttacking( const StackAttackInfo & attackInfo )
{
stacksController->stackAttacking(attackInfo);
}
void BattleInterface::newRoundFirst()
{
waitForAnimations();
}
void BattleInterface::newRound()
{
console->addText(CGI->generaltexth->allTexts[412]);
}
void BattleInterface::giveCommand(EActionType action, BattleHex tile, SpellID spell)
{
const CStack * actor = nullptr;
if(action != EActionType::HERO_SPELL && action != EActionType::RETREAT && action != EActionType::SURRENDER)
{
actor = stacksController->getActiveStack();
}
auto side = getBattle()->playerToSide(curInt->playerID);
if(!side)
{
logGlobal->error("Player %s is not in battle", curInt->playerID.toString());
return;
}
BattleAction ba;
ba.side = side.value();
ba.actionType = action;
ba.aimToHex(tile);
ba.spell = spell;
sendCommand(ba, actor);
}
void BattleInterface::sendCommand(BattleAction command, const CStack * actor)
{
command.stackNumber = actor ? actor->unitId() : ((command.side == BattleSide::ATTACKER) ? -1 : -2);
if(!tacticsMode)
{
logGlobal->trace("Setting command for %s", (actor ? actor->nodeName() : "hero"));
stacksController->setActiveStack(nullptr);
curInt->cb->battleMakeUnitAction(battleID, command);
}
else
{
curInt->cb->battleMakeTacticAction(battleID, command);
stacksController->setActiveStack(nullptr);
//next stack will be activated when action ends
}
CCS->curh->set(Cursor::Combat::POINTER);
}
const CGHeroInstance * BattleInterface::getActiveHero()
{
const CStack *attacker = stacksController->getActiveStack();
if(!attacker)
{
return nullptr;
}
if(attacker->unitSide() == BattleSide::ATTACKER)
{
return attackingHeroInstance;
}
return defendingHeroInstance;
}
void BattleInterface::stackIsCatapulting(const CatapultAttack & ca)
{
if (siegeController)
siegeController->stackIsCatapulting(ca);
}
void BattleInterface::gateStateChanged(const EGateState state)
{
if (siegeController)
siegeController->gateStateChanged(state);
}
void BattleInterface::battleFinished(const BattleResult& br, QueryID queryID)
{
checkForAnimations();
stacksController->setActiveStack(nullptr);
CCS->curh->set(Cursor::Map::POINTER);
curInt->waitWhileDialog();
if(settings["session"]["spectate"].Bool() && settings["session"]["spectate-skip-battle-result"].Bool())
{
curInt->cb->selectionMade(0, queryID);
windowObject->close();
return;
}
auto wnd = std::make_shared<BattleResultWindow>(br, *(this->curInt));
wnd->resultCallback = [=](ui32 selection)
{
curInt->cb->selectionMade(selection, queryID);
};
GH.windows().pushWindow(wnd);
curInt->waitWhileDialog(); // Avoid freeze when AI end turn after battle. Check bug #1897
CPlayerInterface::battleInt = nullptr;
}
void BattleInterface::spellCast(const BattleSpellCast * sc)
{
// Do not deactivate anything in tactics mode
// This is battlefield setup spells
if(!tacticsMode)
{
windowObject->blockUI(true);
// Disable current active stack duing the cast
// Store the current activeStack to stackToActivate
stacksController->deactivateStack();
}
CCS->curh->set(Cursor::Combat::BLOCKED);
const SpellID spellID = sc->spellID;
const CSpell * spell = spellID.toSpell();
auto targetedTile = sc->tile;
assert(spell);
if(!spell)
return;
const AudioPath & castSoundPath = spell->getCastSound();
if (!castSoundPath.empty())
{
auto group = spell->animationInfo.projectile.empty() ?
EAnimationEvents::HIT:
EAnimationEvents::BEFORE_HIT;//FIXME: recheck whether this should be on projectile spawning
addToAnimationStage(group, [=]() {
CCS->soundh->playSound(castSoundPath);
});
}
if ( sc->activeCast )
{
const CStack * casterStack = getBattle()->battleGetStackByID(sc->casterStack);
if(casterStack != nullptr )
{
addToAnimationStage(EAnimationEvents::BEFORE_HIT, [=]()
{
stacksController->addNewAnim(new CastAnimation(*this, casterStack, targetedTile, getBattle()->battleGetStackByPos(targetedTile), spell));
displaySpellCast(spell, casterStack->getPosition());
});
}
else
{
auto hero = sc->side ? defendingHero : attackingHero;
assert(hero);
addToAnimationStage(EAnimationEvents::BEFORE_HIT, [=]()
{
stacksController->addNewAnim(new HeroCastAnimation(*this, hero, targetedTile, getBattle()->battleGetStackByPos(targetedTile), spell));
});
}
}
addToAnimationStage(EAnimationEvents::HIT, [=](){
displaySpellHit(spell, targetedTile);
});
//queuing affect animation
for(auto & elem : sc->affectedCres)
{
auto stack = getBattle()->battleGetStackByID(elem, false);
assert(stack);
if(stack)
{
addToAnimationStage(EAnimationEvents::HIT, [=](){
displaySpellEffect(spell, stack->getPosition());
});
}
}
for(auto & elem : sc->reflectedCres)
{
auto stack = getBattle()->battleGetStackByID(elem, false);
assert(stack);
addToAnimationStage(EAnimationEvents::HIT, [=](){
effectsController->displayEffect(EBattleEffect::MAGIC_MIRROR, stack->getPosition());
});
}
if (!sc->resistedCres.empty())
{
addToAnimationStage(EAnimationEvents::HIT, [=](){
CCS->soundh->playSound(AudioPath::builtin("MAGICRES"));
});
}
for(auto & elem : sc->resistedCres)
{
auto stack = getBattle()->battleGetStackByID(elem, false);
assert(stack);
addToAnimationStage(EAnimationEvents::HIT, [=](){
effectsController->displayEffect(EBattleEffect::RESISTANCE, stack->getPosition());
});
}
//mana absorption
if (sc->manaGained > 0)
{
Point leftHero = Point(15, 30);
Point rightHero = Point(755, 30);
bool side = sc->side;
addToAnimationStage(EAnimationEvents::AFTER_HIT, [=](){
stacksController->addNewAnim(new EffectAnimation(*this, AnimationPath::builtin(side ? "SP07_A.DEF" : "SP07_B.DEF"), leftHero));
stacksController->addNewAnim(new EffectAnimation(*this, AnimationPath::builtin(side ? "SP07_B.DEF" : "SP07_A.DEF"), rightHero));
});
}
// animations will be executed by spell effects
}
void BattleInterface::battleStacksEffectsSet(const SetStackEffect & sse)
{
if(stacksController->getActiveStack() != nullptr)
fieldController->redrawBackgroundWithHexes();
}
void BattleInterface::setHeroAnimation(ui8 side, EHeroAnimType phase)
{
if(side == BattleSide::ATTACKER)
{
if(attackingHero)
attackingHero->setPhase(phase);
}
else
{
if(defendingHero)
defendingHero->setPhase(phase);
}
}
void BattleInterface::displayBattleLog(const std::vector<MetaString> & battleLog)
{
for(const auto & line : battleLog)
{
std::string formatted = line.toString();
boost::algorithm::trim(formatted);
appendBattleLog(formatted);
}
}
void BattleInterface::displaySpellAnimationQueue(const CSpell * spell, const CSpell::TAnimationQueue & q, BattleHex destinationTile, bool isHit)
{
for(const CSpell::TAnimation & animation : q)
{
if(animation.pause > 0)
stacksController->addNewAnim(new DummyAnimation(*this, animation.pause));
if (!animation.effectName.empty())
{
const CStack * destStack = getBattle()->battleGetStackByPos(destinationTile, false);
if (destStack)
stacksController->addNewAnim(new ColorTransformAnimation(*this, destStack, animation.effectName, spell ));
}
if(!animation.resourceName.empty())
{
int flags = 0;
if (isHit)
flags |= EffectAnimation::FORCE_ON_TOP;
if (animation.verticalPosition == VerticalPosition::BOTTOM)
flags |= EffectAnimation::ALIGN_TO_BOTTOM;
if (!destinationTile.isValid())
flags |= EffectAnimation::SCREEN_FILL;
if (!destinationTile.isValid())
stacksController->addNewAnim(new EffectAnimation(*this, animation.resourceName, flags));
else
stacksController->addNewAnim(new EffectAnimation(*this, animation.resourceName, destinationTile, flags));
}
}
}
void BattleInterface::displaySpellCast(const CSpell * spell, BattleHex destinationTile)
{
if(spell)
displaySpellAnimationQueue(spell, spell->animationInfo.cast, destinationTile, false);
}
void BattleInterface::displaySpellEffect(const CSpell * spell, BattleHex destinationTile)
{
if(spell)
displaySpellAnimationQueue(spell, spell->animationInfo.affect, destinationTile, false);
}
void BattleInterface::displaySpellHit(const CSpell * spell, BattleHex destinationTile)
{
if(spell)
displaySpellAnimationQueue(spell, spell->animationInfo.hit, destinationTile, true);
}
CPlayerInterface *BattleInterface::getCurrentPlayerInterface() const
{
return curInt.get();
}
void BattleInterface::trySetActivePlayer( PlayerColor player )
{
if ( attackerInt && attackerInt->playerID == player )
curInt = attackerInt;
if ( defenderInt && defenderInt->playerID == player )
curInt = defenderInt;
}
void BattleInterface::activateStack()
{
stacksController->activateStack();
const CStack * s = stacksController->getActiveStack();
if(!s)
return;
windowObject->updateQueue();
windowObject->blockUI(false);
fieldController->redrawBackgroundWithHexes();
actionsController->activateStack();
GH.fakeMouseMove();
}
bool BattleInterface::makingTurn() const
{
return stacksController->getActiveStack() != nullptr;
}
BattleID BattleInterface::getBattleID() const
{
return battleID;
}
std::shared_ptr<CPlayerBattleCallback> BattleInterface::getBattle() const
{
return curInt->cb->getBattle(battleID);
}
void BattleInterface::endAction(const BattleAction &action)
{
// it is possible that tactics mode ended while opening music is still playing
waitForAnimations();
const CStack *stack = getBattle()->battleGetStackByID(action.stackNumber);
// Activate stack from stackToActivate because this might have been temporary disabled, e.g., during spell cast
activateStack();
stacksController->endAction(action);
windowObject->updateQueue();
//stack ended movement in tactics phase -> select the next one
if (tacticsMode)
tacticNextStack(stack);
//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)
fieldController->redrawBackgroundWithHexes();
}
void BattleInterface::appendBattleLog(const std::string & newEntry)
{
console->addText(newEntry);
}
void BattleInterface::startAction(const BattleAction & action)
{
if(action.actionType == EActionType::END_TACTIC_PHASE)
{
windowObject->tacticPhaseEnded();
return;
}
stacksController->startAction(action);
if (!action.isUnitAction())
return;
assert(getBattle()->battleGetStackByID(action.stackNumber));
windowObject->updateQueue();
effectsController->startAction(action);
}
void BattleInterface::tacticPhaseEnd()
{
stacksController->setActiveStack(nullptr);
tacticsMode = false;
auto side = tacticianInterface->cb->getBattle(battleID)->playerToSide(tacticianInterface->playerID);
auto action = BattleAction::makeEndOFTacticPhase(*side);
tacticianInterface->cb->battleMakeTacticAction(battleID, action);
}
static bool immobile(const CStack *s)
{
return !s->speed(0, true); //should bound stacks be immobile?
}
void BattleInterface::tacticNextStack(const CStack * current)
{
if (!current)
current = stacksController->getActiveStack();
//no switching stacks when the current one is moving
checkForAnimations();
TStacks stacksOfMine = tacticianInterface->cb->getBattle(battleID)->battleGetStacks(CPlayerBattleCallback::ONLY_MINE);
vstd::erase_if (stacksOfMine, &immobile);
if (stacksOfMine.empty())
{
tacticPhaseEnd();
return;
}
auto it = vstd::find(stacksOfMine, current);
if (it != stacksOfMine.end() && ++it != stacksOfMine.end())
stackActivated(*it);
else
stackActivated(stacksOfMine.front());
}
void BattleInterface::obstaclePlaced(const std::vector<std::shared_ptr<const CObstacleInstance>> oi)
{
obstacleController->obstaclePlaced(oi);
}
void BattleInterface::obstacleRemoved(const std::vector<ObstacleChanges> & obstacles)
{
obstacleController->obstacleRemoved(obstacles);
}
const CGHeroInstance *BattleInterface::currentHero() const
{
if (attackingHeroInstance && attackingHeroInstance->tempOwner == curInt->playerID)
return attackingHeroInstance;
if (defendingHeroInstance && defendingHeroInstance->tempOwner == curInt->playerID)
return defendingHeroInstance;
return nullptr;
}
InfoAboutHero BattleInterface::enemyHero() const
{
InfoAboutHero ret;
if (attackingHeroInstance->tempOwner == curInt->playerID)
curInt->cb->getHeroInfo(defendingHeroInstance, ret);
else
curInt->cb->getHeroInfo(attackingHeroInstance, ret);
return ret;
}
void BattleInterface::requestAutofightingAIToTakeAction()
{
assert(curInt->isAutoFightOn);
if(getBattle()->battleIsFinished())
{
return; // battle finished with spellcast
}
if (tacticsMode)
{
// 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?
tacticPhaseEnd();
stacksController->setActiveStack(nullptr);
}
else
{
const CStack* activeStack = stacksController->getActiveStack();
// If enemy is moving, activeStack can be null
if (activeStack)
{
stacksController->setActiveStack(nullptr);
// FIXME: unsafe
// Run task in separate thread to avoid UI lock while AI is making turn (which might take some time)
// HOWEVER this thread won't atttempt to lock game state, potentially leading to races
boost::thread aiThread([this, activeStack]()
{
setThreadName("autofightingAI");
curInt->autofightingAI->activeStack(battleID, activeStack);
});
aiThread.detach();
}
}
}
void BattleInterface::castThisSpell(SpellID spellID)
{
actionsController->castThisSpell(spellID);
}
void BattleInterface::executeStagedAnimations()
{
EAnimationEvents earliestStage = EAnimationEvents::COUNT;
for(const auto & event : awaitingEvents)
earliestStage = std::min(earliestStage, event.event);
if(earliestStage != EAnimationEvents::COUNT)
executeAnimationStage(earliestStage);
}
void BattleInterface::executeAnimationStage(EAnimationEvents event)
{
decltype(awaitingEvents) executingEvents;
for(auto it = awaitingEvents.begin(); it != awaitingEvents.end();)
{
if(it->event == event)
{
executingEvents.push_back(*it);
it = awaitingEvents.erase(it);
}
else
++it;
}
for(const auto & event : executingEvents)
event.action();
}
void BattleInterface::onAnimationsStarted()
{
ongoingAnimationsState.setn(true);
}
void BattleInterface::onAnimationsFinished()
{
ongoingAnimationsState.setn(false);
}
void BattleInterface::waitForAnimations()
{
{
auto unlockInterface = vstd::makeUnlockGuard(GH.interfaceMutex);
ongoingAnimationsState.waitUntil(false);
}
assert(!hasAnimations());
assert(awaitingEvents.empty());
if (!awaitingEvents.empty())
{
logGlobal->error("Wait for animations finished but we still have awaiting events!");
awaitingEvents.clear();
}
}
bool BattleInterface::hasAnimations()
{
return ongoingAnimationsState.get();
}
void BattleInterface::checkForAnimations()
{
assert(!hasAnimations());
if(hasAnimations())
logGlobal->error("Unexpected animations state: expected all animations to be over, but some are still ongoing!");
waitForAnimations();
}
void BattleInterface::addToAnimationStage(EAnimationEvents event, const AwaitingAnimationAction & action)
{
awaitingEvents.push_back({action, event});
}
void BattleInterface::setBattleQueueVisibility(bool visible)
{
windowObject->hideQueue();
if(visible)
windowObject->showQueue();
}
void BattleInterface::setStickyHeroWindowsVisibility(bool visible)
{
windowObject->hideStickyHeroWindows();
if(visible)
windowObject->showStickyHeroWindows();
}