|
|
@@ -0,0 +1,2021 @@
|
|
|
+#include "StdInc.h"
|
|
|
+#include "CBattleCallback.h"
|
|
|
+#include "BattleState.h"
|
|
|
+#include "CGameState.h"
|
|
|
+#include "NetPacks.h"
|
|
|
+#include "CSpellHandler.h"
|
|
|
+#include "VCMI_Lib.h"
|
|
|
+
|
|
|
+#define RETURN_IF_NOT_BATTLE(X) if(!duringBattle()) {tlog1 << __FUNCTION__ << " called when no battle!\n"; return X; }
|
|
|
+
|
|
|
+namespace SiegeStuffThatShouldBeMovedToHandlers // <=== TODO
|
|
|
+{
|
|
|
+ static int lineToWallHex(int line) //returns hex with wall in given line (y coordinate)
|
|
|
+ {
|
|
|
+ static const int lineToHex[] = {12, 29, 45, 62, 78, 95, 112, 130, 147, 165, 182};
|
|
|
+
|
|
|
+ return lineToHex[line];
|
|
|
+ }
|
|
|
+
|
|
|
+ static bool sameSideOfWall(BattleHex pos1, BattleHex pos2)
|
|
|
+ {
|
|
|
+ const int wallInStackLine = lineToWallHex(pos1.getY());
|
|
|
+ const int wallInDestLine = lineToWallHex(pos2.getY());
|
|
|
+
|
|
|
+ const bool stackLeft = pos1 < wallInStackLine;
|
|
|
+ const bool destLeft = pos2 < wallInDestLine;
|
|
|
+
|
|
|
+ return stackLeft != destLeft;
|
|
|
+ }
|
|
|
+
|
|
|
+ static int getMoatDamage(int townType)
|
|
|
+ {
|
|
|
+ //TODO move to config file
|
|
|
+ static const int dmgs[] = {70, 70, -1,
|
|
|
+ 90, 70, 90,
|
|
|
+ 70, 90, 70};
|
|
|
+
|
|
|
+ if(townType >= 0 && townType < ARRAY_COUNT(dmgs))
|
|
|
+ return dmgs[townType];
|
|
|
+
|
|
|
+ tlog1 << "No moat info for town " << townType << std::endl;
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ static EWallParts::EWallParts hexToWallPart(BattleHex hex)
|
|
|
+ {
|
|
|
+ //potentially attackable parts of wall
|
|
|
+ // -2 - indestructible walls
|
|
|
+ static const std::pair<int, EWallParts::EWallParts> attackable[] =
|
|
|
+ {
|
|
|
+ std::make_pair(50, EWallParts::KEEP),
|
|
|
+ std::make_pair(183, EWallParts::BOTTOM_TOWER),
|
|
|
+ std::make_pair(182, EWallParts::BOTTOM_WALL),
|
|
|
+ std::make_pair(130, EWallParts::BELOW_GATE),
|
|
|
+ std::make_pair(62, EWallParts::OVER_GATE),
|
|
|
+ std::make_pair(29, EWallParts::UPPER_WAL),
|
|
|
+ std::make_pair(12, EWallParts::UPPER_TOWER),
|
|
|
+ std::make_pair(95, EWallParts::GATE),
|
|
|
+ std::make_pair(96, EWallParts::GATE),
|
|
|
+ std::make_pair(45, EWallParts::INDESTRUCTIBLE_PART),
|
|
|
+ std::make_pair(78, EWallParts::INDESTRUCTIBLE_PART),
|
|
|
+ std::make_pair(112, EWallParts::INDESTRUCTIBLE_PART),
|
|
|
+ std::make_pair(147, EWallParts::INDESTRUCTIBLE_PART)
|
|
|
+ };
|
|
|
+
|
|
|
+ for(int g = 0; g < ARRAY_COUNT(attackable); ++g)
|
|
|
+ {
|
|
|
+ if(attackable[g].first == hex)
|
|
|
+ return attackable[g].second;
|
|
|
+ }
|
|
|
+
|
|
|
+ return EWallParts::INVALID; //not found!
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+using namespace SiegeStuffThatShouldBeMovedToHandlers;
|
|
|
+
|
|
|
+boost::shared_mutex& CCallbackBase::getGsMutex()
|
|
|
+{
|
|
|
+ return *gs->mx;
|
|
|
+}
|
|
|
+
|
|
|
+bool CCallbackBase::duringBattle() const
|
|
|
+{
|
|
|
+ return getBattle() != nullptr;
|
|
|
+}
|
|
|
+
|
|
|
+void CCallbackBase::setBattle(const BattleInfo *B)
|
|
|
+{
|
|
|
+ battle = B;
|
|
|
+}
|
|
|
+
|
|
|
+ui8 CBattleInfoEssentials::battleTerrainType() const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(-1);
|
|
|
+ return getBattle()->terrainType;
|
|
|
+}
|
|
|
+
|
|
|
+int CBattleInfoEssentials::battleGetBattlefieldType() const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(-1);
|
|
|
+ return getBattle()->battlefieldType;
|
|
|
+}
|
|
|
+
|
|
|
+std::vector<shared_ptr<const CObstacleInstance> > CBattleInfoEssentials::battleGetAllObstacles(boost::optional<BattlePerspective::BattlePerspective> perspective /*= boost::none*/) const
|
|
|
+{
|
|
|
+ std::vector<shared_ptr<const CObstacleInstance> > ret;
|
|
|
+ RETURN_IF_NOT_BATTLE(ret);
|
|
|
+
|
|
|
+ if(!perspective)
|
|
|
+ {
|
|
|
+ //if no particular perspective request, use default one
|
|
|
+ perspective = battleGetMySide();
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if(player >= 0 && *perspective != battleGetMySide())
|
|
|
+ {
|
|
|
+ tlog1 << "Unauthorized access attempt!\n";
|
|
|
+ assert(0); //I want to notice if that happens
|
|
|
+ //perspective = battleGetMySide();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ BOOST_FOREACH(auto oi, getBattle()->obstacles)
|
|
|
+ {
|
|
|
+ if(getBattle()->battleIsObstacleVisibleForSide(*oi, *perspective))
|
|
|
+ ret.push_back(oi);
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+bool CBattleInfoEssentials::battleIsObstacleVisibleForSide(const CObstacleInstance & coi, BattlePerspective::BattlePerspective side) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+ return side == BattlePerspective::ALL_KNOWING || coi.visibleForSide(side, battleHasNativeStack(side));
|
|
|
+}
|
|
|
+
|
|
|
+bool CBattleInfoEssentials::battleHasNativeStack(ui8 side) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+
|
|
|
+ BOOST_FOREACH(const CStack *s, battleGetAllStacks())
|
|
|
+ {
|
|
|
+ if(s->attackerOwned == !side && s->getCreature()->isItNativeTerrain(getBattle()->terrainType))
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+TStacks CBattleInfoEssentials::battleGetAllStacks() const /*returns all stacks, alive or dead or undead or mechanical :) */
|
|
|
+{
|
|
|
+ TStacks ret;
|
|
|
+ RETURN_IF_NOT_BATTLE(ret);
|
|
|
+ boost::copy(getBattle()->stacks, std::back_inserter(ret));
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+TStacks CBattleInfoEssentials::battleAliveStacks() const
|
|
|
+{
|
|
|
+ TStacks ret;
|
|
|
+ vstd::copy_if(battleGetAllStacks(), std::back_inserter(ret), [](const CStack *s){ return s->alive(); });
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+TStacks CBattleInfoEssentials::battleAliveStacks(ui8 side) const
|
|
|
+{
|
|
|
+ TStacks ret;
|
|
|
+ vstd::copy_if(battleGetAllStacks(), std::back_inserter(ret), [=](const CStack *s){ return s->alive() && s->attackerOwned == !side; });
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+int CBattleInfoEssentials::battleGetMoatDmg() const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(0);
|
|
|
+
|
|
|
+ auto town = getBattle()->town;
|
|
|
+ if(!town)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ return getMoatDamage(town->subID);
|
|
|
+}
|
|
|
+
|
|
|
+const CGTownInstance * CBattleInfoEssentials::battleGetDefendedTown() const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(nullptr);
|
|
|
+
|
|
|
+
|
|
|
+ if(!getBattle() || getBattle()->town == NULL)
|
|
|
+ return NULL;
|
|
|
+
|
|
|
+ return getBattle()->town;
|
|
|
+}
|
|
|
+
|
|
|
+BattlePerspective::BattlePerspective CBattleInfoEssentials::battleGetMySide() const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(BattlePerspective::INVALID);
|
|
|
+ if(player < 0)
|
|
|
+ return BattlePerspective::ALL_KNOWING;
|
|
|
+ if(player == getBattle()->sides[0])
|
|
|
+ return BattlePerspective::LEFT_SIDE;
|
|
|
+ if(player == getBattle()->sides[1])
|
|
|
+ return BattlePerspective::RIGHT_SIDE;
|
|
|
+
|
|
|
+ tlog1 << "Cannot find player " << player << " in battle!\n";
|
|
|
+ return BattlePerspective::INVALID;
|
|
|
+}
|
|
|
+
|
|
|
+const CStack * CBattleInfoEssentials::battleActiveStack() const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(nullptr);
|
|
|
+ return battleGetStackByID(getBattle()->activeStack);
|
|
|
+}
|
|
|
+
|
|
|
+const CStack* CBattleInfoEssentials::battleGetStackByID(int ID, bool onlyAlive) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(nullptr);
|
|
|
+
|
|
|
+ BOOST_FOREACH(auto s, battleGetAllStacks())
|
|
|
+ if(s->ID == ID && (!onlyAlive || s->alive()))
|
|
|
+ return s;
|
|
|
+
|
|
|
+ return nullptr;
|
|
|
+}
|
|
|
+
|
|
|
+bool CBattleInfoEssentials::battleDoWeKnowAbout(ui8 side) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+ auto p = battleGetMySide();
|
|
|
+ return p == BattlePerspective::ALL_KNOWING || p == side;
|
|
|
+}
|
|
|
+
|
|
|
+si8 CBattleInfoEssentials::battleTacticDist() const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(0);
|
|
|
+ return getBattle()->tacticDistance;
|
|
|
+}
|
|
|
+
|
|
|
+si8 CBattleInfoEssentials::battleGetTacticsSide() const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(-1);
|
|
|
+ return getBattle()->tacticsSide;
|
|
|
+}
|
|
|
+
|
|
|
+const CGHeroInstance * CBattleInfoEssentials::battleGetFightingHero(ui8 side) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(nullptr);
|
|
|
+ if(side > 1)
|
|
|
+ {
|
|
|
+ tlog1 << "FIXME: " << __FUNCTION__ << " wrong argument!" << std::endl;
|
|
|
+ return nullptr;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(!battleDoWeKnowAbout(side))
|
|
|
+ {
|
|
|
+ tlog1 << "FIXME: " << __FUNCTION__ << " access check " << std::endl;
|
|
|
+ return nullptr;
|
|
|
+ }
|
|
|
+
|
|
|
+ return getBattle()->heroes[side];
|
|
|
+}
|
|
|
+
|
|
|
+int CBattleInfoEssentials::battleCastSpells(ui8 side) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(-1);
|
|
|
+ return getBattle()->castSpells[side];
|
|
|
+}
|
|
|
+
|
|
|
+ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastSpell(int player, ECastingMode::ECastingMode mode) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(ESpellCastProblem::INVALID);
|
|
|
+ const ui8 side = playerToSide(player);
|
|
|
+ if(!battleDoWeKnowAbout(side))
|
|
|
+ {
|
|
|
+ tlog3 << "You can't check if enemy can cast given spell!\n";
|
|
|
+ return ESpellCastProblem::INVALID;
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (mode)
|
|
|
+ {
|
|
|
+ case ECastingMode::HERO_CASTING:
|
|
|
+ {
|
|
|
+ if(battleTacticDist())
|
|
|
+ return ESpellCastProblem::ONGOING_TACTIC_PHASE;
|
|
|
+ if(battleCastSpells(side) > 0)
|
|
|
+ return ESpellCastProblem::ALREADY_CASTED_THIS_TURN;
|
|
|
+
|
|
|
+ auto hero = battleGetFightingHero(side);
|
|
|
+
|
|
|
+ if(!hero)
|
|
|
+ return ESpellCastProblem::NO_HERO_TO_CAST_SPELL;
|
|
|
+ if(!hero->getArt(ArtifactPosition::SPELLBOOK))
|
|
|
+ return ESpellCastProblem::NO_SPELLBOOK;
|
|
|
+ if(hero->hasBonusOfType(Bonus::BLOCK_ALL_MAGIC))
|
|
|
+ return ESpellCastProblem::MAGIC_IS_BLOCKED;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ return ESpellCastProblem::OK;
|
|
|
+}
|
|
|
+
|
|
|
+bool CBattleInfoEssentials::battleCanFlee(int player) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+ ui8 mySide = playerToSide(player);
|
|
|
+ const CGHeroInstance *myHero = battleGetFightingHero(mySide),
|
|
|
+ *enemyHero = battleGetFightingHero(!mySide);
|
|
|
+
|
|
|
+ //current player have no hero
|
|
|
+ if(!myHero)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ //TODo use bonus system
|
|
|
+ //ie. one of heroes is wearing shakles of war
|
|
|
+ if(NBonus::hasOfType(enemyHero, Bonus::ENEMY_CANT_ESCAPE) || NBonus::hasOfType(myHero, Bonus::ENEMY_CANT_ESCAPE))
|
|
|
+ return false;
|
|
|
+
|
|
|
+ //we are besieged defender
|
|
|
+ if(mySide == BattleSide::DEFENDER && battleGetSiegeLevel())
|
|
|
+ {
|
|
|
+ auto town = battleGetDefendedTown();
|
|
|
+ if(!(town->subID == 6 && town->hasBuilt(EBuilding::SPECIAL_1))) //not a stronghold with escape tunnel
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+ui8 CBattleInfoEssentials::playerToSide(int player) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(-1);
|
|
|
+ int ret = vstd::find_pos(getBattle()->sides, player);
|
|
|
+ if(ret < 0)
|
|
|
+ tlog3 << "Cannot find side for player " << player << std::endl;
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+ui8 CBattleInfoEssentials::battleGetSiegeLevel() const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(0);
|
|
|
+ return getBattle()->siege;
|
|
|
+}
|
|
|
+
|
|
|
+bool CBattleInfoEssentials::battleCanSurrender(int player) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+ //conditions like for fleeing + enemy must have a hero
|
|
|
+ return battleCanFlee(player) && battleGetFightingHero(!playerToSide(player));
|
|
|
+}
|
|
|
+
|
|
|
+bool CBattleInfoEssentials::battleHasHero(ui8 side) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+ assert(side >= 0 && side < 2);
|
|
|
+ return getBattle()->heroes[side];
|
|
|
+}
|
|
|
+
|
|
|
+ui8 CBattleInfoEssentials::battleGetWallState(int partOfWall) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(0);
|
|
|
+ if(getBattle()->siege == 0)
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ assert(partOfWall >= 0 && partOfWall < EWallParts::PARTS_COUNT);
|
|
|
+ return getBattle()->si.wallState[partOfWall];
|
|
|
+}
|
|
|
+
|
|
|
+si8 CBattleInfoCallback::battleHasWallPenalty( const CStack * stack, BattleHex destHex ) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+ if (!battleGetSiegeLevel() || stack->hasBonusOfType(Bonus::NO_WALL_PENALTY))
|
|
|
+ return false;
|
|
|
+
|
|
|
+ const int wallInStackLine = lineToWallHex(stack->position.getY());
|
|
|
+ const int wallInDestLine = lineToWallHex(destHex.getY());
|
|
|
+
|
|
|
+ const bool stackLeft = stack->position < wallInStackLine;
|
|
|
+ const bool destRight = destHex > wallInDestLine;
|
|
|
+
|
|
|
+ if (stackLeft && destRight) //shooting from outside to inside
|
|
|
+ {
|
|
|
+ int row = (stack->position + destHex) / (2 * GameConstants::BFIELD_WIDTH);
|
|
|
+ if (stack->position > destHex && ((destHex % GameConstants::BFIELD_WIDTH - stack->position % GameConstants::BFIELD_WIDTH) < 2)) //shooting up high
|
|
|
+ row -= 2;
|
|
|
+ const int wallPos = lineToWallHex(row);
|
|
|
+ if (battleHexToWallPart(wallPos) != -1) //wall still exists or is indestructible
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+si8 CBattleInfoCallback::battleCanTeleportTo(const CStack * stack, BattleHex destHex, int telportLevel) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+ if(getAccesibility().accessible(destHex, stack))
|
|
|
+ return false;
|
|
|
+
|
|
|
+ if (battleGetSiegeLevel() && telportLevel < 2) //check for wall
|
|
|
+ return sameSideOfWall(stack->position, destHex);
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+// std::vector<int> CBattleInfoCallback::battleGetDistances(const CStack * stack, BattleHex hex /*= BattleHex::INVALID*/, BattleHex * predecessors /*= NULL*/)
|
|
|
+// {
|
|
|
+// // FIXME - This method is broken, hex argument is not used. However AI depends on that wrong behaviour.
|
|
|
+//
|
|
|
+// if(!hex.isValid())
|
|
|
+// hex = stack->position;
|
|
|
+//
|
|
|
+// std::vector<int> ret(GameConstants::BFIELD_SIZE, -1); //fill initial ret with -1's
|
|
|
+//
|
|
|
+// if(!hex.isValid()) //stack has bad position? probably castle turret, return initial values (they can't move)
|
|
|
+// return ret;
|
|
|
+//
|
|
|
+// bool ac[GameConstants::BFIELD_SIZE] = {0};
|
|
|
+// std::set<BattleHex> occupyable;
|
|
|
+// getBattle()->getAccessibilityMap(ac, stack->doubleWide(), stack->attackerOwned, false, occupyable, stack->hasBonusOfType(Bonus::FLYING), stack);
|
|
|
+// BattleHex pr[GameConstants::BFIELD_SIZE];
|
|
|
+// int dist[GameConstants::BFIELD_SIZE];
|
|
|
+// getBattle()->makeBFS(stack->position, ac, pr, dist, stack->doubleWide(), stack->attackerOwned, stack->hasBonusOfType(Bonus::FLYING), false);
|
|
|
+//
|
|
|
+// for(int i=0; i<GameConstants::BFIELD_SIZE; ++i)
|
|
|
+// {
|
|
|
+// if(pr[i] != -1)
|
|
|
+// ret[i] = dist[i];
|
|
|
+// }
|
|
|
+//
|
|
|
+// if(predecessors)
|
|
|
+// {
|
|
|
+// memcpy(predecessors, pr, GameConstants::BFIELD_SIZE * sizeof(BattleHex));
|
|
|
+// }
|
|
|
+//
|
|
|
+// return ret;
|
|
|
+// }
|
|
|
+
|
|
|
+std::set<BattleHex> CBattleInfoCallback::battleGetAttackedHexes(const CStack* attacker, BattleHex destinationTile, BattleHex attackerPos /*= BattleHex::INVALID*/) const
|
|
|
+{
|
|
|
+ std::set<BattleHex> attackedHexes;
|
|
|
+ RETURN_IF_NOT_BATTLE(attackedHexes);
|
|
|
+
|
|
|
+ AttackableTiles at = getPotentiallyAttackableHexes(attacker, destinationTile, attackerPos);
|
|
|
+
|
|
|
+ BOOST_FOREACH (BattleHex tile, at.hostileCreaturePositions)
|
|
|
+ {
|
|
|
+ const CStack * st = battleGetStackByPos(tile, true);
|
|
|
+ if(st && st->owner != attacker->owner) //only hostile stacks - does it work well with Berserk?
|
|
|
+ {
|
|
|
+ attackedHexes.insert(tile);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ BOOST_FOREACH (BattleHex tile, at.friendlyCreaturePositions)
|
|
|
+ {
|
|
|
+ if(const CStack * st = battleGetStackByPos(tile, true)) //friendly stacks can also be damaged by Dragon Breath
|
|
|
+ {
|
|
|
+ attackedHexes.insert(tile);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return attackedHexes;
|
|
|
+}
|
|
|
+
|
|
|
+si32 CBattleInfoCallback::battleGetRandomStackSpell(const CStack * stack, ERandomSpell mode) const
|
|
|
+{
|
|
|
+ switch (mode)
|
|
|
+ {
|
|
|
+ case RANDOM_GENIE:
|
|
|
+ return getRandomBeneficialSpell(stack); //target
|
|
|
+ break;
|
|
|
+ case RANDOM_AIMED:
|
|
|
+ return getRandomCastedSpell(stack); //caster
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ tlog1 << "Incorrect mode of battleGetRandomSpell (" << mode <<")\n";
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+const CStack* CBattleInfoCallback::battleGetStackByPos(BattleHex pos, bool onlyAlive) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(nullptr);
|
|
|
+ BOOST_FOREACH(auto s, battleGetAllStacks())
|
|
|
+ if(vstd::contains(s->getHexes(), pos) && (!onlyAlive || s->alive()))
|
|
|
+ return s;
|
|
|
+
|
|
|
+ return nullptr;
|
|
|
+}
|
|
|
+
|
|
|
+void CBattleInfoCallback::battleGetStackQueue(std::vector<const CStack *> &out, const int howMany, const int turn /*= 0*/, int lastMoved /*= -1*/) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE();
|
|
|
+
|
|
|
+ //let's define a huge lambda
|
|
|
+ auto takeStack = [&](std::vector<const CStack *> &st) -> const CStack*
|
|
|
+ {
|
|
|
+ const CStack *ret = NULL;
|
|
|
+ unsigned i, //fastest stack
|
|
|
+ j=0; //fastest stack of the other side
|
|
|
+ for(i = 0; i < st.size(); i++)
|
|
|
+ if(st[i])
|
|
|
+ break;
|
|
|
+
|
|
|
+ //no stacks left
|
|
|
+ if(i == st.size())
|
|
|
+ return nullptr;
|
|
|
+
|
|
|
+ const CStack *fastest = st[i], *other = NULL;
|
|
|
+ int bestSpeed = fastest->Speed(turn);
|
|
|
+
|
|
|
+ if(fastest->attackerOwned != lastMoved)
|
|
|
+ {
|
|
|
+ ret = fastest;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ for(j = i + 1; j < st.size(); j++)
|
|
|
+ {
|
|
|
+ if(!st[j]) continue;
|
|
|
+ if(st[j]->attackerOwned != lastMoved || st[j]->Speed(turn) != bestSpeed)
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(j >= st.size())
|
|
|
+ {
|
|
|
+ ret = fastest;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ other = st[j];
|
|
|
+ if(other->Speed(turn) != bestSpeed)
|
|
|
+ ret = fastest;
|
|
|
+ else
|
|
|
+ ret = other;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ assert(ret);
|
|
|
+ if(ret == fastest)
|
|
|
+ st[i] = NULL;
|
|
|
+ else
|
|
|
+ st[j] = NULL;
|
|
|
+
|
|
|
+ lastMoved = ret->attackerOwned;
|
|
|
+ return ret;
|
|
|
+ };
|
|
|
+
|
|
|
+ //We'll split creatures with remaining movement to 4 buckets
|
|
|
+ // [0] - turrets/catapult,
|
|
|
+ // [1] - normal (unmoved) creatures, other war machines,
|
|
|
+ // [2] - waited cres that had morale,
|
|
|
+ // [3] - rest of waited cres
|
|
|
+ std::vector<const CStack *> phase[4];
|
|
|
+ int toMove = 0; //how many stacks still has move
|
|
|
+ const CStack *active = battleActiveStack();
|
|
|
+
|
|
|
+ //active stack hasn't taken any action yet - must be placed at the beginning of queue, no matter what
|
|
|
+ if(!turn && active && active->willMove() && !vstd::contains(active->state, EBattleStackState::WAITING))
|
|
|
+ {
|
|
|
+ out.push_back(active);
|
|
|
+ if(out.size() == howMany)
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ BOOST_FOREACH(auto s, battleGetAllStacks())
|
|
|
+ {
|
|
|
+ if((turn <= 0 && !s->willMove()) //we are considering current round and stack won't move
|
|
|
+ || (turn > 0 && !s->canMove(turn)) //stack won't be able to move in later rounds
|
|
|
+ || (turn <= 0 && s == active && out.size() && s == out.front())) //it's active stack already added at the beginning of queue
|
|
|
+ {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ int p = -1; //in which phase this tack will move?
|
|
|
+ if(turn <= 0 && vstd::contains(s->state, EBattleStackState::WAITING)) //consider waiting state only for ongoing round
|
|
|
+ {
|
|
|
+ if(vstd::contains(s->state, EBattleStackState::HAD_MORALE))
|
|
|
+ p = 2;
|
|
|
+ else
|
|
|
+ p = 3;
|
|
|
+ }
|
|
|
+ else if(s->getCreature()->idNumber == 145 || s->getCreature()->idNumber == 149) //catapult and turrets are first
|
|
|
+ {
|
|
|
+ p = 0;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ p = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ phase[p].push_back(s);
|
|
|
+ toMove++;
|
|
|
+ }
|
|
|
+
|
|
|
+ for(int i = 0; i < 4; i++)
|
|
|
+ boost::sort(phase[i], CMP_stack(i, turn > 0 ? turn : 0));
|
|
|
+
|
|
|
+ for(size_t i = 0; i < phase[0].size() && i < howMany; i++)
|
|
|
+ out.push_back(phase[0][i]);
|
|
|
+
|
|
|
+ if(out.size() == howMany)
|
|
|
+ return;
|
|
|
+
|
|
|
+ if(lastMoved == -1)
|
|
|
+ {
|
|
|
+ if(active)
|
|
|
+ {
|
|
|
+ if(out.size() && out.front() == active)
|
|
|
+ lastMoved = active->attackerOwned;
|
|
|
+ else
|
|
|
+ lastMoved = active->attackerOwned;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ lastMoved = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ int pi = 1;
|
|
|
+ while(out.size() < howMany)
|
|
|
+ {
|
|
|
+ const CStack *hlp = takeStack(phase[pi]);
|
|
|
+ if(!hlp)
|
|
|
+ {
|
|
|
+ pi++;
|
|
|
+ if(pi > 3)
|
|
|
+ {
|
|
|
+ //if(turn != 2)
|
|
|
+ battleGetStackQueue(out, howMany, turn + 1, lastMoved);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ out.push_back(hlp);
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void CBattleInfoCallback::battleGetStackCountOutsideHexes(bool *ac) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE();
|
|
|
+ auto accessibility = getAccesibility();
|
|
|
+
|
|
|
+ for(int i = 0; i < accessibility.size(); i++)
|
|
|
+ ac[i] = (accessibility[i] == EAccessibility::ACCESSIBLE);
|
|
|
+}
|
|
|
+
|
|
|
+std::vector<BattleHex> CBattleInfoCallback::battleGetAvailableHexes(const CStack * stack, bool addOccupiable, std::vector<BattleHex> * attackable) const
|
|
|
+{
|
|
|
+ std::vector<BattleHex> ret;
|
|
|
+
|
|
|
+ RETURN_IF_NOT_BATTLE(ret);
|
|
|
+ if(!stack->position.isValid()) //turrets
|
|
|
+ return ret;
|
|
|
+
|
|
|
+ auto reachability = getReachability(stack);
|
|
|
+
|
|
|
+ for (int i = 0; i < GameConstants::BFIELD_SIZE; ++i)
|
|
|
+ {
|
|
|
+ // If obstacles or other stacks makes movement impossible, it can't be helped.
|
|
|
+ if(!reachability.isReachable(i))
|
|
|
+ continue;
|
|
|
+
|
|
|
+ if(battleTacticDist() && battleGetTacticsSide() == !stack->attackerOwned)
|
|
|
+ {
|
|
|
+ //Stack has to perform tactic-phase movement -> can enter any reachable tile within given range
|
|
|
+ if(!isInTacticRange(i))
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ //Not tactics phase -> destination must be reachable and within stack range.
|
|
|
+ if(reachability.distances[i] > stack->Speed(0, true))
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ ret.push_back(i);
|
|
|
+
|
|
|
+ if(addOccupiable && stack->doubleWide())
|
|
|
+ {
|
|
|
+ //If two-hex stack can stand on hex i then obviously it can occupy its second hex from that position
|
|
|
+ ret.push_back(stack->occupiedHex(i));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if(attackable)
|
|
|
+ {
|
|
|
+ auto meleeAttackable = [&](BattleHex hex) -> bool
|
|
|
+ {
|
|
|
+ // Return true if given hex has at least one available neighbour.
|
|
|
+ // Available hexes are already present in ret vector.
|
|
|
+ auto availableNeighbor = boost::find_if(ret, [=] (BattleHex availableHex)
|
|
|
+ { return BattleHex::mutualPosition(hex, availableHex) >= 0; });
|
|
|
+
|
|
|
+ return availableNeighbor != ret.end();
|
|
|
+ };
|
|
|
+
|
|
|
+ BOOST_FOREACH(const CStack * otherSt, battleAliveStacks(stack->attackerOwned))
|
|
|
+ {
|
|
|
+ if(!otherSt->isValidTarget(false))
|
|
|
+ continue;
|
|
|
+
|
|
|
+ std::vector<BattleHex> occupied = otherSt->getHexes();
|
|
|
+
|
|
|
+ if(battleCanShoot(stack, otherSt->position))
|
|
|
+ {
|
|
|
+ attackable->insert(attackable->end(), occupied.begin(), occupied.end());
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ BOOST_FOREACH(BattleHex he, occupied)
|
|
|
+ {
|
|
|
+ if(meleeAttackable(he))
|
|
|
+ attackable->push_back(he);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //adding occupiable likely adds duplicates to ret -> clean it up
|
|
|
+ boost::sort(ret);
|
|
|
+ ret.erase(boost::unique(ret).end(), ret.end());
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+bool CBattleInfoCallback::battleCanShoot(const CStack * stack, BattleHex dest) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+
|
|
|
+ if(battleTacticDist()) //no shooting during tactics
|
|
|
+ return false;
|
|
|
+
|
|
|
+ const CStack *dst = battleGetStackByPos(dest);
|
|
|
+
|
|
|
+ if(!stack || !dst)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ if(stack->hasBonusOfType(Bonus::FORGETFULL)) //forgetfulness
|
|
|
+ return false;
|
|
|
+
|
|
|
+ if(stack->getCreature()->idNumber == 145 && dst) //catapult cannot attack creatures
|
|
|
+ return false;
|
|
|
+
|
|
|
+ //const CGHeroInstance * stackHero = battleGetOwner(stack);
|
|
|
+ if(stack->hasBonusOfType(Bonus::SHOOTER)//it's shooter
|
|
|
+ && stack->owner != dst->owner
|
|
|
+ && dst->alive()
|
|
|
+ && (!battleIsStackBlocked(stack) || stack->hasBonusOfType(Bonus::FREE_SHOOTING))
|
|
|
+ && stack->shots
|
|
|
+ )
|
|
|
+ return true;
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+TDmgRange CBattleInfoCallback::calculateDmgRange(const CStack* attacker, const CStack* defender, bool shooting,
|
|
|
+ ui8 charge, bool lucky, bool deathBlow, bool ballistaDoubleDmg) const
|
|
|
+{
|
|
|
+ return calculateDmgRange(attacker, defender, attacker->count, shooting, charge, lucky, deathBlow, ballistaDoubleDmg);
|
|
|
+}
|
|
|
+
|
|
|
+TDmgRange CBattleInfoCallback::calculateDmgRange( const CStack* attacker, const CStack* defender, TQuantity attackerCount,
|
|
|
+ bool shooting, ui8 charge, bool lucky, bool deathBlow, bool ballistaDoubleDmg ) const
|
|
|
+{
|
|
|
+ double additiveBonus = 1.0, multBonus = 1.0,
|
|
|
+ minDmg = attacker->getMinDamage() * attackerCount,
|
|
|
+ maxDmg = attacker->getMaxDamage() * attackerCount;
|
|
|
+
|
|
|
+ if(attacker->getCreature()->idNumber == 149) //arrow turret
|
|
|
+ {
|
|
|
+ switch(attacker->position)
|
|
|
+ {
|
|
|
+ case -2: //keep
|
|
|
+ minDmg = 15;
|
|
|
+ maxDmg = 15;
|
|
|
+ break;
|
|
|
+ case -3: case -4: //turrets
|
|
|
+ minDmg = 7.5;
|
|
|
+ maxDmg = 7.5;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(attacker->hasBonusOfType(Bonus::SIEGE_WEAPON) && attacker->getCreature()->idNumber != 149) //any siege weapon, but only ballista can attack (second condition - not arrow turret)
|
|
|
+ { //minDmg and maxDmg are multiplied by hero attack + 1
|
|
|
+ auto retreivePrimSkill = [&](int skill) -> int
|
|
|
+ {
|
|
|
+ const Bonus *b = attacker->getBonus(Selector::sourceTypeSel(Bonus::HERO_BASE_SKILL) && Selector::typeSubtype(Bonus::PRIMARY_SKILL, skill));
|
|
|
+ return b ? b->val : 0; //if there is no hero or no info on his primary skill, return 0
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ minDmg *= retreivePrimSkill(PrimarySkill::ATTACK) + 1;
|
|
|
+ maxDmg *= retreivePrimSkill(PrimarySkill::ATTACK) + 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ int attackDefenceDifference = 0;
|
|
|
+ if(attacker->hasBonusOfType(Bonus::GENERAL_ATTACK_REDUCTION))
|
|
|
+ {
|
|
|
+ double multAttackReduction = attacker->valOfBonuses(Bonus::GENERAL_ATTACK_REDUCTION, -1024) / 100.0;
|
|
|
+ attackDefenceDifference = attacker->Attack() * multAttackReduction;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ attackDefenceDifference = attacker->Attack();
|
|
|
+ }
|
|
|
+
|
|
|
+ if(attacker->hasBonusOfType(Bonus::ENEMY_DEFENCE_REDUCTION))
|
|
|
+ {
|
|
|
+ double multDefenceReduction = (100 - attacker->valOfBonuses(Bonus::ENEMY_DEFENCE_REDUCTION, -1024)) / 100.0;
|
|
|
+ attackDefenceDifference -= defender->Defense() * multDefenceReduction;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ attackDefenceDifference -= defender->Defense();
|
|
|
+ }
|
|
|
+
|
|
|
+ //calculating total attack/defense skills modifier
|
|
|
+
|
|
|
+ if(shooting) //precision handling (etc.)
|
|
|
+ attackDefenceDifference += attacker->getBonuses(Selector::typeSubtype(Bonus::PRIMARY_SKILL, PrimarySkill::ATTACK), Selector::effectRange(Bonus::ONLY_DISTANCE_FIGHT))->totalValue();
|
|
|
+ else //bloodlust handling (etc.)
|
|
|
+ attackDefenceDifference += attacker->getBonuses(Selector::typeSubtype(Bonus::PRIMARY_SKILL, PrimarySkill::ATTACK), Selector::effectRange(Bonus::ONLY_MELEE_FIGHT))->totalValue();
|
|
|
+
|
|
|
+
|
|
|
+ if(attacker->getEffect(55)) //slayer handling
|
|
|
+ {
|
|
|
+ std::vector<int> affectedIds;
|
|
|
+ int spLevel = attacker->getEffect(55)->val;
|
|
|
+
|
|
|
+ for(int g = 0; g < VLC->creh->creatures.size(); ++g)
|
|
|
+ {
|
|
|
+ BOOST_FOREACH(const Bonus *b, VLC->creh->creatures[g]->getBonusList())
|
|
|
+ {
|
|
|
+ if ( (b->type == Bonus::KING3 && spLevel >= 3) || //expert
|
|
|
+ (b->type == Bonus::KING2 && spLevel >= 2) || //adv +
|
|
|
+ (b->type == Bonus::KING1 && spLevel >= 0) ) //none or basic +
|
|
|
+ {
|
|
|
+ affectedIds.push_back(g);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ for(ui32 g=0; g<affectedIds.size(); ++g)
|
|
|
+ {
|
|
|
+ if(defender->getCreature()->idNumber == affectedIds[g])
|
|
|
+ {
|
|
|
+ attackDefenceDifference += VLC->spellh->spells[55]->powers[attacker->getEffect(55)->val];
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //bonus from attack/defense skills
|
|
|
+ if(attackDefenceDifference < 0) //decreasing dmg
|
|
|
+ {
|
|
|
+ const double dec = std::min(0.025 * (-attackDefenceDifference), 0.7);
|
|
|
+ multBonus *= 1.0 - dec;
|
|
|
+ }
|
|
|
+ else //increasing dmg
|
|
|
+ {
|
|
|
+ const double inc = std::min(0.05 * attackDefenceDifference, 4.0);
|
|
|
+ additiveBonus += inc;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ //applying jousting bonus
|
|
|
+ if( attacker->hasBonusOfType(Bonus::JOUSTING) && !defender->hasBonusOfType(Bonus::CHARGE_IMMUNITY) )
|
|
|
+ additiveBonus += charge * 0.05;
|
|
|
+
|
|
|
+
|
|
|
+ //handling secondary abilities and artifacts giving premies to them
|
|
|
+ if(shooting)
|
|
|
+ additiveBonus += attacker->valOfBonuses(Bonus::SECONDARY_SKILL_PREMY, CGHeroInstance::ARCHERY) / 100.0;
|
|
|
+ else
|
|
|
+ additiveBonus += attacker->valOfBonuses(Bonus::SECONDARY_SKILL_PREMY, CGHeroInstance::OFFENCE) / 100.0;
|
|
|
+
|
|
|
+ if(defender)
|
|
|
+ multBonus *= (std::max(0, 100 - defender->valOfBonuses(Bonus::SECONDARY_SKILL_PREMY, CGHeroInstance::ARMORER))) / 100.0;
|
|
|
+
|
|
|
+ //handling hate effect
|
|
|
+ additiveBonus += attacker->valOfBonuses(Bonus::HATE, defender->getCreature()->idNumber) / 100.;
|
|
|
+
|
|
|
+ //luck bonus
|
|
|
+ if (lucky)
|
|
|
+ {
|
|
|
+ additiveBonus += 1.0;
|
|
|
+ }
|
|
|
+
|
|
|
+ //ballista double dmg
|
|
|
+ if(ballistaDoubleDmg)
|
|
|
+ {
|
|
|
+ additiveBonus += 1.0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (deathBlow) //Dread Knight and many WoGified creatures
|
|
|
+ {
|
|
|
+ additiveBonus += 1.0;
|
|
|
+ }
|
|
|
+
|
|
|
+ //handling spell effects
|
|
|
+ if(!shooting && defender->hasBonusOfType(Bonus::GENERAL_DAMAGE_REDUCTION, 0)) //eg. shield
|
|
|
+ {
|
|
|
+ multBonus *= defender->valOfBonuses(Bonus::GENERAL_DAMAGE_REDUCTION, 0) / 100.0;
|
|
|
+ }
|
|
|
+ else if(shooting && defender->hasBonusOfType(Bonus::GENERAL_DAMAGE_REDUCTION, 1)) //eg. air shield
|
|
|
+ {
|
|
|
+ multBonus *= defender->valOfBonuses(Bonus::GENERAL_DAMAGE_REDUCTION, 1) / 100.0;
|
|
|
+ }
|
|
|
+
|
|
|
+ TBonusListPtr curseEffects = attacker->getBonuses(Selector::type(Bonus::ALWAYS_MINIMUM_DAMAGE)); //attacker->getEffect(42);
|
|
|
+ TBonusListPtr blessEffects = attacker->getBonuses(Selector::type(Bonus::ALWAYS_MAXIMUM_DAMAGE)); //attacker->getEffect(43);
|
|
|
+ int curseBlessAdditiveModifier = blessEffects->totalValue() - curseEffects->totalValue();
|
|
|
+ double curseMultiplicativePenalty = curseEffects->size() ? (*std::max_element(curseEffects->begin(), curseEffects->end(), &Bonus::compareByAdditionalInfo))->additionalInfo : 0;
|
|
|
+
|
|
|
+ if(curseMultiplicativePenalty) //curse handling (partial, the rest is below)
|
|
|
+ {
|
|
|
+ multBonus *= 1.0 - curseMultiplicativePenalty/100;
|
|
|
+ }
|
|
|
+
|
|
|
+ auto isAdvancedAirShield = [](const Bonus *bonus)
|
|
|
+ {
|
|
|
+ return bonus->source == Bonus::SPELL_EFFECT
|
|
|
+ && bonus->sid == Spells::AIR_SHIELD
|
|
|
+ && bonus->val >= SecSkillLevel::ADVANCED;
|
|
|
+ };
|
|
|
+
|
|
|
+ //wall / distance penalty + advanced air shield
|
|
|
+ const bool distPenalty = !attacker->hasBonusOfType(Bonus::NO_DISTANCE_PENALTY) && battleHasDistancePenalty(attacker, defender->position);
|
|
|
+ const bool obstaclePenalty = battleHasWallPenalty(attacker, defender->position);
|
|
|
+
|
|
|
+ if (shooting)
|
|
|
+ {
|
|
|
+ if (distPenalty || defender->hasBonus(isAdvancedAirShield))
|
|
|
+ {
|
|
|
+ multBonus *= 0.5;
|
|
|
+ }
|
|
|
+ if (obstaclePenalty)
|
|
|
+ {
|
|
|
+ multBonus *= 0.5; //cumulative
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!shooting && attacker->hasBonusOfType(Bonus::SHOOTER) && !attacker->hasBonusOfType(Bonus::NO_MELEE_PENALTY))
|
|
|
+ {
|
|
|
+ multBonus *= 0.5;
|
|
|
+ }
|
|
|
+
|
|
|
+ minDmg *= additiveBonus * multBonus;
|
|
|
+ maxDmg *= additiveBonus * multBonus;
|
|
|
+
|
|
|
+ TDmgRange returnedVal;
|
|
|
+
|
|
|
+ if(curseEffects->size()) //curse handling (rest)
|
|
|
+ {
|
|
|
+ minDmg += curseBlessAdditiveModifier;
|
|
|
+ returnedVal = std::make_pair(int(minDmg), int(minDmg));
|
|
|
+ }
|
|
|
+ else if(blessEffects->size()) //bless handling
|
|
|
+ {
|
|
|
+ maxDmg += curseBlessAdditiveModifier;
|
|
|
+ returnedVal = std::make_pair(int(maxDmg), int(maxDmg));
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ returnedVal = std::make_pair(int(minDmg), int(maxDmg));
|
|
|
+ }
|
|
|
+
|
|
|
+ //damage cannot be less than 1
|
|
|
+ vstd::amax(returnedVal.first, 1);
|
|
|
+ vstd::amax(returnedVal.second, 1);
|
|
|
+
|
|
|
+ return returnedVal;
|
|
|
+}
|
|
|
+
|
|
|
+TDmgRange CBattleInfoCallback::battleEstimateDamage(const CStack * attacker, const CStack * defender, TDmgRange * retaliationDmg) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(std::make_pair(0, 0));
|
|
|
+
|
|
|
+ const bool shooting = battleCanShoot(attacker, defender->position);
|
|
|
+ const ui8 mySide = !attacker->attackerOwned;
|
|
|
+
|
|
|
+ TDmgRange ret = calculateDmgRange(attacker, defender, shooting, 0, false, false, false);
|
|
|
+
|
|
|
+ if(retaliationDmg)
|
|
|
+ {
|
|
|
+ if(shooting)
|
|
|
+ {
|
|
|
+ retaliationDmg->first = retaliationDmg->second = 0;
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ ui32 TDmgRange::* pairElems[] = {&TDmgRange::first, &TDmgRange::second};
|
|
|
+ for (int i=0; i<2; ++i)
|
|
|
+ {
|
|
|
+ BattleStackAttacked bsa;
|
|
|
+ bsa.damageAmount = ret.*pairElems[i];
|
|
|
+ retaliationDmg->*pairElems[!i] = calculateDmgRange(defender, attacker, bsa.newAmount, false, 0, false, false, false).*pairElems[!i];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+shared_ptr<const CObstacleInstance> CBattleInfoCallback::battleGetObstacleOnPos(BattleHex tile, bool onlyBlocking /*= true*/) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(shared_ptr<const CObstacleInstance>());
|
|
|
+
|
|
|
+ BOOST_FOREACH(auto &obs, battleGetAllObstacles())
|
|
|
+ {
|
|
|
+ if(vstd::contains(obs->getBlockedTiles(), tile)
|
|
|
+ || (!onlyBlocking && vstd::contains(obs->getAffectedTiles(), tile)))
|
|
|
+ {
|
|
|
+ return obs;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return shared_ptr<const CObstacleInstance>();
|
|
|
+}
|
|
|
+
|
|
|
+AccessibilityInfo CBattleInfoCallback::getAccesibility() const
|
|
|
+{
|
|
|
+ AccessibilityInfo ret;
|
|
|
+ ret.fill(EAccessibility::ACCESSIBLE);
|
|
|
+
|
|
|
+ //removing accessibility for side columns of hexes
|
|
|
+ for(int y = 0; y < GameConstants::BFIELD_HEIGHT; y++)
|
|
|
+ {
|
|
|
+ ret[BattleHex(GameConstants::BFIELD_WIDTH - 1, y)] = EAccessibility::SIDE_COLUMN;
|
|
|
+ ret[BattleHex(0, y)] = EAccessibility::SIDE_COLUMN;
|
|
|
+ }
|
|
|
+
|
|
|
+ //tiles occupied by standing stacks
|
|
|
+ BOOST_FOREACH(auto stack, battleAliveStacks())
|
|
|
+ {
|
|
|
+ BOOST_FOREACH(auto hex, stack->getHexes())
|
|
|
+ if(hex.isAvailable()) //towers can have <0 pos; we don't also want to overwrite side columns
|
|
|
+ ret[hex] = EAccessibility::ALIVE_STACK;
|
|
|
+ }
|
|
|
+
|
|
|
+ //obstacles
|
|
|
+ BOOST_FOREACH(const auto &obst, battleGetAllObstacles())
|
|
|
+ {
|
|
|
+ BOOST_FOREACH(auto hex, obst->getBlockedTiles())
|
|
|
+ ret[hex] = EAccessibility::OBSTACLE;
|
|
|
+ }
|
|
|
+
|
|
|
+ //walls
|
|
|
+ if(battleGetSiegeLevel() > 0)
|
|
|
+ {
|
|
|
+ static const int permanentlyLocked[] = {12, 45, 78, 112, 147, 165};
|
|
|
+ BOOST_FOREACH(auto hex, permanentlyLocked)
|
|
|
+ ret[hex] = EAccessibility::UNAVAILABLE;
|
|
|
+
|
|
|
+ //TODO likely duplicated logic
|
|
|
+ static const std::pair<int, BattleHex> lockedIfNotDestroyed[] = //(which part of wall, which hex is blocked if this part of wall is not destroyed
|
|
|
+ {std::make_pair(2, BattleHex(182)), std::make_pair(3, BattleHex(130)),
|
|
|
+ std::make_pair(4, BattleHex(62)), std::make_pair(5, BattleHex(29))};
|
|
|
+
|
|
|
+ for(int b=0; b<ARRAY_COUNT(lockedIfNotDestroyed); ++b)
|
|
|
+ {
|
|
|
+ if(battleGetWallState(lockedIfNotDestroyed[b].first) < 3)
|
|
|
+ ret[lockedIfNotDestroyed[b].second] = EAccessibility::DESTRUCTIBLE_WALL;
|
|
|
+ }
|
|
|
+
|
|
|
+ //gate
|
|
|
+ if(battleGetWallState(7) < 3) //if it attacker's unit and gate is not destroyed
|
|
|
+ {
|
|
|
+ ret[95] = ret[96] = EAccessibility::GATE; //block gate's hexes
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+ReachabilityInfo CBattleInfoCallback::makeBFS(const AccessibilityInfo &accessibility, const ReachabilityInfo::Parameters params) const
|
|
|
+{
|
|
|
+ ReachabilityInfo ret;
|
|
|
+ ret.accessibility = accessibility;
|
|
|
+ ret.params = params;
|
|
|
+
|
|
|
+ ret.predecessors.fill(BattleHex::INVALID);
|
|
|
+ ret.distances.fill(ReachabilityInfo::INFINITE_DIST);
|
|
|
+
|
|
|
+ const std::set<BattleHex> quicksands = getStoppers(params.perspective);
|
|
|
+ //const bool twoHexCreature = params.doubleWide;
|
|
|
+
|
|
|
+
|
|
|
+ std::queue<BattleHex> hexq; //bfs queue
|
|
|
+
|
|
|
+ //first element
|
|
|
+ hexq.push(params.startPosition);
|
|
|
+ ret.distances[params.startPosition] = 0;
|
|
|
+
|
|
|
+ while(!hexq.empty()) //bfs loop
|
|
|
+ {
|
|
|
+ const BattleHex curHex = hexq.front();
|
|
|
+ hexq.pop();
|
|
|
+
|
|
|
+ //walking stack can't step past the quicksands
|
|
|
+ //TODO what if second hex of two-hex creature enters quicksand
|
|
|
+ if(curHex != params.startPosition && vstd::contains(quicksands, curHex))
|
|
|
+ continue;
|
|
|
+
|
|
|
+ const int costToNeighbour = ret.distances[curHex] + 1;
|
|
|
+ BOOST_FOREACH(BattleHex neighbour, curHex.neighbouringTiles())
|
|
|
+ {
|
|
|
+ const bool accessible = accessibility.accessible(neighbour, params.doubleWide, params.attackerOwned);
|
|
|
+ const int costFoundSoFar = ret.distances[neighbour];
|
|
|
+
|
|
|
+ if(accessible && costToNeighbour < costFoundSoFar)
|
|
|
+ {
|
|
|
+ hexq.push(neighbour);
|
|
|
+ ret.distances[neighbour] = costToNeighbour;
|
|
|
+ ret.predecessors[neighbour] = curHex;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+ReachabilityInfo CBattleInfoCallback::makeBFS(const CStack *stack) const
|
|
|
+{
|
|
|
+ return makeBFS(getAccesibility(), ReachabilityInfo::Parameters(stack));
|
|
|
+}
|
|
|
+
|
|
|
+std::set<BattleHex> CBattleInfoCallback::getStoppers(BattlePerspective::BattlePerspective whichSidePerspective) const
|
|
|
+{
|
|
|
+ std::set<BattleHex> ret;
|
|
|
+ RETURN_IF_NOT_BATTLE(ret);
|
|
|
+
|
|
|
+ BOOST_FOREACH(auto &oi, battleGetAllObstacles(whichSidePerspective))
|
|
|
+ {
|
|
|
+ if(battleIsObstacleVisibleForSide(*oi, whichSidePerspective))
|
|
|
+ {
|
|
|
+ range::copy(oi->getStoppingTile(), vstd::set_inserter(ret));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+std::pair<const CStack *, BattleHex> CBattleInfoCallback::getNearestStack(const CStack * closest, boost::logic::tribool attackerOwned) const
|
|
|
+{
|
|
|
+ auto reachability = getReachability(closest);
|
|
|
+
|
|
|
+ // I hate std::pairs with their undescriptive member names first / second
|
|
|
+ struct DistStack
|
|
|
+ {
|
|
|
+ int distanceToPred;
|
|
|
+ const CStack *stack;
|
|
|
+ };
|
|
|
+
|
|
|
+ std::vector<DistStack> stackPairs; //pairs <<distance, hex>, stack>
|
|
|
+ for(int g=0; g<GameConstants::BFIELD_SIZE; ++g)
|
|
|
+ {
|
|
|
+ const CStack * atG = battleGetStackByPos(g);
|
|
|
+ if(!atG || atG->ID == closest->ID) //if there is not stack or we are the closest one
|
|
|
+ continue;
|
|
|
+
|
|
|
+ if(boost::logic::indeterminate(attackerOwned) || atG->attackerOwned == attackerOwned)
|
|
|
+ {
|
|
|
+ if(reachability.isReachable(g))
|
|
|
+ continue;
|
|
|
+
|
|
|
+ DistStack hlp = {reachability.distances[reachability.predecessors[g]], atG};
|
|
|
+ stackPairs.push_back(hlp);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(stackPairs.size() > 0)
|
|
|
+ {
|
|
|
+ auto comparator = [](DistStack lhs, DistStack rhs) { return lhs.distanceToPred < rhs.distanceToPred; };
|
|
|
+ auto minimal = boost::min_element(stackPairs, comparator);
|
|
|
+ return std::make_pair(minimal->stack, reachability.predecessors[minimal->stack->position]);
|
|
|
+ }
|
|
|
+
|
|
|
+ return std::make_pair<const CStack * , BattleHex>(NULL, BattleHex::INVALID);
|
|
|
+}
|
|
|
+
|
|
|
+si8 CBattleInfoCallback::battleGetTacticDist() const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(0);
|
|
|
+
|
|
|
+ //TODO get rid of this method
|
|
|
+ if(battleDoWeKnowAbout(battleGetTacticsSide()))
|
|
|
+ return battleTacticDist();
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+bool CBattleInfoCallback::isInTacticRange(BattleHex dest) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+ auto side = battleGetTacticsSide();
|
|
|
+ auto dist = battleGetTacticDist();
|
|
|
+
|
|
|
+ return ((!side && dest.getX() > 0 && dest.getX() <= dist)
|
|
|
+ || (side && dest.getX() < GameConstants::BFIELD_WIDTH - 1 && dest.getX() >= GameConstants::BFIELD_WIDTH - dist - 1));
|
|
|
+}
|
|
|
+
|
|
|
+ReachabilityInfo CBattleInfoCallback::getReachability(const CStack *stack) const
|
|
|
+{
|
|
|
+ ReachabilityInfo::Parameters params(stack);
|
|
|
+
|
|
|
+ if(!battleDoWeKnowAbout(!stack->attackerOwned))
|
|
|
+ {
|
|
|
+ //Stack is held by enemy, we can't use his perspective to check for reachability.
|
|
|
+ tlog3 << "Falling back to our perspective for reachability lookup for " << stack->nodeName() << std::endl;
|
|
|
+ params.perspective = battleGetMySide();
|
|
|
+ }
|
|
|
+
|
|
|
+ return getReachability(params);
|
|
|
+}
|
|
|
+
|
|
|
+ReachabilityInfo CBattleInfoCallback::getReachability(const ReachabilityInfo::Parameters ¶ms) const
|
|
|
+{
|
|
|
+ if(params.flying)
|
|
|
+ return getFlyingReachability(params);
|
|
|
+ else
|
|
|
+ return makeBFS(getAccesibility(), params);
|
|
|
+}
|
|
|
+
|
|
|
+ReachabilityInfo CBattleInfoCallback::getFlyingReachability(const ReachabilityInfo::Parameters params) const
|
|
|
+{
|
|
|
+ ReachabilityInfo ret;
|
|
|
+ ret.accessibility = getAccesibility();
|
|
|
+
|
|
|
+ for(int i = 0; i < GameConstants::BFIELD_SIZE; i++)
|
|
|
+ {
|
|
|
+ if(ret.accessibility.accessible(i, params.doubleWide, params.attackerOwned))
|
|
|
+ {
|
|
|
+ ret.predecessors[i] = params.startPosition;
|
|
|
+ ret.distances[i] = BattleHex::getDistance(params.startPosition, i);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+AttackableTiles CBattleInfoCallback::getPotentiallyAttackableHexes(const CStack* attacker, BattleHex destinationTile, BattleHex attackerPos) const
|
|
|
+{
|
|
|
+ AttackableTiles at;
|
|
|
+ RETURN_IF_NOT_BATTLE(at);
|
|
|
+
|
|
|
+ const int WN = GameConstants::BFIELD_WIDTH;
|
|
|
+ ui16 hex = (attackerPos != BattleHex::INVALID) ? attackerPos.hex : attacker->position.hex; //real or hypothetical (cursor) position
|
|
|
+ if (attacker->hasBonusOfType(Bonus::ATTACKS_ALL_ADJACENT))
|
|
|
+ {
|
|
|
+ boost::copy(attacker->getSurroundingHexes(attackerPos), vstd::set_inserter(at.hostileCreaturePositions));
|
|
|
+// BOOST_FOREACH (BattleHex tile, attacker->getSurroundingHexes(attackerPos))
|
|
|
+// at.hostileCreaturePositions.insert(tile);
|
|
|
+ }
|
|
|
+ if (attacker->hasBonusOfType(Bonus::THREE_HEADED_ATTACK))
|
|
|
+ {
|
|
|
+ std::vector<BattleHex> hexes = attacker->getSurroundingHexes(attackerPos);
|
|
|
+ BOOST_FOREACH (BattleHex tile, hexes)
|
|
|
+ {
|
|
|
+ if ((BattleHex::mutualPosition(tile, destinationTile) > -1 && BattleHex::mutualPosition(tile, hex) > -1) //adjacent both to attacker's head and attacked tile
|
|
|
+ || tile == destinationTile) //or simply attacked directly
|
|
|
+ {
|
|
|
+ const CStack * st = battleGetStackByPos(tile, true);
|
|
|
+ if(st && st->owner != attacker->owner) //only hostile stacks - does it work well with Berserk?
|
|
|
+ {
|
|
|
+ at.hostileCreaturePositions.insert(tile);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (attacker->hasBonusOfType(Bonus::TWO_HEX_ATTACK_BREATH))
|
|
|
+ {
|
|
|
+ std::vector<BattleHex> hexes; //only one, in fact
|
|
|
+ int pseudoVector = destinationTile.hex - hex;
|
|
|
+ switch (pseudoVector)
|
|
|
+ {
|
|
|
+ case 1:
|
|
|
+ case -1:
|
|
|
+ BattleHex::checkAndPush(destinationTile.hex + pseudoVector, hexes);
|
|
|
+ break;
|
|
|
+ case WN: //17
|
|
|
+ case WN + 1: //18
|
|
|
+ case -WN: //-17
|
|
|
+ case -WN + 1: //-16
|
|
|
+ BattleHex::checkAndPush(destinationTile.hex + pseudoVector + ((hex/WN)%2 ? 1 : -1 ), hexes);
|
|
|
+ break;
|
|
|
+ case WN-1: //16
|
|
|
+ case -WN-1: //-18
|
|
|
+ BattleHex::checkAndPush(destinationTile.hex + pseudoVector + ((hex/WN)%2 ? 1 : 0), hexes);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ BOOST_FOREACH (BattleHex tile, hexes)
|
|
|
+ {
|
|
|
+ //friendly stacks can also be damaged by Dragon Breath
|
|
|
+ if(const CStack * st = battleGetStackByPos(tile, true))
|
|
|
+ at.friendlyCreaturePositions.insert(tile);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return at;
|
|
|
+}
|
|
|
+
|
|
|
+std::set<const CStack*> CBattleInfoCallback::getAttackedCreatures(const CStack* attacker, BattleHex destinationTile, BattleHex attackerPos /*= BattleHex::INVALID*/) const
|
|
|
+{
|
|
|
+ std::set<const CStack*> attackedCres;
|
|
|
+ RETURN_IF_NOT_BATTLE(attackedCres);
|
|
|
+
|
|
|
+ AttackableTiles at = getPotentiallyAttackableHexes(attacker, destinationTile, attackerPos);
|
|
|
+ BOOST_FOREACH (BattleHex tile, at.hostileCreaturePositions) //all around & three-headed attack
|
|
|
+ {
|
|
|
+ const CStack * st = battleGetStackByPos(tile, true);
|
|
|
+ if(st && st->owner != attacker->owner) //only hostile stacks - does it work well with Berserk?
|
|
|
+ {
|
|
|
+ attackedCres.insert(st);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ BOOST_FOREACH (BattleHex tile, at.friendlyCreaturePositions)
|
|
|
+ {
|
|
|
+ const CStack * st = battleGetStackByPos(tile, true);
|
|
|
+ if(st) //friendly stacks can also be damaged by Dragon Breath
|
|
|
+ {
|
|
|
+ attackedCres.insert(st);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return attackedCres;
|
|
|
+}
|
|
|
+
|
|
|
+ReachabilityInfo::TDistances CBattleInfoCallback::battleGetDistances(const CStack * stack, BattleHex hex /*= BattleHex::INVALID*/, BattleHex * predecessors /*= NULL*/) const
|
|
|
+{
|
|
|
+ ReachabilityInfo::TDistances ret;
|
|
|
+ ret.fill(-1);
|
|
|
+ RETURN_IF_NOT_BATTLE(ret);
|
|
|
+
|
|
|
+ ReachabilityInfo::Parameters params(stack);
|
|
|
+ params.startPosition = hex.isValid() ? hex : stack->position;
|
|
|
+ auto reachability = getReachability(params);
|
|
|
+
|
|
|
+ boost::copy(reachability.distances, ret.begin());
|
|
|
+
|
|
|
+ if(predecessors)
|
|
|
+ for(int i = 0; i < GameConstants::BFIELD_SIZE; i++)
|
|
|
+ predecessors[i] = reachability.predecessors[i];
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+si8 CBattleInfoCallback::battleHasDistancePenalty(const CStack * stack, BattleHex destHex) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+ if(stack->hasBonusOfType(Bonus::NO_DISTANCE_PENALTY))
|
|
|
+ return false;
|
|
|
+
|
|
|
+ if(BattleHex::getDistance(stack->position, destHex) <= 10)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ const CStack * dstStack = battleGetStackByPos(destHex, false);
|
|
|
+ if(dstStack)
|
|
|
+ {
|
|
|
+ //If on dest hex stands stack that occupies a hex within our distance
|
|
|
+ BOOST_FOREACH(auto hex, dstStack->getHexes())
|
|
|
+ if(BattleHex::getDistance(stack->position, hex) <= 10)
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+EWallParts::EWallParts CBattleInfoCallback::battleHexToWallPart(BattleHex hex) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(EWallParts::INVALID);
|
|
|
+ return hexToWallPart(hex);
|
|
|
+}
|
|
|
+
|
|
|
+ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleIsImmune(const CGHeroInstance * caster, const CSpell * spell, ECastingMode::ECastingMode mode, BattleHex dest) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(ESpellCastProblem::INVALID);
|
|
|
+
|
|
|
+
|
|
|
+ // Get stack at destination hex -> subject of our spell.
|
|
|
+ const CStack * subject = battleGetStackByPos(dest, !spell->isRisingSpell()); //only alive if not rising spell
|
|
|
+
|
|
|
+ if(subject)
|
|
|
+ {
|
|
|
+ if (spell->isPositive() && subject->hasBonusOfType(Bonus::RECEPTIVE)) //accept all positive spells
|
|
|
+ return ESpellCastProblem::OK;
|
|
|
+
|
|
|
+ switch (spell->id) //TODO: more general logic for new spells?
|
|
|
+ {
|
|
|
+ case Spells::DESTROY_UNDEAD:
|
|
|
+ if (!subject->hasBonusOfType(Bonus::UNDEAD))
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
|
|
|
+ break;
|
|
|
+ case Spells::DEATH_RIPPLE:
|
|
|
+ if (subject->hasBonusOfType(Bonus::SIEGE_WEAPON))
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL; //don't break here - undeads and war machines are immune, non-living are not
|
|
|
+ case Spells::BLESS:
|
|
|
+ case Spells::CURSE: //undeads are immune to bless & curse
|
|
|
+ if (subject->hasBonusOfType(Bonus::UNDEAD))
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
|
|
|
+ break;
|
|
|
+ case Spells::HASTE:
|
|
|
+ case Spells::SLOW:
|
|
|
+ case Spells::TELEPORT:
|
|
|
+ case Spells::CLONE:
|
|
|
+ if (subject->hasBonusOfType(Bonus::SIEGE_WEAPON))
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL; //war machines are immune to some spells than involve movement
|
|
|
+ if (spell->id == Spells::CLONE && caster) //TODO: how about stacks casting Clone?
|
|
|
+ {
|
|
|
+ if (vstd::contains(subject->state, EBattleStackState::CLONED))
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL; //can't clone already cloned creature
|
|
|
+ int maxLevel = (std::max(caster->getSpellSchoolLevel(spell), (ui8)1) + 4);
|
|
|
+ int creLevel = subject->getCreature()->level;
|
|
|
+ if (maxLevel < creLevel) //tier 1-5 for basic, 1-6 for advanced, 1-7 for expert
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Spells::FORGETFULNESS:
|
|
|
+ if (!subject->hasBonusOfType(Bonus::SHOOTER))
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
|
|
|
+ break;
|
|
|
+ case Spells::DISPEL_HELPFUL_SPELLS:
|
|
|
+ {
|
|
|
+ TBonusListPtr spellBon = subject->getSpellBonuses();
|
|
|
+ bool hasPositiveSpell = false;
|
|
|
+ BOOST_FOREACH(const Bonus * b, *spellBon)
|
|
|
+ {
|
|
|
+ if(VLC->spellh->spells[b->sid]->isPositive())
|
|
|
+ {
|
|
|
+ hasPositiveSpell = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if(!hasPositiveSpell)
|
|
|
+ {
|
|
|
+ return ESpellCastProblem::NO_SPELLS_TO_DISPEL;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ const bool damageSpell = spell->isDamageSpell();
|
|
|
+ auto battleTestElementalImmunity = [&](Bonus::BonusType element) -> bool //helper for battleisImmune
|
|
|
+ {
|
|
|
+ if (!spell->isPositive()) //negative or indifferent
|
|
|
+ {
|
|
|
+ if ((damageSpell && subject->hasBonusOfType(element, 2)) || subject->hasBonusOfType(element, 1))
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ else if (spell->isPositive()) //positive
|
|
|
+ {
|
|
|
+ if (subject->hasBonusOfType(element, 0)) //must be immune to all spells
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+ };
|
|
|
+
|
|
|
+
|
|
|
+ if (damageSpell && subject->hasBonusOfType(Bonus::DIRECT_DAMAGE_IMMUNITY))
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
|
|
|
+
|
|
|
+ if (spell->fire)
|
|
|
+ {
|
|
|
+ if (battleTestElementalImmunity(Bonus::FIRE_IMMUNITY))
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
|
|
|
+ }
|
|
|
+ if (spell->water)
|
|
|
+ {
|
|
|
+ if (battleTestElementalImmunity(Bonus::WATER_IMMUNITY))
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
|
|
|
+ }
|
|
|
+ if (spell->earth)
|
|
|
+ {
|
|
|
+ if (battleTestElementalImmunity(Bonus::EARTH_IMMUNITY))
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
|
|
|
+ }
|
|
|
+ if (spell->air)
|
|
|
+ {
|
|
|
+ if (battleTestElementalImmunity(Bonus::AIR_IMMUNITY))
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
|
|
|
+ }
|
|
|
+ if (vstd::contains(VLC->spellh->mindSpells, spell->id))
|
|
|
+ {
|
|
|
+ if (subject->hasBonusOfType(Bonus::MIND_IMMUNITY))
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (spell->isRisingSpell())
|
|
|
+ {
|
|
|
+ if (subject->count >= subject->baseAmount) //TODO: calculate potential hp raised
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
|
|
|
+ }
|
|
|
+
|
|
|
+ TBonusListPtr immunities = subject->getBonuses(Selector::type(Bonus::LEVEL_SPELL_IMMUNITY));
|
|
|
+ if(subject->hasBonusOfType(Bonus::NEGATE_ALL_NATURAL_IMMUNITIES))
|
|
|
+ {
|
|
|
+ immunities->remove_if([](const Bonus* b){ return b->source == Bonus::CREATURE_ABILITY; });
|
|
|
+ }
|
|
|
+
|
|
|
+ if(subject->hasBonusOfType(Bonus::SPELL_IMMUNITY, spell->id)
|
|
|
+ || ( immunities->size() > 0 && immunities->totalValue() >= spell->level && spell->level))
|
|
|
+ {
|
|
|
+ return ESpellCastProblem::STACK_IMMUNE_TO_SPELL;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else //no target stack on this tile
|
|
|
+ {
|
|
|
+ if(spell->getTargetType() == CSpell::CREATURE
|
|
|
+ || (spell->getTargetType() == CSpell::CREATURE_EXPERT_MASSIVE
|
|
|
+ && mode == ECastingMode::HERO_CASTING
|
|
|
+ && caster
|
|
|
+ && caster->getSpellSchoolLevel(spell) < SecSkillLevel::EXPERT))
|
|
|
+ {
|
|
|
+ return ESpellCastProblem::WRONG_SPELL_TARGET;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return ESpellCastProblem::OK;
|
|
|
+}
|
|
|
+
|
|
|
+ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastThisSpell( int player, const CSpell * spell, ECastingMode::ECastingMode mode ) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(ESpellCastProblem::INVALID);
|
|
|
+ const ui8 side = playerToSide(player);
|
|
|
+ if(!battleDoWeKnowAbout(side))
|
|
|
+ ESpellCastProblem::INVALID;
|
|
|
+
|
|
|
+ ESpellCastProblem::ESpellCastProblem genProblem = battleCanCastSpell(player, mode);
|
|
|
+ if(genProblem != ESpellCastProblem::OK)
|
|
|
+ return genProblem;
|
|
|
+
|
|
|
+ //Casting hero, set only if he is an actual caster.
|
|
|
+ const CGHeroInstance *castingHero = mode == ECastingMode::HERO_CASTING
|
|
|
+ ? battleGetFightingHero(side)
|
|
|
+ : nullptr;
|
|
|
+
|
|
|
+
|
|
|
+ switch(mode)
|
|
|
+ {
|
|
|
+ case ECastingMode::HERO_CASTING:
|
|
|
+ {
|
|
|
+ assert(castingHero);
|
|
|
+ if(!castingHero->canCastThisSpell(spell))
|
|
|
+ return ESpellCastProblem::HERO_DOESNT_KNOW_SPELL;
|
|
|
+ if(castingHero->mana < battleGetSpellCost(spell, castingHero)) //not enough mana
|
|
|
+ return ESpellCastProblem::NOT_ENOUGH_MANA;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if(spell->id < 10) //it's adventure spell (not combat))
|
|
|
+ return ESpellCastProblem::ADVMAP_SPELL_INSTEAD_OF_BATTLE_SPELL;
|
|
|
+
|
|
|
+ //TODO?
|
|
|
+ //if(NBonus::hasOfType(heroes[1-cside], Bonus::SPELL_IMMUNITY, spell->id)) //non - casting hero provides immunity for this spell
|
|
|
+ // return ESpellCastProblem::SECOND_HEROS_SPELL_IMMUNITY;
|
|
|
+ if(spell->isNegative())
|
|
|
+ {
|
|
|
+ bool allEnemiesImmune = true;
|
|
|
+ BOOST_FOREACH(auto enemyStack, battleAliveStacks(!side))
|
|
|
+ {
|
|
|
+ if(!enemyStack->hasBonusOfType(Bonus::SPELL_IMMUNITY, spell->id))
|
|
|
+ {
|
|
|
+ allEnemiesImmune = false;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(allEnemiesImmune)
|
|
|
+ return ESpellCastProblem::NO_APPROPRIATE_TARGET;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if(battleMaxSpellLevel() < spell->level) //effect like Recanter's Cloak or Orb of Inhibition
|
|
|
+ return ESpellCastProblem::SPELL_LEVEL_LIMIT_EXCEEDED;
|
|
|
+
|
|
|
+ //IDs of summon elemental spells (fire, earth, water, air)
|
|
|
+ int spellIDs[] = { Spells::SUMMON_FIRE_ELEMENTAL, Spells::SUMMON_EARTH_ELEMENTAL,
|
|
|
+ Spells::SUMMON_WATER_ELEMENTAL, Spells::SUMMON_AIR_ELEMENTAL };
|
|
|
+ //(fire, earth, water, air) elementals
|
|
|
+ int creIDs[] = {114, 113, 115, 112};
|
|
|
+
|
|
|
+ int arpos = vstd::find_pos(spellIDs, spell->id);
|
|
|
+ if(arpos < ARRAY_COUNT(spellIDs))
|
|
|
+ {
|
|
|
+ //check if there are summoned elementals of other type
|
|
|
+ BOOST_FOREACH( const CStack * st, battleAliveStacks())
|
|
|
+ if(vstd::contains(st->state, EBattleStackState::SUMMONED) && st->getCreature()->idNumber == creIDs[arpos])
|
|
|
+ return ESpellCastProblem::ANOTHER_ELEMENTAL_SUMMONED;
|
|
|
+ }
|
|
|
+
|
|
|
+ //checking if there exists an appropriate target
|
|
|
+ switch(spell->getTargetType())
|
|
|
+ {
|
|
|
+ case CSpell::CREATURE:
|
|
|
+ case CSpell::CREATURE_EXPERT_MASSIVE:
|
|
|
+ if(mode == ECastingMode::HERO_CASTING)
|
|
|
+ {
|
|
|
+ const CGHeroInstance * caster = battleGetFightingHero(player);
|
|
|
+ bool targetExists = false;
|
|
|
+ BOOST_FOREACH(const CStack * stack, battleAliveStacks())
|
|
|
+ {
|
|
|
+ switch (spell->positiveness)
|
|
|
+ {
|
|
|
+ case CSpell::POSITIVE:
|
|
|
+ if(stack->owner == caster->getOwner())
|
|
|
+ {
|
|
|
+ if(battleIsImmune(caster, spell, mode, stack->position) == ESpellCastProblem::OK)
|
|
|
+ {
|
|
|
+ targetExists = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case CSpell::NEUTRAL:
|
|
|
+ if(battleIsImmune(caster, spell, mode, stack->position) == ESpellCastProblem::OK)
|
|
|
+ {
|
|
|
+ targetExists = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case CSpell::NEGATIVE:
|
|
|
+ if(stack->owner != caster->getOwner())
|
|
|
+ {
|
|
|
+ if(battleIsImmune(caster, spell, mode, stack->position) == ESpellCastProblem::OK)
|
|
|
+ {
|
|
|
+ targetExists = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if(!targetExists)
|
|
|
+ {
|
|
|
+ return ESpellCastProblem::NO_APPROPRIATE_TARGET;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case CSpell::OBSTACLE:
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ return ESpellCastProblem::OK;
|
|
|
+}
|
|
|
+
|
|
|
+ui32 CBattleInfoCallback::battleGetSpellCost(const CSpell * sp, const CGHeroInstance * caster) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(-1);
|
|
|
+ //TODO should be replaced using bonus system facilities (propagation onto battle node)
|
|
|
+
|
|
|
+ ui32 ret = caster->getSpellCost(sp);
|
|
|
+
|
|
|
+ //checking for friendly stacks reducing cost of the spell and
|
|
|
+ //enemy stacks increasing it
|
|
|
+ si32 manaReduction = 0;
|
|
|
+ si32 manaIncrease = 0;
|
|
|
+
|
|
|
+
|
|
|
+ BOOST_FOREACH(auto stack, battleAliveStacks())
|
|
|
+ {
|
|
|
+ if(stack->owner == caster->tempOwner && stack->hasBonusOfType(Bonus::CHANGES_SPELL_COST_FOR_ALLY) )
|
|
|
+ {
|
|
|
+ vstd::amax(manaReduction, stack->valOfBonuses(Bonus::CHANGES_SPELL_COST_FOR_ALLY));
|
|
|
+ }
|
|
|
+ if( stack->owner != caster->tempOwner && stack->hasBonusOfType(Bonus::CHANGES_SPELL_COST_FOR_ENEMY) )
|
|
|
+ {
|
|
|
+ vstd::amax(manaIncrease, stack->valOfBonuses(Bonus::CHANGES_SPELL_COST_FOR_ENEMY));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return ret - manaReduction + manaIncrease;
|
|
|
+}
|
|
|
+
|
|
|
+ESpellCastProblem::ESpellCastProblem CBattleInfoCallback::battleCanCastThisSpellHere( int player, const CSpell * spell, ECastingMode::ECastingMode mode, BattleHex dest ) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(ESpellCastProblem::INVALID);
|
|
|
+ ESpellCastProblem::ESpellCastProblem moreGeneralProblem = battleCanCastThisSpell(player, spell, mode);
|
|
|
+ if(moreGeneralProblem != ESpellCastProblem::OK)
|
|
|
+ return moreGeneralProblem;
|
|
|
+
|
|
|
+ if(spell->getTargetType() == CSpell::OBSTACLE)
|
|
|
+ {
|
|
|
+ //isObstacleOnTile(dest)
|
|
|
+ //
|
|
|
+ //
|
|
|
+ //TODO
|
|
|
+ //assert that it's remove obstacle
|
|
|
+ //rules whether we can remove spell-created obstacle
|
|
|
+ return ESpellCastProblem::NO_APPROPRIATE_TARGET;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ //get dead stack if we cast resurrection or animate dead
|
|
|
+ const CStack *deadStack = getStackIf([dest](const CStack *s) { return !s->alive() && s->position == dest; });
|
|
|
+ const CStack *aliveStack = getStackIf([dest](const CStack *s) { return s->alive() && s->position == dest;});
|
|
|
+
|
|
|
+
|
|
|
+ if(spell->isRisingSpell())
|
|
|
+ {
|
|
|
+ if(!deadStack && !aliveStack)
|
|
|
+ return ESpellCastProblem::NO_APPROPRIATE_TARGET;
|
|
|
+ if(spell->id == Spells::ANIMATE_DEAD && deadStack && !deadStack->hasBonusOfType(Bonus::UNDEAD))
|
|
|
+ return ESpellCastProblem::NO_APPROPRIATE_TARGET;
|
|
|
+ if(deadStack && deadStack->owner != player) //you can resurrect only your own stacks //FIXME: it includes alive stacks as well
|
|
|
+ return ESpellCastProblem::NO_APPROPRIATE_TARGET;
|
|
|
+ }
|
|
|
+ else if(spell->getTargetType() == CSpell::CREATURE || spell->getTargetType() == CSpell::CREATURE_EXPERT_MASSIVE)
|
|
|
+ {
|
|
|
+ if(!aliveStack)
|
|
|
+ return ESpellCastProblem::NO_APPROPRIATE_TARGET;
|
|
|
+ if(spell->isNegative() && aliveStack->owner == player)
|
|
|
+ return ESpellCastProblem::NO_APPROPRIATE_TARGET;
|
|
|
+ if(spell->isPositive() && aliveStack->owner != player)
|
|
|
+ return ESpellCastProblem::NO_APPROPRIATE_TARGET;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if (mode == ECastingMode::HERO_CASTING)
|
|
|
+ return battleIsImmune(battleGetFightingHero(playerToSide(player)), spell, mode, dest);
|
|
|
+ else
|
|
|
+ return battleIsImmune(NULL, spell, mode, dest);
|
|
|
+}
|
|
|
+
|
|
|
+const CStack * CBattleInfoCallback::getStackIf(boost::function<bool(const CStack*)> pred) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(nullptr);
|
|
|
+ auto stacks = battleGetAllStacks();
|
|
|
+ auto stackItr = range::find_if(stacks, pred);
|
|
|
+ return stackItr == stacks.end()
|
|
|
+ ? NULL
|
|
|
+ : *stackItr;
|
|
|
+}
|
|
|
+
|
|
|
+bool CBattleInfoCallback::battleIsStackBlocked(const CStack * stack) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+
|
|
|
+ if(stack->hasBonusOfType(Bonus::SIEGE_WEAPON)) //siege weapons cannot be blocked
|
|
|
+ return false;
|
|
|
+
|
|
|
+ BOOST_FOREACH(const CStack * s, batteAdjacentCreatures(stack))
|
|
|
+ {
|
|
|
+ if (s->owner != stack->owner) //blocked by enemy stack
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+std::set<const CStack*> CBattleInfoCallback:: batteAdjacentCreatures(const CStack * stack) const
|
|
|
+{
|
|
|
+ std::set<const CStack*> stacks;
|
|
|
+ RETURN_IF_NOT_BATTLE(stacks);
|
|
|
+
|
|
|
+ BOOST_FOREACH (BattleHex hex, stack->getSurroundingHexes())
|
|
|
+ if(const CStack *neighbour = battleGetStackByPos(hex, true))
|
|
|
+ stacks.insert(neighbour);
|
|
|
+
|
|
|
+ return stacks;
|
|
|
+}
|
|
|
+
|
|
|
+TSpell CBattleInfoCallback::getRandomBeneficialSpell(const CStack * subject) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(-1);
|
|
|
+ std::vector<TSpell> possibleSpells;
|
|
|
+
|
|
|
+ BOOST_FOREACH(const CSpell *spell, VLC->spellh->spells)
|
|
|
+ {
|
|
|
+ if (spell->isPositive()) //only positive
|
|
|
+ {
|
|
|
+ if (subject->hasBonusFrom(Bonus::SPELL_EFFECT, spell->id)
|
|
|
+ || battleCanCastThisSpellHere(subject->owner, spell, ECastingMode::CREATURE_ACTIVE_CASTING, subject->position) != ESpellCastProblem::OK)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ switch (spell->id)
|
|
|
+ {
|
|
|
+ case Spells::SHIELD:
|
|
|
+ case Spells::FIRE_SHIELD: // not if all enemy units are shooters
|
|
|
+ {
|
|
|
+ auto walker = getStackIf([&](const CStack *stack) //look for enemy, non-shooting stack
|
|
|
+ {
|
|
|
+ return stack->owner != subject->owner && !stack->shots;
|
|
|
+ });
|
|
|
+
|
|
|
+ if (!walker)
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Spells::AIR_SHIELD: //only against active shooters
|
|
|
+ {
|
|
|
+
|
|
|
+ auto shooter = getStackIf([&](const CStack *stack) //look for enemy, non-shooting stack
|
|
|
+ {
|
|
|
+ return stack->owner != subject->owner && stack->hasBonusOfType(Bonus::SHOOTER) && stack->shots;
|
|
|
+ });
|
|
|
+ if (!shooter)
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Spells::ANTI_MAGIC:
|
|
|
+ case Spells::MAGIC_MIRROR:
|
|
|
+ {
|
|
|
+ if (!battleHasHero(subject->attackerOwned)) //only if there is enemy hero
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Spells::CURE: //only damaged units - what about affected by curse?
|
|
|
+ {
|
|
|
+ if (subject->firstHPleft >= subject->MaxHealth())
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Spells::BLOODLUST:
|
|
|
+ {
|
|
|
+ if (subject->shots) //if can shoot - only if enemy uits are adjacent
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Spells::PRECISION:
|
|
|
+ {
|
|
|
+ if (!(subject->hasBonusOfType(Bonus::SHOOTER) && subject->shots))
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Spells::SLAYER://only if monsters are present
|
|
|
+ {
|
|
|
+ auto kingMonster = getStackIf([&](const CStack *stack) //look for enemy, non-shooting stack
|
|
|
+ {
|
|
|
+ return stack->owner != subject->owner
|
|
|
+ && (stack->hasBonus(Selector::type(Bonus::KING1) || Selector::type(Bonus::KING2) || Selector::type(Bonus::KING3)));
|
|
|
+ });
|
|
|
+
|
|
|
+ if (!kingMonster)
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Spells::CLONE: //not allowed
|
|
|
+ continue;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ possibleSpells.push_back(spell->id);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (possibleSpells.size())
|
|
|
+ return possibleSpells[rand() % possibleSpells.size()];
|
|
|
+ else
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+TSpell CBattleInfoCallback::getRandomCastedSpell(const CStack * caster) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(-1);
|
|
|
+
|
|
|
+ TBonusListPtr bl = caster->getBonuses(Selector::type(Bonus::SPELLCASTER));
|
|
|
+ if (!bl->size())
|
|
|
+ return -1;
|
|
|
+ int totalWeight = 0;
|
|
|
+ BOOST_FOREACH(Bonus * b, *bl)
|
|
|
+ {
|
|
|
+ totalWeight += std::max(b->additionalInfo, 1); //minimal chance to cast is 1
|
|
|
+ }
|
|
|
+ int randomPos = rand() % totalWeight;
|
|
|
+ BOOST_FOREACH(Bonus * b, *bl)
|
|
|
+ {
|
|
|
+ randomPos -= std::max(b->additionalInfo, 1);
|
|
|
+ if(randomPos < 0)
|
|
|
+ {
|
|
|
+ return b->subtype;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+int CBattleInfoCallback::battleGetSurrenderCost(int Player) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(-3);
|
|
|
+ if(!battleCanSurrender(Player))
|
|
|
+ return -1;
|
|
|
+
|
|
|
+ int ret = 0;
|
|
|
+ double discount = 0;
|
|
|
+ BOOST_FOREACH(const CStack *s, battleAliveStacks(playerToSide(Player)))
|
|
|
+ if(s->base) //we pay for our stack that comes from our army slots - condition eliminates summoned cres and war machines
|
|
|
+ ret += s->getCreature()->cost[Res::GOLD] * s->count;
|
|
|
+
|
|
|
+ if(const CGHeroInstance *h = battleGetFightingHero(playerToSide(Player)))
|
|
|
+ discount += h->valOfBonuses(Bonus::SURRENDER_DISCOUNT);
|
|
|
+
|
|
|
+ ret *= (100.0 - discount) / 100.0;
|
|
|
+ vstd::amax(ret, 0); //no negative costs for >100% discounts (impossible in original H3 mechanics, but some day...)
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+si8 CBattleInfoCallback::battleMaxSpellLevel() const
|
|
|
+{
|
|
|
+ const CBonusSystemNode *node = NULL;
|
|
|
+ if(const CGHeroInstance *h = battleGetFightingHero(battleGetMySide()))
|
|
|
+ node = h;
|
|
|
+ //TODO else use battle node
|
|
|
+ if(!node)
|
|
|
+ return GameConstants::SPELL_LEVELS;
|
|
|
+
|
|
|
+ //We can't "just get value" - it'd be 0 if there are bonuses (and all would be blocked)
|
|
|
+ auto b = node->getBonuses(Selector::type(Bonus::BLOCK_MAGIC_ABOVE));
|
|
|
+ if(b->size())
|
|
|
+ return b->totalValue();
|
|
|
+
|
|
|
+ return GameConstants::SPELL_LEVELS;
|
|
|
+}
|
|
|
+bool AccessibilityInfo::accessible(BattleHex tile, const CStack *stack) const
|
|
|
+{
|
|
|
+ return accessible(tile, stack->doubleWide(), stack->attackerOwned);
|
|
|
+}
|
|
|
+
|
|
|
+bool AccessibilityInfo::accessible(BattleHex tile, bool doubleWide, bool attackerOwned) const
|
|
|
+{
|
|
|
+ // All hexes that stack would cover if standing on tile have to be accessible.
|
|
|
+ BOOST_FOREACH(auto hex, CStack::getHexes(tile, doubleWide, attackerOwned))
|
|
|
+ if(!hex.isValid() || at(hex) != EAccessibility::ACCESSIBLE)
|
|
|
+ return false;
|
|
|
+
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+bool AccessibilityInfo::occupiable(const CStack *stack, BattleHex tile) const
|
|
|
+{
|
|
|
+ //obviously, we can occupy tile by standing on it
|
|
|
+ if(accessible(tile, stack))
|
|
|
+ return true;
|
|
|
+
|
|
|
+ if(stack->doubleWide())
|
|
|
+ {
|
|
|
+ //Check the tile next to -> if stack stands there, it'll also occupy considered hex
|
|
|
+ const BattleHex anotherTile = tile + (stack->attackerOwned ? BattleHex::RIGHT : BattleHex::LEFT);
|
|
|
+ if(accessible(anotherTile, stack))
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+ReachabilityInfo::Parameters::Parameters()
|
|
|
+{
|
|
|
+ stack = nullptr;
|
|
|
+ perspective = BattlePerspective::ALL_KNOWING;
|
|
|
+ attackerOwned = doubleWide = flying = false;
|
|
|
+}
|
|
|
+
|
|
|
+ReachabilityInfo::Parameters::Parameters(const CStack *Stack)
|
|
|
+{
|
|
|
+ stack = Stack;
|
|
|
+ perspective = (BattlePerspective::BattlePerspective)(!Stack->attackerOwned);
|
|
|
+ startPosition = Stack->position;
|
|
|
+ doubleWide = stack->doubleWide();
|
|
|
+ attackerOwned = stack->attackerOwned;
|
|
|
+ flying = stack->hasBonusOfType(Bonus::FLYING);
|
|
|
+}
|
|
|
+
|
|
|
+ESpellCastProblem::ESpellCastProblem CPlayerBattleCallback::battleCanCastThisSpell(const CSpell * spell) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(ESpellCastProblem::INVALID);
|
|
|
+ return CBattleInfoCallback::battleCanCastThisSpell(player, spell, ECastingMode::HERO_CASTING);
|
|
|
+}
|
|
|
+
|
|
|
+ESpellCastProblem::ESpellCastProblem CPlayerBattleCallback::battleCanCastThisSpell(const CSpell * spell, BattleHex destination) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(ESpellCastProblem::INVALID);
|
|
|
+ return battleCanCastThisSpellHere(player, spell, ECastingMode::HERO_CASTING, destination);
|
|
|
+}
|
|
|
+
|
|
|
+ESpellCastProblem::ESpellCastProblem CPlayerBattleCallback::battleCanCreatureCastThisSpell(const CSpell * spell, BattleHex destination) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(ESpellCastProblem::INVALID);
|
|
|
+ return battleCanCastThisSpellHere(player, spell, ECastingMode::CREATURE_ACTIVE_CASTING, destination);
|
|
|
+}
|
|
|
+
|
|
|
+bool CPlayerBattleCallback::battleCanFlee() const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+ return CBattleInfoEssentials::battleCanFlee(player);
|
|
|
+}
|
|
|
+
|
|
|
+TStacks CPlayerBattleCallback::battleGetStacks(EStackOwnership whose /*= MINE_AND_ENEMY*/, bool onlyAlive /*= true*/) const
|
|
|
+{
|
|
|
+ TStacks ret;
|
|
|
+ RETURN_IF_NOT_BATTLE(ret);
|
|
|
+ vstd::copy_if(battleGetAllStacks(), std::back_inserter(ret), [=](const CStack *s) -> bool
|
|
|
+ {
|
|
|
+ const bool ownerMatches = (whose == MINE_AND_ENEMY)
|
|
|
+ || (whose == ONLY_MINE && s->owner == player)
|
|
|
+ || (whose == ONLY_ENEMY && s->owner != player);
|
|
|
+ const bool alivenessMatches = s->alive() || !onlyAlive;
|
|
|
+ return ownerMatches && alivenessMatches;
|
|
|
+ });
|
|
|
+
|
|
|
+ return ret;
|
|
|
+}
|
|
|
+
|
|
|
+int CPlayerBattleCallback::battleGetSurrenderCost() const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(-3)
|
|
|
+ return CBattleInfoCallback::battleGetSurrenderCost(player);
|
|
|
+}
|
|
|
+
|
|
|
+bool CPlayerBattleCallback::battleCanCastSpell(ESpellCastProblem::ESpellCastProblem *outProblem /*= nullptr*/) const
|
|
|
+{
|
|
|
+ RETURN_IF_NOT_BATTLE(false);
|
|
|
+ auto problem = CBattleInfoCallback::battleCanCastSpell(player, ECastingMode::HERO_CASTING);
|
|
|
+ if(outProblem)
|
|
|
+ *outProblem = problem;
|
|
|
+
|
|
|
+ return problem == ESpellCastProblem::OK;
|
|
|
+}
|
Michał W. Urbańczyk