BattleFlowProcessor.cpp 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802
  1. /*
  2. * BattleFlowProcessor.cpp, part of VCMI engine
  3. *
  4. * Authors: listed in file AUTHORS in main folder
  5. *
  6. * License: GNU General Public License v2.0 or later
  7. * Full text of license available in license.txt file, in main folder
  8. *
  9. */
  10. #include "StdInc.h"
  11. #include "BattleFlowProcessor.h"
  12. #include "BattleProcessor.h"
  13. #include "../CGameHandler.h"
  14. #include "../TurnTimerHandler.h"
  15. #include "../../lib/CStack.h"
  16. #include "../../lib/battle/CBattleInfoCallback.h"
  17. #include "../../lib/battle/IBattleState.h"
  18. #include "../../lib/callback/GameRandomizer.h"
  19. #include "../../lib/entities/building/TownFortifications.h"
  20. #include "../../lib/mapObjects/CGTownInstance.h"
  21. #include "../../lib/networkPacks/PacksForClientBattle.h"
  22. #include "../../lib/spells/BonusCaster.h"
  23. #include "../../lib/spells/CSpellHandler.h"
  24. #include "../../lib/spells/ISpellMechanics.h"
  25. #include "../../lib/spells/ObstacleCasterProxy.h"
  26. #include <vstd/RNG.h>
  27. BattleFlowProcessor::BattleFlowProcessor(BattleProcessor * owner, CGameHandler * newGameHandler)
  28. : owner(owner)
  29. , gameHandler(newGameHandler)
  30. {
  31. }
  32. void BattleFlowProcessor::summonGuardiansHelper(const CBattleInfoCallback & battle, BattleHexArray & output, const BattleHex & targetPosition, BattleSide side, bool targetIsTwoHex) //return hexes for summoning two hex monsters in output, target = unit to guard
  33. {
  34. int x = targetPosition.getX();
  35. int y = targetPosition.getY();
  36. const bool targetIsAttacker = side == BattleSide::ATTACKER;
  37. if (targetIsAttacker) //handle front guardians, TODO: should we handle situation when units start battle near opposite side of the battlefield? Cannot happen in normal H3...
  38. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false).cloneInDirection(BattleHex::EDir::RIGHT, false));
  39. else
  40. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false).cloneInDirection(BattleHex::EDir::LEFT, false));
  41. //guardian spawn locations for four default position cases for attacker and defender, non-default starting location for att and def is handled in first two if's
  42. if (targetIsAttacker && ((y % 2 == 0) || (x > 1)))
  43. {
  44. if (targetIsTwoHex && (y % 2 == 1) && (x == 2)) //handle exceptional case
  45. {
  46. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::TOP_RIGHT, false));
  47. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::BOTTOM_RIGHT, false));
  48. }
  49. else
  50. { //add back-side guardians for two-hex target, side guardians for one-hex
  51. output.checkAndPush(targetPosition.cloneInDirection(targetIsTwoHex ? BattleHex::EDir::TOP_LEFT : BattleHex::EDir::TOP_RIGHT, false));
  52. output.checkAndPush(targetPosition.cloneInDirection(targetIsTwoHex ? BattleHex::EDir::BOTTOM_LEFT : BattleHex::EDir::BOTTOM_RIGHT, false));
  53. if (!targetIsTwoHex && x > 2) //back guard for one-hex
  54. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false));
  55. else if (targetIsTwoHex)//front-side guardians for two-hex target
  56. {
  57. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false).cloneInDirection(BattleHex::EDir::TOP_RIGHT, false));
  58. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false).cloneInDirection(BattleHex::EDir::BOTTOM_RIGHT, false));
  59. if (x > 3) //back guard for two-hex
  60. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false).cloneInDirection(BattleHex::EDir::LEFT, false));
  61. }
  62. }
  63. }
  64. else if (!targetIsAttacker && ((y % 2 == 1) || (x < GameConstants::BFIELD_WIDTH - 2)))
  65. {
  66. if (targetIsTwoHex && (y % 2 == 0) && (x == GameConstants::BFIELD_WIDTH - 3)) //handle exceptional case... equivalent for above for defender side
  67. {
  68. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::TOP_LEFT, false));
  69. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::BOTTOM_LEFT, false));
  70. }
  71. else
  72. {
  73. output.checkAndPush(targetPosition.cloneInDirection(targetIsTwoHex ? BattleHex::EDir::TOP_RIGHT : BattleHex::EDir::TOP_LEFT, false));
  74. output.checkAndPush(targetPosition.cloneInDirection(targetIsTwoHex ? BattleHex::EDir::BOTTOM_RIGHT : BattleHex::EDir::BOTTOM_LEFT, false));
  75. if (!targetIsTwoHex && x < GameConstants::BFIELD_WIDTH - 3)
  76. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false));
  77. else if (targetIsTwoHex)
  78. {
  79. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false).cloneInDirection(BattleHex::EDir::TOP_LEFT, false));
  80. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false).cloneInDirection(BattleHex::EDir::BOTTOM_LEFT, false));
  81. if (x < GameConstants::BFIELD_WIDTH - 4)
  82. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false).cloneInDirection(BattleHex::EDir::RIGHT, false));
  83. }
  84. }
  85. }
  86. else if (!targetIsAttacker && y % 2 == 0)
  87. {
  88. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false).cloneInDirection(BattleHex::EDir::TOP_LEFT, false));
  89. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::LEFT, false).cloneInDirection(BattleHex::EDir::BOTTOM_LEFT, false));
  90. }
  91. else if (targetIsAttacker && y % 2 == 1)
  92. {
  93. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false).cloneInDirection(BattleHex::EDir::TOP_RIGHT, false));
  94. output.checkAndPush(targetPosition.cloneInDirection(BattleHex::EDir::RIGHT, false).cloneInDirection(BattleHex::EDir::BOTTOM_RIGHT, false));
  95. }
  96. }
  97. void BattleFlowProcessor::tryPlaceMoats(const CBattleInfoCallback & battle)
  98. {
  99. const auto * town = battle.battleGetDefendedTown();
  100. if (!town)
  101. return;
  102. const auto & fortifications = town->fortificationsLevel();
  103. //Moat should be initialized here, because only here we can use spellcasting
  104. if (fortifications.hasMoat)
  105. {
  106. const auto * h = battle.battleGetFightingHero(BattleSide::DEFENDER);
  107. const auto * actualCaster = h ? static_cast<const spells::Caster*>(h) : nullptr;
  108. auto moatCaster = spells::SilentCaster(battle.sideToPlayer(BattleSide::DEFENDER), actualCaster);
  109. auto cast = spells::BattleCast(&battle, &moatCaster, spells::Mode::PASSIVE, fortifications.moatSpell.toSpell());
  110. auto target = spells::Target();
  111. cast.cast(gameHandler->spellcastEnvironment(), target);
  112. }
  113. }
  114. void BattleFlowProcessor::onBattleStarted(const CBattleInfoCallback & battle)
  115. {
  116. tryPlaceMoats(battle);
  117. gameHandler->turnTimerHandler->onBattleStart(battle.getBattle()->getBattleID());
  118. if (battle.battleGetTacticDist() == 0)
  119. onTacticsEnded(battle);
  120. }
  121. void BattleFlowProcessor::trySummonGuardians(const CBattleInfoCallback & battle, const CStack * stack)
  122. {
  123. if (!stack->hasBonusOfType(BonusType::SUMMON_GUARDIANS))
  124. return;
  125. std::shared_ptr<const Bonus> summonInfo = stack->getBonus(Selector::type()(BonusType::SUMMON_GUARDIANS));
  126. auto accessibility = battle.getAccessibility();
  127. CreatureID creatureData = summonInfo->subtype.as<CreatureID>();
  128. BattleHexArray targetHexes;
  129. const bool targetIsBig = stack->unitType()->isDoubleWide(); //target = creature to guard
  130. const bool guardianIsBig = creatureData.toCreature()->isDoubleWide();
  131. /*Chosen idea for two hex units was to cover all possible surrounding hexes of target unit with as small number of stacks as possible.
  132. For one-hex targets there are four guardians - front, back and one per side (up + down).
  133. Two-hex targets are wider and the difference is there are two guardians per side to cover 3 hexes + extra hex in the front
  134. Additionally, there are special cases for starting positions etc., where guardians would be outside of battlefield if spawned normally*/
  135. if (!guardianIsBig)
  136. targetHexes = stack->getSurroundingHexes();
  137. else
  138. summonGuardiansHelper(battle, targetHexes, stack->getPosition(), stack->unitSide(), targetIsBig);
  139. for(const auto & hex : targetHexes)
  140. {
  141. if(accessibility.accessible(hex, guardianIsBig, stack->unitSide())) //without this multiple creatures can occupy one hex
  142. {
  143. battle::UnitInfo info;
  144. info.id = battle.battleNextUnitId();
  145. info.count = std::max(1, stack->getCount() * summonInfo->val / 100);
  146. info.type = creatureData;
  147. info.side = stack->unitSide();
  148. info.position = hex;
  149. info.summoned = true;
  150. BattleUnitsChanged pack;
  151. pack.battleID = battle.getBattle()->getBattleID();
  152. pack.changedStacks.emplace_back(info.id, UnitChanges::EOperation::ADD);
  153. info.save(pack.changedStacks.back().data);
  154. gameHandler->sendAndApply(pack);
  155. }
  156. }
  157. // send empty event to client
  158. // temporary(?) workaround to force animations to trigger
  159. StacksInjured fakeEvent;
  160. fakeEvent.battleID = battle.getBattle()->getBattleID();
  161. gameHandler->sendAndApply(fakeEvent);
  162. }
  163. void BattleFlowProcessor::castOpeningSpells(const CBattleInfoCallback & battle)
  164. {
  165. for(auto i : {BattleSide::ATTACKER, BattleSide::DEFENDER})
  166. {
  167. const auto * h = battle.battleGetFightingHero(i);
  168. if (!h)
  169. continue;
  170. TConstBonusListPtr bl = h->getBonusesOfType(BonusType::OPENING_BATTLE_SPELL);
  171. for (const auto & b : *bl)
  172. {
  173. spells::BonusCaster caster(h, b);
  174. const CSpell * spell = b->subtype.as<SpellID>().toSpell();
  175. spells::BattleCast parameters(&battle, &caster, spells::Mode::PASSIVE, spell);
  176. parameters.setSpellLevel(3);
  177. parameters.setEffectDuration(b->val);
  178. parameters.massive = true;
  179. parameters.castIfPossible(gameHandler->spellcastEnvironment(), spells::Target());
  180. }
  181. }
  182. }
  183. void BattleFlowProcessor::onTacticsEnded(const CBattleInfoCallback & battle)
  184. {
  185. //initial stacks appearance triggers, e.g. built-in bonus spells
  186. auto initialStacks = battle.battleGetAllStacks(true);
  187. for (const CStack * stack : initialStacks)
  188. {
  189. trySummonGuardians(battle, stack);
  190. stackEnchantedTrigger(battle, stack);
  191. }
  192. castOpeningSpells(battle);
  193. // it is possible that due to opening spells one side was eliminated -> check for end of battle
  194. if (owner->checkBattleStateChanges(battle))
  195. return;
  196. startNextRound(battle, true);
  197. activateNextStack(battle);
  198. }
  199. void BattleFlowProcessor::startNextRound(const CBattleInfoCallback & battle, bool isFirstRound)
  200. {
  201. BattleNextRound bnr;
  202. bnr.battleID = battle.getBattle()->getBattleID();
  203. logGlobal->debug("Next round starts");
  204. gameHandler->sendAndApply(bnr);
  205. // operate on copy - removing obstacles will invalidate iterator on 'battle' container
  206. auto obstacles = battle.battleGetAllObstacles();
  207. for (const auto & obstPtr : obstacles)
  208. {
  209. const auto * sco = dynamic_cast<const SpellCreatedObstacle *>(obstPtr.get());
  210. if (sco && sco->turnsRemaining == 0)
  211. removeObstacle(battle, *obstPtr);
  212. }
  213. for(const auto * stack : battle.battleGetAllStacks(true))
  214. {
  215. if(stack->alive() && !isFirstRound)
  216. stackEnchantedTrigger(battle, stack);
  217. }
  218. }
  219. const CStack * BattleFlowProcessor::getNextStack(const CBattleInfoCallback & battle)
  220. {
  221. std::vector<battle::Units> q;
  222. battle.battleGetTurnOrder(q, 1, 0, -1); //todo: get rid of "turn -1"
  223. if(q.empty())
  224. return nullptr;
  225. if(q.front().empty())
  226. return nullptr;
  227. const auto * next = q.front().front();
  228. const auto * stack = dynamic_cast<const CStack *>(next);
  229. // regeneration takes place before everything else but only during first turn attempt in each round
  230. // also works under blind and similar effects
  231. if(stack && stack->alive() && !stack->waiting)
  232. {
  233. BattleTriggerEffect bte;
  234. bte.battleID = battle.getBattle()->getBattleID();
  235. bte.stackID = stack->unitId();
  236. bte.effect = BonusType::HP_REGENERATION;
  237. const int32_t lostHealth = stack->getMaxHealth() - stack->getFirstHPleft();
  238. if(stack->hasBonusOfType(BonusType::HP_REGENERATION))
  239. bte.val = std::min(lostHealth, stack->valOfBonuses(BonusType::HP_REGENERATION));
  240. if(bte.val) // anything to heal
  241. gameHandler->sendAndApply(bte);
  242. }
  243. if(!next || !next->willMove())
  244. return nullptr;
  245. return stack;
  246. }
  247. void BattleFlowProcessor::activateNextStack(const CBattleInfoCallback & battle)
  248. {
  249. // Find next stack that requires manual control
  250. for (;;)
  251. {
  252. // battle has ended
  253. if (owner->checkBattleStateChanges(battle))
  254. return;
  255. const CStack * next = getNextStack(battle);
  256. if (!next)
  257. {
  258. // No stacks to move - start next round
  259. startNextRound(battle, false);
  260. next = getNextStack(battle);
  261. if (!next)
  262. throw std::runtime_error("Failed to find valid stack to act!");
  263. }
  264. BattleUnitsChanged removeGhosts;
  265. removeGhosts.battleID = battle.getBattle()->getBattleID();
  266. auto pendingGhosts = battle.battleGetStacksIf([](const CStack * stack){
  267. return stack->ghostPending;
  268. });
  269. for(const auto * stack : pendingGhosts)
  270. removeGhosts.changedStacks.emplace_back(stack->unitId(), UnitChanges::EOperation::REMOVE);
  271. if(!removeGhosts.changedStacks.empty())
  272. gameHandler->sendAndApply(removeGhosts);
  273. gameHandler->turnTimerHandler->onBattleNextStack(battle.getBattle()->getBattleID(), *next);
  274. if (!tryMakeAutomaticAction(battle, next))
  275. {
  276. if(next->alive()) {
  277. setActiveStack(battle, next, BattleUnitTurnReason::TURN_QUEUE);
  278. break;
  279. }
  280. }
  281. }
  282. }
  283. bool BattleFlowProcessor::tryMakeAutomaticAction(const CBattleInfoCallback & battle, const CStack * next)
  284. {
  285. // check for bad morale => freeze
  286. int nextStackMorale = next->moraleVal();
  287. if(!next->hadMorale && !next->waited() && nextStackMorale < 0)
  288. {
  289. ObjectInstanceID ownerArmy = battle.getBattle()->getSideArmy(next->unitSide())->id;
  290. if (gameHandler->randomizer->rollBadMorale(ownerArmy, -nextStackMorale))
  291. {
  292. //unit loses its turn - empty freeze action
  293. BattleAction ba;
  294. ba.actionType = EActionType::BAD_MORALE;
  295. ba.side = next->unitSide();
  296. ba.stackNumber = next->unitId();
  297. makeAutomaticAction(battle, next, ba);
  298. return true;
  299. }
  300. }
  301. if (next->hasBonusOfType(BonusType::ATTACKS_NEAREST_CREATURE)) //while in berserk
  302. {
  303. logGlobal->trace("Handle Berserk effect");
  304. std::pair<const battle::Unit *, BattleHex> attackInfo = battle.getNearestStack(next);
  305. if (attackInfo.first != nullptr)
  306. {
  307. BattleAction attack;
  308. attack.actionType = EActionType::WALK_AND_ATTACK;
  309. attack.side = next->unitSide();
  310. attack.stackNumber = next->unitId();
  311. attack.aimToHex(attackInfo.second);
  312. attack.aimToUnit(attackInfo.first);
  313. makeAutomaticAction(battle, next, attack);
  314. logGlobal->trace("Attacked nearest target %s", attackInfo.first->getDescription());
  315. }
  316. else
  317. {
  318. makeStackDoNothing(battle, next);
  319. logGlobal->trace("No target found");
  320. }
  321. return true;
  322. }
  323. const CGHeroInstance * curOwner = battle.battleGetOwnerHero(next);
  324. const CreatureID stackCreatureId = next->unitType()->getId();
  325. if ((stackCreatureId == CreatureID::ARROW_TOWERS || stackCreatureId == CreatureID::BALLISTA)
  326. && (!curOwner || !gameHandler->randomizer->rollCombatAbility(curOwner->id, curOwner->valOfBonuses(BonusType::MANUAL_CONTROL, BonusSubtypeID(stackCreatureId)))))
  327. {
  328. BattleAction attack;
  329. attack.actionType = EActionType::SHOOT;
  330. attack.side = next->unitSide();
  331. attack.stackNumber = next->unitId();
  332. // TODO: unify logic with AI?
  333. // Find best target using logic similar to H3 AI
  334. const auto & isBetterTarget = [&battle](const battle::Unit * candidate, const battle::Unit * current)
  335. {
  336. bool candidateInsideWalls = battle.battleIsInsideWalls(candidate->getPosition());
  337. bool currentInsideWalls = battle.battleIsInsideWalls(current->getPosition());
  338. if (candidateInsideWalls != currentInsideWalls)
  339. return candidateInsideWalls > currentInsideWalls;
  340. // also check for war machines - shooters are more dangerous than war machines, ballista or catapult
  341. bool candidateCanShoot = candidate->canShoot() && candidate->unitType()->warMachine == ArtifactID::NONE;
  342. bool currentCanShoot = current->canShoot() && current->unitType()->warMachine == ArtifactID::NONE;
  343. if (candidateCanShoot != currentCanShoot)
  344. return candidateCanShoot > currentCanShoot;
  345. int64_t candidateTargetValue = static_cast<int64_t>(candidate->unitType()->getAIValue() * candidate->getCount());
  346. int64_t currentTargetValue = static_cast<int64_t>(current->unitType()->getAIValue() * current->getCount());
  347. return candidateTargetValue > currentTargetValue;
  348. };
  349. const battle::Unit * target = nullptr;
  350. for(auto & elem : battle.battleGetAllStacks(true))
  351. {
  352. if (elem->unitOwner() == next->unitOwner())
  353. continue;
  354. if (!elem->isValidTarget())
  355. continue;
  356. if (!battle.battleCanShoot(next, elem->getPosition()))
  357. continue;
  358. if (target && !isBetterTarget(elem, target))
  359. continue;
  360. target = elem;
  361. }
  362. if(target == nullptr)
  363. {
  364. makeStackDoNothing(battle, next);
  365. }
  366. else
  367. {
  368. attack.aimToUnit(target);
  369. makeAutomaticAction(battle, next, attack);
  370. }
  371. return true;
  372. }
  373. if (next->unitType()->getId() == CreatureID::CATAPULT)
  374. {
  375. const auto & attackableBattleHexes = battle.getAttackableBattleHexes();
  376. if (attackableBattleHexes.empty())
  377. {
  378. makeStackDoNothing(battle, next);
  379. return true;
  380. }
  381. if (!curOwner || !gameHandler->randomizer->rollCombatAbility(curOwner->id, curOwner->valOfBonuses(BonusType::MANUAL_CONTROL, BonusSubtypeID(CreatureID(CreatureID::CATAPULT)))))
  382. {
  383. BattleAction attack;
  384. attack.actionType = EActionType::CATAPULT;
  385. attack.side = next->unitSide();
  386. attack.stackNumber = next->unitId();
  387. makeAutomaticAction(battle, next, attack);
  388. return true;
  389. }
  390. }
  391. if (next->unitType()->getId() == CreatureID::FIRST_AID_TENT)
  392. {
  393. TStacks possibleStacks = battle.battleGetStacksIf([&next](const CStack * s)
  394. {
  395. return s->unitOwner() == next->unitOwner() && s->canBeHealed();
  396. });
  397. if (possibleStacks.empty())
  398. {
  399. makeStackDoNothing(battle, next);
  400. return true;
  401. }
  402. if (!curOwner || !gameHandler->randomizer->rollCombatAbility(curOwner->id, curOwner->valOfBonuses(BonusType::MANUAL_CONTROL, BonusSubtypeID(CreatureID(CreatureID::FIRST_AID_TENT)))))
  403. {
  404. RandomGeneratorUtil::randomShuffle(possibleStacks, gameHandler->getRandomGenerator());
  405. const CStack * toBeHealed = possibleStacks.front();
  406. BattleAction heal;
  407. heal.actionType = EActionType::STACK_HEAL;
  408. heal.aimToUnit(toBeHealed);
  409. heal.side = next->unitSide();
  410. heal.stackNumber = next->unitId();
  411. makeAutomaticAction(battle, next, heal);
  412. return true;
  413. }
  414. }
  415. stackTurnTrigger(battle, next); //various effects
  416. if(next->fear)
  417. {
  418. makeStackDoNothing(battle, next); //end immediately if stack was affected by fear
  419. return true;
  420. }
  421. return false;
  422. }
  423. bool BattleFlowProcessor::rollGoodMorale(const CBattleInfoCallback & battle, const CStack * next)
  424. {
  425. //check for good morale
  426. auto nextStackMorale = next->moraleVal();
  427. if( !next->hadMorale
  428. && !next->defending
  429. && !next->waited()
  430. && !next->fear
  431. && next->alive()
  432. && next->canMove()
  433. && nextStackMorale > 0)
  434. {
  435. ObjectInstanceID ownerArmy = battle.getBattle()->getSideArmy(next->unitSide())->id;
  436. if (gameHandler->randomizer->rollGoodMorale(ownerArmy, nextStackMorale))
  437. {
  438. BattleTriggerEffect bte;
  439. bte.battleID = battle.getBattle()->getBattleID();
  440. bte.stackID = next->unitId();
  441. bte.effect = BonusType::MORALE;
  442. bte.val = 1;
  443. bte.additionalInfo = 0;
  444. gameHandler->sendAndApply(bte); //play animation
  445. return true;
  446. }
  447. }
  448. return false;
  449. }
  450. void BattleFlowProcessor::onActionMade(const CBattleInfoCallback & battle, const BattleAction &ba)
  451. {
  452. const auto * actedStack = battle.battleGetStackByID(ba.stackNumber, false);
  453. const auto * activeStack = battle.battleActiveUnit();
  454. if (ba.actionType == EActionType::END_TACTIC_PHASE)
  455. {
  456. onTacticsEnded(battle);
  457. return;
  458. }
  459. //we're after action, all results applied
  460. // check whether action has ended the battle
  461. if(owner->checkBattleStateChanges(battle))
  462. return;
  463. // tactics - next stack will be selected by player
  464. if(battle.battleGetTacticDist() != 0)
  465. return;
  466. // creature will not skip the turn after casting a spell if spell uses canCastWithoutSkip
  467. if(ba.actionType == EActionType::MONSTER_SPELL)
  468. {
  469. assert(activeStack != nullptr);
  470. assert(actedStack != nullptr);
  471. // NOTE: in case of random spellcaster, (e.g. Master Genie) spell has been selected by server and was not present in action received from player
  472. if(actedStack->castSpellThisTurn && ba.spell.hasValue() && ba.spell.toSpell()->canCastWithoutSkip())
  473. {
  474. setActiveStack(battle, actedStack, BattleUnitTurnReason::UNIT_SPELLCAST);
  475. return;
  476. }
  477. }
  478. if (ba.isUnitAction())
  479. {
  480. assert(activeStack != nullptr);
  481. assert(actedStack != nullptr);
  482. if (rollGoodMorale(battle, actedStack))
  483. {
  484. // Good morale - same stack makes 2nd turn
  485. setActiveStack(battle, actedStack, BattleUnitTurnReason::MORALE);
  486. return;
  487. }
  488. }
  489. else
  490. {
  491. if (activeStack && activeStack->alive())
  492. {
  493. // this is action made by hero AND unit is alive (e.g. not killed by casted spell)
  494. // keep current active stack for next action
  495. setActiveStack(battle, activeStack, BattleUnitTurnReason::HERO_SPELLCAST);
  496. return;
  497. }
  498. }
  499. activateNextStack(battle);
  500. }
  501. void BattleFlowProcessor::makeStackDoNothing(const CBattleInfoCallback & battle, const CStack * next)
  502. {
  503. BattleAction doNothing;
  504. doNothing.actionType = EActionType::NO_ACTION;
  505. doNothing.side = next->unitSide();
  506. doNothing.stackNumber = next->unitId();
  507. makeAutomaticAction(battle, next, doNothing);
  508. }
  509. bool BattleFlowProcessor::makeAutomaticAction(const CBattleInfoCallback & battle, const CStack *stack, const BattleAction &ba)
  510. {
  511. BattleSetActiveStack bsa;
  512. bsa.battleID = battle.getBattle()->getBattleID();
  513. bsa.stack = stack->unitId();
  514. bsa.reason = BattleUnitTurnReason::AUTOMATIC_ACTION;
  515. gameHandler->sendAndApply(bsa);
  516. bool ret = owner->makeAutomaticBattleAction(battle, ba);
  517. return ret;
  518. }
  519. void BattleFlowProcessor::stackEnchantedTrigger(const CBattleInfoCallback & battle, const CStack * st)
  520. {
  521. auto bl = *(st->getBonusesOfType(BonusType::ENCHANTED));
  522. for(const auto & b : bl)
  523. {
  524. if (!b->subtype.as<SpellID>().hasValue())
  525. continue;
  526. const CSpell * sp = b->subtype.as<SpellID>().toSpell();
  527. const int32_t val = bl.valOfBonuses(Selector::typeSubtype(b->type, b->subtype));
  528. const int32_t level = ((val > 3) ? (val - 3) : val);
  529. spells::BattleCast battleCast(&battle, st, spells::Mode::PASSIVE, sp);
  530. //this makes effect accumulate for at most 50 turns by default, but effect may be permanent and last till the end of battle
  531. battleCast.setEffectDuration(50);
  532. battleCast.setSpellLevel(level);
  533. spells::Target target;
  534. if(val > 3)
  535. {
  536. for(const auto * s : battle.battleGetAllStacks())
  537. if(battle.battleMatchOwner(st, s, true) && s->isValidTarget()) //all allied
  538. target.emplace_back(s);
  539. }
  540. else
  541. {
  542. target.emplace_back(st);
  543. }
  544. battleCast.applyEffects(gameHandler->spellcastEnvironment(), target, false, true);
  545. }
  546. }
  547. void BattleFlowProcessor::removeObstacle(const CBattleInfoCallback & battle, const CObstacleInstance & obstacle)
  548. {
  549. BattleObstaclesChanged obsRem;
  550. obsRem.battleID = battle.getBattle()->getBattleID();
  551. obsRem.changes.emplace_back(obstacle.uniqueID, ObstacleChanges::EOperation::REMOVE);
  552. gameHandler->sendAndApply(obsRem);
  553. }
  554. void BattleFlowProcessor::stackTurnTrigger(const CBattleInfoCallback & battle, const CStack *st)
  555. {
  556. BattleTriggerEffect bte;
  557. bte.battleID = battle.getBattle()->getBattleID();
  558. bte.stackID = st->unitId();
  559. bte.effect = BonusType::NONE;
  560. bte.val = 0;
  561. bte.additionalInfo = 0;
  562. if (st->alive())
  563. {
  564. //unbind
  565. if (st->hasBonusOfType(BonusType::BIND_EFFECT))
  566. {
  567. bool unbind = true;
  568. BonusList bl = *(st->getBonusesOfType(BonusType::BIND_EFFECT));
  569. auto adjacent = battle.battleAdjacentUnits(st);
  570. for (const auto & b : bl)
  571. {
  572. if(b->additionalInfo != CAddInfo::NONE)
  573. {
  574. const CStack * stack = battle.battleGetStackByID(b->additionalInfo[0]); //binding stack must be alive and adjacent
  575. if(stack && vstd::contains(adjacent, stack)) //binding stack is still present
  576. unbind = false;
  577. }
  578. else
  579. {
  580. unbind = false;
  581. }
  582. }
  583. if (unbind)
  584. {
  585. BattleSetStackProperty ssp;
  586. ssp.battleID = battle.getBattle()->getBattleID();
  587. ssp.which = BattleSetStackProperty::UNBIND;
  588. ssp.stackID = st->unitId();
  589. gameHandler->sendAndApply(ssp);
  590. }
  591. }
  592. if (st->hasBonusOfType(BonusType::POISON))
  593. {
  594. std::shared_ptr<const Bonus> b = st->getFirstBonus(Selector::source(BonusSource::SPELL_EFFECT, BonusSourceID(SpellID(SpellID::POISON))).And(Selector::type()(BonusType::STACK_HEALTH)));
  595. if (b) //TODO: what if not?...
  596. {
  597. bte.val = std::max (b->val - 10, -(st->valOfBonuses(BonusType::POISON)));
  598. if (bte.val < b->val) //(negative) poison effect increases - update it
  599. {
  600. bte.effect = BonusType::POISON;
  601. gameHandler->sendAndApply(bte);
  602. }
  603. }
  604. }
  605. if(st->hasBonusOfType(BonusType::MANA_DRAIN) && !st->drainedMana)
  606. {
  607. const CGHeroInstance * opponentHero = battle.battleGetFightingHero(battle.otherSide(st->unitSide()));
  608. if(opponentHero)
  609. {
  610. ui32 manaDrained = st->valOfBonuses(BonusType::MANA_DRAIN);
  611. vstd::amin(manaDrained, opponentHero->mana);
  612. if(manaDrained)
  613. {
  614. bte.effect = BonusType::MANA_DRAIN;
  615. bte.val = manaDrained;
  616. bte.additionalInfo = opponentHero->id.getNum(); //for sanity
  617. gameHandler->sendAndApply(bte);
  618. }
  619. }
  620. }
  621. if (st->hasBonusOfType(BonusType::FEARFUL))
  622. {
  623. int chance = st->valOfBonuses(BonusType::FEARFUL);
  624. ObjectInstanceID opponentArmyID = battle.battleGetArmyObject(battle.otherSide(st->unitSide()))->id;
  625. if (gameHandler->randomizer->rollCombatAbility(opponentArmyID, chance))
  626. {
  627. bte.effect = BonusType::FEARFUL;
  628. gameHandler->sendAndApply(bte);
  629. }
  630. }
  631. BonusList bl = *(st->getBonuses(Selector::type()(BonusType::ENCHANTER)));
  632. bl.remove_if([](const Bonus * b)
  633. {
  634. return b->subtype.as<SpellID>() == SpellID::NONE;
  635. });
  636. BattleSide side = battle.playerToSide(st->unitOwner());
  637. if(st->canCast())
  638. {
  639. bool cast = false;
  640. while(!bl.empty() && !cast)
  641. {
  642. auto bonus = *RandomGeneratorUtil::nextItem(bl, gameHandler->getRandomGenerator());
  643. auto spellID = bonus->subtype.as<SpellID>();
  644. const CSpell * spell = SpellID(spellID).toSpell();
  645. bl.remove_if([&bonus](const Bonus * b)
  646. {
  647. return b == bonus.get();
  648. });
  649. if (battle.battleGetEnchanterCounter(side) != 0 && bonus->additionalInfo[0] != 0)
  650. continue; // cooldown
  651. spells::BattleCast parameters(&battle, st, spells::Mode::ENCHANTER, spell);
  652. parameters.setSpellLevel(bonus->val);
  653. //todo: recheck effect level
  654. if(parameters.castIfPossible(gameHandler->spellcastEnvironment(), spells::Target(1, parameters.massive ? spells::Destination() : spells::Destination(st))))
  655. {
  656. cast = true;
  657. int cooldown = bonus->additionalInfo[0];
  658. if (cooldown != 0)
  659. {
  660. BattleSetStackProperty ssp;
  661. ssp.battleID = battle.getBattle()->getBattleID();
  662. ssp.which = BattleSetStackProperty::ENCHANTER_COUNTER;
  663. ssp.absolute = false;
  664. ssp.val = cooldown;
  665. ssp.stackID = st->unitId();
  666. gameHandler->sendAndApply(ssp);
  667. }
  668. }
  669. }
  670. }
  671. }
  672. }
  673. void BattleFlowProcessor::setActiveStack(const CBattleInfoCallback & battle, const battle::Unit * stack, BattleUnitTurnReason reason)
  674. {
  675. assert(stack);
  676. BattleSetActiveStack sas;
  677. sas.battleID = battle.getBattle()->getBattleID();
  678. sas.stack = stack->unitId();
  679. sas.reason = reason;
  680. gameHandler->sendAndApply(sas);
  681. }