BattleExchangeVariant.cpp 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851
  1. /*
  2. * BattleAI.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 "BattleExchangeVariant.h"
  12. #include "../../lib/CStack.h"
  13. AttackerValue::AttackerValue()
  14. : value(0),
  15. isRetaliated(false)
  16. {
  17. }
  18. MoveTarget::MoveTarget()
  19. : positions(), cachedAttack(), score(EvaluationResult::INEFFECTIVE_SCORE), scorePerTurn(EvaluationResult::INEFFECTIVE_SCORE)
  20. {
  21. turnsToRich = 1;
  22. }
  23. float BattleExchangeVariant::trackAttack(
  24. const AttackPossibility & ap,
  25. std::shared_ptr<HypotheticBattle> hb,
  26. DamageCache & damageCache)
  27. {
  28. auto attacker = hb->getForUpdate(ap.attack.attacker->unitId());
  29. float attackValue = ap.attackValue();
  30. auto affectedUnits = ap.affectedUnits;
  31. dpsScore.ourDamageReduce += ap.attackerDamageReduce + ap.collateralDamageReduce;
  32. dpsScore.enemyDamageReduce += ap.defenderDamageReduce + ap.shootersBlockedDmg;
  33. attackerValue[attacker->unitId()].value = attackValue;
  34. affectedUnits.push_back(ap.attackerState);
  35. for(auto affectedUnit : affectedUnits)
  36. {
  37. auto unitToUpdate = hb->getForUpdate(affectedUnit->unitId());
  38. auto damageDealt = unitToUpdate->getTotalHealth() - affectedUnit->getTotalHealth();
  39. if(damageDealt > 0)
  40. {
  41. unitToUpdate->damage(damageDealt);
  42. }
  43. if(unitToUpdate->unitSide() == attacker->unitSide())
  44. {
  45. if(unitToUpdate->unitId() == attacker->unitId())
  46. {
  47. unitToUpdate->afterAttack(ap.attack.shooting, false);
  48. #if BATTLE_TRACE_LEVEL>=1
  49. logAi->trace(
  50. "%s -> %s, ap retaliation, %s, dps: %lld",
  51. ap.attack.defender->getDescription(),
  52. ap.attack.attacker->getDescription(),
  53. ap.attack.shooting ? "shot" : "mellee",
  54. damageDealt);
  55. #endif
  56. }
  57. else
  58. {
  59. #if BATTLE_TRACE_LEVEL>=1
  60. logAi->trace(
  61. "%s, ap collateral, dps: %lld",
  62. unitToUpdate->getDescription(),
  63. damageDealt);
  64. #endif
  65. }
  66. }
  67. else
  68. {
  69. if(unitToUpdate->unitId() == ap.attack.defender->unitId())
  70. {
  71. if(unitToUpdate->ableToRetaliate() && !affectedUnit->ableToRetaliate())
  72. {
  73. unitToUpdate->afterAttack(ap.attack.shooting, true);
  74. }
  75. #if BATTLE_TRACE_LEVEL>=1
  76. logAi->trace(
  77. "%s -> %s, ap attack, %s, dps: %lld",
  78. attacker->getDescription(),
  79. ap.attack.defender->getDescription(),
  80. ap.attack.shooting ? "shot" : "mellee",
  81. damageDealt);
  82. #endif
  83. }
  84. else
  85. {
  86. #if BATTLE_TRACE_LEVEL>=1
  87. logAi->trace(
  88. "%s, ap enemy collateral, dps: %lld",
  89. unitToUpdate->getDescription(),
  90. damageDealt);
  91. #endif
  92. }
  93. }
  94. }
  95. #if BATTLE_TRACE_LEVEL >= 1
  96. logAi->trace(
  97. "ap score: our: %2f, enemy: %2f, collateral: %2f, blocked: %2f",
  98. ap.attackerDamageReduce,
  99. ap.defenderDamageReduce,
  100. ap.collateralDamageReduce,
  101. ap.shootersBlockedDmg);
  102. #endif
  103. return attackValue;
  104. }
  105. float BattleExchangeVariant::trackAttack(
  106. std::shared_ptr<StackWithBonuses> attacker,
  107. std::shared_ptr<StackWithBonuses> defender,
  108. bool shooting,
  109. bool isOurAttack,
  110. DamageCache & damageCache,
  111. std::shared_ptr<HypotheticBattle> hb,
  112. bool evaluateOnly)
  113. {
  114. const std::string cachingStringBlocksRetaliation = "type_BLOCKS_RETALIATION";
  115. static const auto selectorBlocksRetaliation = Selector::type()(BonusType::BLOCKS_RETALIATION);
  116. const bool counterAttacksBlocked = attacker->hasBonus(selectorBlocksRetaliation, cachingStringBlocksRetaliation);
  117. int64_t attackDamage = damageCache.getDamage(attacker.get(), defender.get(), hb);
  118. float defenderDamageReduce = AttackPossibility::calculateDamageReduce(attacker.get(), defender.get(), attackDamage, damageCache, hb);
  119. float attackerDamageReduce = 0;
  120. if(!evaluateOnly)
  121. {
  122. #if BATTLE_TRACE_LEVEL>=1
  123. logAi->trace(
  124. "%s -> %s, normal attack, %s, dps: %lld, %2f",
  125. attacker->getDescription(),
  126. defender->getDescription(),
  127. shooting ? "shot" : "mellee",
  128. attackDamage,
  129. defenderDamageReduce);
  130. #endif
  131. if(isOurAttack)
  132. {
  133. dpsScore.enemyDamageReduce += defenderDamageReduce;
  134. attackerValue[attacker->unitId()].value += defenderDamageReduce;
  135. }
  136. else
  137. dpsScore.ourDamageReduce += defenderDamageReduce;
  138. defender->damage(attackDamage);
  139. attacker->afterAttack(shooting, false);
  140. }
  141. if(!evaluateOnly && defender->alive() && defender->ableToRetaliate() && !counterAttacksBlocked && !shooting)
  142. {
  143. auto retaliationDamage = damageCache.getDamage(defender.get(), attacker.get(), hb);
  144. attackerDamageReduce = AttackPossibility::calculateDamageReduce(defender.get(), attacker.get(), retaliationDamage, damageCache, hb);
  145. #if BATTLE_TRACE_LEVEL>=1
  146. logAi->trace(
  147. "%s -> %s, retaliation, dps: %lld, %2f",
  148. defender->getDescription(),
  149. attacker->getDescription(),
  150. retaliationDamage,
  151. attackerDamageReduce);
  152. #endif
  153. if(isOurAttack)
  154. {
  155. dpsScore.ourDamageReduce += attackerDamageReduce;
  156. attackerValue[attacker->unitId()].isRetaliated = true;
  157. }
  158. else
  159. {
  160. dpsScore.enemyDamageReduce += attackerDamageReduce;
  161. attackerValue[defender->unitId()].value += attackerDamageReduce;
  162. }
  163. attacker->damage(retaliationDamage);
  164. defender->afterAttack(false, true);
  165. }
  166. auto score = defenderDamageReduce - attackerDamageReduce;
  167. #if BATTLE_TRACE_LEVEL>=1
  168. if(!score)
  169. {
  170. logAi->trace("Attack has zero score def:%2f att:%2f", defenderDamageReduce, attackerDamageReduce);
  171. }
  172. #endif
  173. return score;
  174. }
  175. float BattleExchangeEvaluator::scoreValue(const BattleScore & score) const
  176. {
  177. return score.enemyDamageReduce * getPositiveEffectMultiplier() - score.ourDamageReduce * getNegativeEffectMultiplier();
  178. }
  179. EvaluationResult BattleExchangeEvaluator::findBestTarget(
  180. const battle::Unit * activeStack,
  181. PotentialTargets & targets,
  182. DamageCache & damageCache,
  183. std::shared_ptr<HypotheticBattle> hb)
  184. {
  185. EvaluationResult result(targets.bestAction());
  186. if(!activeStack->waited() && !activeStack->acquireState()->hadMorale)
  187. {
  188. #if BATTLE_TRACE_LEVEL>=1
  189. logAi->trace("Evaluating waited attack for %s", activeStack->getDescription());
  190. #endif
  191. auto hbWaited = std::make_shared<HypotheticBattle>(env.get(), hb);
  192. hbWaited->resetActiveUnit();
  193. hbWaited->getForUpdate(activeStack->unitId())->waiting = true;
  194. hbWaited->getForUpdate(activeStack->unitId())->waitedThisTurn = true;
  195. updateReachabilityMap(hbWaited);
  196. for(auto & ap : targets.possibleAttacks)
  197. {
  198. float score = evaluateExchange(ap, 0, targets, damageCache, hbWaited);
  199. if(score > result.score)
  200. {
  201. result.score = score;
  202. result.bestAttack = ap;
  203. result.wait = true;
  204. #if BATTLE_TRACE_LEVEL >= 1
  205. logAi->trace("New high score %2f", result.score);
  206. #endif
  207. }
  208. }
  209. }
  210. #if BATTLE_TRACE_LEVEL>=1
  211. logAi->trace("Evaluating normal attack for %s", activeStack->getDescription());
  212. #endif
  213. updateReachabilityMap(hb);
  214. if(result.bestAttack.attack.shooting
  215. && !result.bestAttack.defenderDead
  216. && !activeStack->waited()
  217. && hb->battleHasShootingPenalty(activeStack, result.bestAttack.dest))
  218. {
  219. if(!canBeHitThisTurn(result.bestAttack))
  220. return result; // lets wait
  221. }
  222. for(auto & ap : targets.possibleAttacks)
  223. {
  224. float score = evaluateExchange(ap, 0, targets, damageCache, hb);
  225. bool sameScoreButWaited = vstd::isAlmostEqual(score, result.score) && result.wait;
  226. if(score > result.score || sameScoreButWaited)
  227. {
  228. result.score = score;
  229. result.bestAttack = ap;
  230. result.wait = false;
  231. #if BATTLE_TRACE_LEVEL >= 1
  232. logAi->trace("New high score %2f", result.score);
  233. #endif
  234. }
  235. }
  236. return result;
  237. }
  238. MoveTarget BattleExchangeEvaluator::findMoveTowardsUnreachable(
  239. const battle::Unit * activeStack,
  240. PotentialTargets & targets,
  241. DamageCache & damageCache,
  242. std::shared_ptr<HypotheticBattle> hb)
  243. {
  244. MoveTarget result;
  245. BattleExchangeVariant ev;
  246. if(targets.unreachableEnemies.empty())
  247. return result;
  248. auto speed = activeStack->getMovementRange();
  249. if(speed == 0)
  250. return result;
  251. updateReachabilityMap(hb);
  252. auto dists = cb->getReachability(activeStack);
  253. for(const battle::Unit * enemy : targets.unreachableEnemies)
  254. {
  255. std::vector<const battle::Unit *> adjacentStacks = getAdjacentUnits(enemy);
  256. auto closestStack = *vstd::minElementByFun(adjacentStacks, [&](const battle::Unit * u) -> int64_t
  257. {
  258. return dists.distToNearestNeighbour(activeStack, u) * 100000 - activeStack->getTotalHealth();
  259. });
  260. auto distance = dists.distToNearestNeighbour(activeStack, closestStack);
  261. if(distance >= GameConstants::BFIELD_SIZE)
  262. continue;
  263. if(distance <= speed)
  264. continue;
  265. auto turnsToRich = (distance - 1) / speed + 1;
  266. auto hexes = closestStack->getSurroundingHexes();
  267. auto enemySpeed = closestStack->getMovementRange();
  268. auto speedRatio = speed / static_cast<float>(enemySpeed);
  269. auto multiplier = speedRatio > 1 ? 1 : speedRatio;
  270. if(enemy->canShoot())
  271. multiplier *= 1.5f;
  272. for(auto hex : hexes)
  273. {
  274. // FIXME: provide distance info for Jousting bonus
  275. auto bai = BattleAttackInfo(activeStack, closestStack, 0, cb->battleCanShoot(activeStack));
  276. auto attack = AttackPossibility::evaluate(bai, hex, damageCache, hb);
  277. attack.shootersBlockedDmg = 0; // we do not want to count on it, it is not for sure
  278. auto score = calculateExchange(attack, turnsToRich, targets, damageCache, hb);
  279. auto scorePerTurn = BattleScore(score.enemyDamageReduce * std::sqrt(multiplier / turnsToRich), score.ourDamageReduce);
  280. if(result.scorePerTurn < scoreValue(scorePerTurn))
  281. {
  282. result.scorePerTurn = scoreValue(scorePerTurn);
  283. result.score = scoreValue(score);
  284. result.positions = closestStack->getAttackableHexes(activeStack);
  285. result.cachedAttack = attack;
  286. result.turnsToRich = turnsToRich;
  287. }
  288. }
  289. }
  290. return result;
  291. }
  292. std::vector<const battle::Unit *> BattleExchangeEvaluator::getAdjacentUnits(const battle::Unit * blockerUnit) const
  293. {
  294. std::queue<const battle::Unit *> queue;
  295. std::vector<const battle::Unit *> checkedStacks;
  296. queue.push(blockerUnit);
  297. while(!queue.empty())
  298. {
  299. auto stack = queue.front();
  300. queue.pop();
  301. checkedStacks.push_back(stack);
  302. auto hexes = stack->getSurroundingHexes();
  303. for(auto hex : hexes)
  304. {
  305. auto neighbor = cb->battleGetUnitByPos(hex);
  306. if(neighbor && neighbor->unitSide() == stack->unitSide() && !vstd::contains(checkedStacks, neighbor))
  307. {
  308. queue.push(neighbor);
  309. checkedStacks.push_back(neighbor);
  310. }
  311. }
  312. }
  313. return checkedStacks;
  314. }
  315. ReachabilityData BattleExchangeEvaluator::getExchangeUnits(
  316. const AttackPossibility & ap,
  317. uint8_t turn,
  318. PotentialTargets & targets,
  319. std::shared_ptr<HypotheticBattle> hb) const
  320. {
  321. ReachabilityData result;
  322. auto hexes = ap.attack.defender->getSurroundingHexes();
  323. if(!ap.attack.shooting) hexes.push_back(ap.from);
  324. std::vector<const battle::Unit *> allReachableUnits;
  325. for(auto hex : hexes)
  326. {
  327. vstd::concatenate(allReachableUnits, turn == 0 ? reachabilityMap.at(hex) : getOneTurnReachableUnits(turn, hex));
  328. }
  329. vstd::removeDuplicates(allReachableUnits);
  330. auto copy = allReachableUnits;
  331. for(auto unit : copy)
  332. {
  333. for(auto adjacentUnit : getAdjacentUnits(unit))
  334. {
  335. auto unitWithBonuses = hb->battleGetUnitByID(adjacentUnit->unitId());
  336. if(vstd::contains(targets.unreachableEnemies, adjacentUnit)
  337. && !vstd::contains(allReachableUnits, unitWithBonuses))
  338. {
  339. allReachableUnits.push_back(unitWithBonuses);
  340. }
  341. }
  342. }
  343. vstd::removeDuplicates(allReachableUnits);
  344. if(!vstd::contains(allReachableUnits, ap.attack.attacker))
  345. {
  346. allReachableUnits.push_back(ap.attack.attacker);
  347. }
  348. if(allReachableUnits.size() < 2)
  349. {
  350. #if BATTLE_TRACE_LEVEL>=1
  351. logAi->trace("Reachability map contains only %d stacks", allReachableUnits.size());
  352. #endif
  353. return result;
  354. }
  355. for(auto unit : allReachableUnits)
  356. {
  357. auto accessible = !unit->canShoot();
  358. if(!accessible)
  359. {
  360. for(auto hex : unit->getSurroundingHexes())
  361. {
  362. if(ap.attack.defender->coversPos(hex))
  363. {
  364. accessible = true;
  365. }
  366. }
  367. }
  368. if(accessible)
  369. result.melleeAccessible.push_back(unit);
  370. else
  371. result.shooters.push_back(unit);
  372. }
  373. for(int turn = 0; turn < turnOrder.size(); turn++)
  374. {
  375. for(auto unit : turnOrder[turn])
  376. {
  377. if(vstd::contains(allReachableUnits, unit))
  378. result.units.push_back(unit);
  379. }
  380. }
  381. vstd::erase_if(result.units, [&](const battle::Unit * u) -> bool
  382. {
  383. return !hb->battleGetUnitByID(u->unitId())->alive();
  384. });
  385. return result;
  386. }
  387. float BattleExchangeEvaluator::evaluateExchange(
  388. const AttackPossibility & ap,
  389. uint8_t turn,
  390. PotentialTargets & targets,
  391. DamageCache & damageCache,
  392. std::shared_ptr<HypotheticBattle> hb) const
  393. {
  394. BattleScore score = calculateExchange(ap, turn, targets, damageCache, hb);
  395. #if BATTLE_TRACE_LEVEL >= 1
  396. logAi->trace(
  397. "calculateExchange score +%2f -%2fx%2f = %2f",
  398. score.enemyDamageReduce,
  399. score.ourDamageReduce,
  400. getNegativeEffectMultiplier(),
  401. scoreValue(score));
  402. #endif
  403. return scoreValue(score);
  404. }
  405. BattleScore BattleExchangeEvaluator::calculateExchange(
  406. const AttackPossibility & ap,
  407. uint8_t turn,
  408. PotentialTargets & targets,
  409. DamageCache & damageCache,
  410. std::shared_ptr<HypotheticBattle> hb) const
  411. {
  412. #if BATTLE_TRACE_LEVEL>=1
  413. logAi->trace("Battle exchange at %d", ap.attack.shooting ? ap.dest.hex : ap.from.hex);
  414. #endif
  415. if(cb->battleGetMySide() == BattleSide::LEFT_SIDE
  416. && cb->battleGetGateState() == EGateState::BLOCKED
  417. && ap.attack.defender->coversPos(BattleHex::GATE_BRIDGE))
  418. {
  419. return BattleScore(EvaluationResult::INEFFECTIVE_SCORE, 0);
  420. }
  421. std::vector<const battle::Unit *> ourStacks;
  422. std::vector<const battle::Unit *> enemyStacks;
  423. if(hb->battleGetUnitByID(ap.attack.defender->unitId())->alive())
  424. enemyStacks.push_back(ap.attack.defender);
  425. ReachabilityData exchangeUnits = getExchangeUnits(ap, turn, targets, hb);
  426. if(exchangeUnits.units.empty())
  427. {
  428. return BattleScore();
  429. }
  430. auto exchangeBattle = std::make_shared<HypotheticBattle>(env.get(), hb);
  431. BattleExchangeVariant v;
  432. for(auto unit : exchangeUnits.units)
  433. {
  434. if(unit->isTurret())
  435. continue;
  436. bool isOur = exchangeBattle->battleMatchOwner(ap.attack.attacker, unit, true);
  437. auto & attackerQueue = isOur ? ourStacks : enemyStacks;
  438. auto u = exchangeBattle->getForUpdate(unit->unitId());
  439. if(u->alive() && !vstd::contains(attackerQueue, unit))
  440. {
  441. attackerQueue.push_back(unit);
  442. #if BATTLE_TRACE_LEVEL
  443. logAi->trace("Exchanging: %s", u->getDescription());
  444. #endif
  445. }
  446. }
  447. auto melleeAttackers = ourStacks;
  448. vstd::removeDuplicates(melleeAttackers);
  449. vstd::erase_if(melleeAttackers, [&](const battle::Unit * u) -> bool
  450. {
  451. return cb->battleCanShoot(u);
  452. });
  453. bool canUseAp = true;
  454. for(auto activeUnit : exchangeUnits.units)
  455. {
  456. bool isOur = exchangeBattle->battleMatchOwner(ap.attack.attacker, activeUnit, true);
  457. battle::Units & attackerQueue = isOur ? ourStacks : enemyStacks;
  458. battle::Units & oppositeQueue = isOur ? enemyStacks : ourStacks;
  459. auto attacker = exchangeBattle->getForUpdate(activeUnit->unitId());
  460. if(!attacker->alive())
  461. {
  462. #if BATTLE_TRACE_LEVEL>=1
  463. logAi->trace( "Attacker is dead");
  464. #endif
  465. continue;
  466. }
  467. auto targetUnit = ap.attack.defender;
  468. if(!isOur || !exchangeBattle->battleGetUnitByID(targetUnit->unitId())->alive())
  469. {
  470. auto estimateAttack = [&](const battle::Unit * u) -> float
  471. {
  472. auto stackWithBonuses = exchangeBattle->getForUpdate(u->unitId());
  473. auto score = v.trackAttack(
  474. attacker,
  475. stackWithBonuses,
  476. exchangeBattle->battleCanShoot(stackWithBonuses.get()),
  477. isOur,
  478. damageCache,
  479. hb,
  480. true);
  481. #if BATTLE_TRACE_LEVEL>=1
  482. logAi->trace("Best target selector %s->%s score = %2f", attacker->getDescription(), stackWithBonuses->getDescription(), score);
  483. #endif
  484. return score;
  485. };
  486. auto unitsInOppositeQueueExceptInaccessible = oppositeQueue;
  487. vstd::erase_if(unitsInOppositeQueueExceptInaccessible, [&](const battle::Unit * u)->bool
  488. {
  489. return vstd::contains(exchangeUnits.shooters, u);
  490. });
  491. if(!unitsInOppositeQueueExceptInaccessible.empty())
  492. {
  493. targetUnit = *vstd::maxElementByFun(unitsInOppositeQueueExceptInaccessible, estimateAttack);
  494. }
  495. else
  496. {
  497. auto reachable = exchangeBattle->battleGetUnitsIf([this, &exchangeBattle, &attacker](const battle::Unit * u) -> bool
  498. {
  499. if(u->unitSide() == attacker->unitSide())
  500. return false;
  501. if(!exchangeBattle->getForUpdate(u->unitId())->alive())
  502. return false;
  503. if (!u->getPosition().isValid())
  504. return false; // e.g. tower shooters
  505. return vstd::contains_if(reachabilityMap.at(u->getPosition()), [&attacker](const battle::Unit * other) -> bool
  506. {
  507. return attacker->unitId() == other->unitId();
  508. });
  509. });
  510. if(!reachable.empty())
  511. {
  512. targetUnit = *vstd::maxElementByFun(reachable, estimateAttack);
  513. }
  514. else
  515. {
  516. #if BATTLE_TRACE_LEVEL>=1
  517. logAi->trace("Battle queue is empty and no reachable enemy.");
  518. #endif
  519. continue;
  520. }
  521. }
  522. }
  523. auto defender = exchangeBattle->getForUpdate(targetUnit->unitId());
  524. auto shooting = exchangeBattle->battleCanShoot(attacker.get());
  525. const int totalAttacks = attacker->getTotalAttacks(shooting);
  526. if(canUseAp && activeUnit->unitId() == ap.attack.attacker->unitId()
  527. && targetUnit->unitId() == ap.attack.defender->unitId())
  528. {
  529. v.trackAttack(ap, exchangeBattle, damageCache);
  530. }
  531. else
  532. {
  533. for(int i = 0; i < totalAttacks; i++)
  534. {
  535. v.trackAttack(attacker, defender, shooting, isOur, damageCache, exchangeBattle);
  536. if(!attacker->alive() || !defender->alive())
  537. break;
  538. }
  539. }
  540. canUseAp = false;
  541. vstd::erase_if(attackerQueue, [&](const battle::Unit * u) -> bool
  542. {
  543. return !exchangeBattle->battleGetUnitByID(u->unitId())->alive();
  544. });
  545. vstd::erase_if(oppositeQueue, [&](const battle::Unit * u) -> bool
  546. {
  547. return !exchangeBattle->battleGetUnitByID(u->unitId())->alive();
  548. });
  549. }
  550. // avoid blocking path for stronger stack by weaker stack
  551. // the method checks if all stacks can be placed around enemy
  552. std::map<BattleHex, battle::Units> reachabilityMap;
  553. auto hexes = ap.attack.defender->getSurroundingHexes();
  554. for(auto hex : hexes)
  555. reachabilityMap[hex] = getOneTurnReachableUnits(turn, hex);
  556. #if BATTLE_TRACE_LEVEL>=1
  557. logAi->trace("Exchange score: enemy: %2f, our -%2f", v.getScore().enemyDamageReduce, v.getScore().ourDamageReduce);
  558. #endif
  559. return v.getScore();
  560. }
  561. bool BattleExchangeEvaluator::canBeHitThisTurn(const AttackPossibility & ap)
  562. {
  563. for(auto pos : ap.attack.attacker->getSurroundingHexes())
  564. {
  565. for(auto u : reachabilityMap[pos])
  566. {
  567. if(u->unitSide() != ap.attack.attacker->unitSide())
  568. {
  569. return true;
  570. }
  571. }
  572. }
  573. return false;
  574. }
  575. void BattleExchangeEvaluator::updateReachabilityMap(std::shared_ptr<HypotheticBattle> hb)
  576. {
  577. const int TURN_DEPTH = 2;
  578. turnOrder.clear();
  579. hb->battleGetTurnOrder(turnOrder, std::numeric_limits<int>::max(), TURN_DEPTH);
  580. for(auto turn : turnOrder)
  581. {
  582. for(auto u : turn)
  583. {
  584. if(!vstd::contains(reachabilityCache, u->unitId()))
  585. {
  586. reachabilityCache[u->unitId()] = hb->getReachability(u);
  587. }
  588. }
  589. }
  590. for(BattleHex hex = BattleHex::TOP_LEFT; hex.isValid(); hex = hex + 1)
  591. {
  592. reachabilityMap[hex] = getOneTurnReachableUnits(0, hex);
  593. }
  594. }
  595. std::vector<const battle::Unit *> BattleExchangeEvaluator::getOneTurnReachableUnits(uint8_t turn, BattleHex hex) const
  596. {
  597. std::vector<const battle::Unit *> result;
  598. for(int i = 0; i < turnOrder.size(); i++, turn++)
  599. {
  600. auto & turnQueue = turnOrder[i];
  601. HypotheticBattle turnBattle(env.get(), cb);
  602. for(const battle::Unit * unit : turnQueue)
  603. {
  604. if(unit->isTurret())
  605. continue;
  606. if(turnBattle.battleCanShoot(unit))
  607. {
  608. result.push_back(unit);
  609. continue;
  610. }
  611. auto unitSpeed = unit->getMovementRange(turn);
  612. auto radius = unitSpeed * (turn + 1);
  613. auto reachabilityIter = reachabilityCache.find(unit->unitId());
  614. assert(reachabilityIter != reachabilityCache.end()); // missing updateReachabilityMap call?
  615. ReachabilityInfo unitReachability = reachabilityIter != reachabilityCache.end() ? reachabilityIter->second : turnBattle.getReachability(unit);
  616. bool reachable = unitReachability.distances[hex] <= radius;
  617. if(!reachable && unitReachability.accessibility[hex] == EAccessibility::ALIVE_STACK)
  618. {
  619. const battle::Unit * hexStack = cb->battleGetUnitByPos(hex);
  620. if(hexStack && cb->battleMatchOwner(unit, hexStack, false))
  621. {
  622. for(BattleHex neighbor : hex.neighbouringTiles())
  623. {
  624. reachable = unitReachability.distances[neighbor] <= radius;
  625. if(reachable) break;
  626. }
  627. }
  628. }
  629. if(reachable)
  630. {
  631. result.push_back(unit);
  632. }
  633. }
  634. }
  635. return result;
  636. }
  637. // avoid blocking path for stronger stack by weaker stack
  638. bool BattleExchangeEvaluator::checkPositionBlocksOurStacks(HypotheticBattle & hb, const battle::Unit * activeUnit, BattleHex position)
  639. {
  640. const int BLOCKING_THRESHOLD = 70;
  641. const int BLOCKING_OWN_ATTACK_PENALTY = 100;
  642. const int BLOCKING_OWN_MOVE_PENALTY = 1;
  643. float blockingScore = 0;
  644. auto activeUnitDamage = activeUnit->getMinDamage(hb.battleCanShoot(activeUnit)) * activeUnit->getCount();
  645. for(int turn = 0; turn < turnOrder.size(); turn++)
  646. {
  647. auto & turnQueue = turnOrder[turn];
  648. HypotheticBattle turnBattle(env.get(), cb);
  649. auto unitToUpdate = turnBattle.getForUpdate(activeUnit->unitId());
  650. unitToUpdate->setPosition(position);
  651. for(const battle::Unit * unit : turnQueue)
  652. {
  653. if(unit->unitId() == unitToUpdate->unitId() || cb->battleMatchOwner(unit, activeUnit, false))
  654. continue;
  655. auto blockedUnitDamage = unit->getMinDamage(hb.battleCanShoot(unit)) * unit->getCount();
  656. float ratio = blockedUnitDamage / (float)(blockedUnitDamage + activeUnitDamage + 0.01);
  657. auto unitReachability = turnBattle.getReachability(unit);
  658. auto unitSpeed = unit->getMovementRange(turn); // Cached value, to avoid performance hit
  659. for(BattleHex hex = BattleHex::TOP_LEFT; hex.isValid(); hex = hex + 1)
  660. {
  661. bool enemyUnit = false;
  662. bool reachable = unitReachability.distances[hex] <= unitSpeed;
  663. if(!reachable && unitReachability.accessibility[hex] == EAccessibility::ALIVE_STACK)
  664. {
  665. const battle::Unit * hexStack = turnBattle.battleGetUnitByPos(hex);
  666. if(hexStack && cb->battleMatchOwner(unit, hexStack, false))
  667. {
  668. enemyUnit = true;
  669. for(BattleHex neighbor : hex.neighbouringTiles())
  670. {
  671. reachable = unitReachability.distances[neighbor] <= unitSpeed;
  672. if(reachable) break;
  673. }
  674. }
  675. }
  676. if(!reachable && std::count(reachabilityMap[hex].begin(), reachabilityMap[hex].end(), unit) > 1)
  677. {
  678. blockingScore += ratio * (enemyUnit ? BLOCKING_OWN_ATTACK_PENALTY : BLOCKING_OWN_MOVE_PENALTY);
  679. }
  680. }
  681. }
  682. }
  683. #if BATTLE_TRACE_LEVEL>=1
  684. logAi->trace("Position %d, blocking score %f", position.hex, blockingScore);
  685. #endif
  686. return blockingScore > BLOCKING_THRESHOLD;
  687. }