StupidAI.cpp 8.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326
  1. #include "StdInc.h"
  2. #include "../../lib/AI_Base.h"
  3. #include "StupidAI.h"
  4. #include "../../lib/BattleState.h"
  5. #include "../../CCallback.h"
  6. #include "../../lib/CCreatureHandler.h"
  7. shared_ptr<CBattleCallback> cbc;
  8. CStupidAI::CStupidAI(void)
  9. : side(-1)
  10. {
  11. print("created");
  12. }
  13. CStupidAI::~CStupidAI(void)
  14. {
  15. print("destroyed");
  16. }
  17. void CStupidAI::init(shared_ptr<CBattleCallback> CB)
  18. {
  19. print("init called, saving ptr to IBattleCallback");
  20. cbc = cb = CB;
  21. }
  22. void CStupidAI::actionFinished(const BattleAction &action)
  23. {
  24. print("actionFinished called");
  25. }
  26. void CStupidAI::actionStarted(const BattleAction &action)
  27. {
  28. print("actionStarted called");
  29. }
  30. struct EnemyInfo
  31. {
  32. const CStack * s;
  33. int adi, adr;
  34. std::vector<BattleHex> attackFrom; //for melee fight
  35. EnemyInfo(const CStack * _s) : s(_s)
  36. {}
  37. void calcDmg(const CStack * ourStack)
  38. {
  39. TDmgRange retal, dmg = cbc->battleEstimateDamage(ourStack, s, &retal);
  40. adi = (dmg.first + dmg.second) / 2;
  41. adr = (retal.first + retal.second) / 2;
  42. }
  43. bool operator==(const EnemyInfo& ei) const
  44. {
  45. return s == ei.s;
  46. }
  47. };
  48. bool isMoreProfitable(const EnemyInfo &ei1, const EnemyInfo& ei2)
  49. {
  50. return (ei1.adi-ei1.adr) < (ei2.adi - ei2.adr);
  51. }
  52. int distToNearestNeighbour(BattleHex hex, const ReachabilityInfo::TDistances& dists, BattleHex *chosenHex = nullptr)
  53. {
  54. int ret = 1000000;
  55. for(auto & n: hex.neighbouringTiles())
  56. {
  57. if(dists[n] >= 0 && dists[n] < ret)
  58. {
  59. ret = dists[n];
  60. if(chosenHex)
  61. *chosenHex = n;
  62. }
  63. }
  64. return ret;
  65. }
  66. bool isCloser(const EnemyInfo & ei1, const EnemyInfo & ei2, const ReachabilityInfo::TDistances & dists)
  67. {
  68. return distToNearestNeighbour(ei1.s->position, dists) < distToNearestNeighbour(ei2.s->position, dists);
  69. }
  70. static bool willSecondHexBlockMoreEnemyShooters(const BattleHex &h1, const BattleHex &h2)
  71. {
  72. int shooters[2] = {0}; //count of shooters on hexes
  73. for(int i = 0; i < 2; i++)
  74. for (auto & neighbour : (i ? h2 : h1).neighbouringTiles())
  75. if(const CStack *s = cbc->battleGetStackByPos(neighbour))
  76. if(s->getCreature()->isShooting())
  77. shooters[i]++;
  78. return shooters[0] < shooters[1];
  79. }
  80. BattleAction CStupidAI::activeStack( const CStack * stack )
  81. {
  82. //boost::this_thread::sleep(boost::posix_time::seconds(2));
  83. print("activeStack called for " + stack->nodeName());
  84. auto dists = cb->battleGetDistances(stack);
  85. std::vector<EnemyInfo> enemiesShootable, enemiesReachable, enemiesUnreachable;
  86. if(stack->type->idNumber == CreatureID::CATAPULT)
  87. {
  88. BattleAction attack;
  89. static const int wallHexes[] = {50, 183, 182, 130, 62, 29, 12, 95};
  90. attack.destinationTile = wallHexes[ rand()%ARRAY_COUNT(wallHexes) ];
  91. attack.actionType = Battle::CATAPULT;
  92. attack.additionalInfo = 0;
  93. attack.side = side;
  94. attack.stackNumber = stack->ID;
  95. return attack;
  96. }
  97. for (const CStack *s : cb->battleGetStacks(CBattleCallback::ONLY_ENEMY))
  98. {
  99. if(cb->battleCanShoot(stack, s->position))
  100. {
  101. enemiesShootable.push_back(s);
  102. }
  103. else
  104. {
  105. std::vector<BattleHex> avHexes = cb->battleGetAvailableHexes(stack, false);
  106. for (BattleHex hex : avHexes)
  107. {
  108. if(CStack::isMeleeAttackPossible(stack, s, hex))
  109. {
  110. std::vector<EnemyInfo>::iterator i = std::find(enemiesReachable.begin(), enemiesReachable.end(), s);
  111. if(i == enemiesReachable.end())
  112. {
  113. enemiesReachable.push_back(s);
  114. i = enemiesReachable.begin() + (enemiesReachable.size() - 1);
  115. }
  116. i->attackFrom.push_back(hex);
  117. }
  118. }
  119. if(!vstd::contains(enemiesReachable, s) && s->position.isValid())
  120. enemiesUnreachable.push_back(s);
  121. }
  122. }
  123. if(enemiesShootable.size())
  124. {
  125. const EnemyInfo &ei= *std::max_element(enemiesShootable.begin(), enemiesShootable.end(), isMoreProfitable);
  126. return BattleAction::makeShotAttack(stack, ei.s);
  127. }
  128. else if(enemiesReachable.size())
  129. {
  130. const EnemyInfo &ei= *std::max_element(enemiesReachable.begin(), enemiesReachable.end(), &isMoreProfitable);
  131. return BattleAction::makeMeleeAttack(stack, ei.s, *std::max_element(ei.attackFrom.begin(), ei.attackFrom.end(), &willSecondHexBlockMoreEnemyShooters));
  132. }
  133. else if(enemiesUnreachable.size()) //due to #955 - a buggy battle may occur when there are no enemies
  134. {
  135. assert(enemiesUnreachable.size());
  136. const EnemyInfo &ei= *std::min_element(enemiesUnreachable.begin(), enemiesUnreachable.end(), boost::bind(isCloser, _1, _2, boost::ref(dists)));
  137. assert(ei.s);
  138. if(distToNearestNeighbour(ei.s->position, dists) < GameConstants::BFIELD_SIZE)
  139. {
  140. return goTowards(stack, ei.s->position);
  141. }
  142. }
  143. return BattleAction::makeDefend(stack);
  144. }
  145. void CStupidAI::battleAttack(const BattleAttack *ba)
  146. {
  147. print("battleAttack called");
  148. }
  149. void CStupidAI::battleStacksAttacked(const std::vector<BattleStackAttacked> & bsa)
  150. {
  151. print("battleStacksAttacked called");
  152. }
  153. void CStupidAI::battleEnd(const BattleResult *br)
  154. {
  155. print("battleEnd called");
  156. }
  157. // void CStupidAI::battleResultsApplied()
  158. // {
  159. // print("battleResultsApplied called");
  160. // }
  161. void CStupidAI::battleNewRoundFirst(int round)
  162. {
  163. print("battleNewRoundFirst called");
  164. }
  165. void CStupidAI::battleNewRound(int round)
  166. {
  167. print("battleNewRound called");
  168. }
  169. void CStupidAI::battleStackMoved(const CStack * stack, std::vector<BattleHex> dest, int distance)
  170. {
  171. print("battleStackMoved called");;
  172. }
  173. void CStupidAI::battleSpellCast(const BattleSpellCast *sc)
  174. {
  175. print("battleSpellCast called");
  176. }
  177. void CStupidAI::battleStacksEffectsSet(const SetStackEffect & sse)
  178. {
  179. print("battleStacksEffectsSet called");
  180. }
  181. void CStupidAI::battleStart(const CCreatureSet *army1, const CCreatureSet *army2, int3 tile, const CGHeroInstance *hero1, const CGHeroInstance *hero2, bool Side)
  182. {
  183. print("battleStart called");
  184. side = Side;
  185. }
  186. void CStupidAI::battleStacksHealedRes(const std::vector<std::pair<ui32, ui32> > & healedStacks, bool lifeDrain, bool tentHeal, si32 lifeDrainFrom)
  187. {
  188. print("battleStacksHealedRes called");
  189. }
  190. void CStupidAI::battleNewStackAppeared(const CStack * stack)
  191. {
  192. print("battleNewStackAppeared called");
  193. }
  194. void CStupidAI::battleObstaclesRemoved(const std::set<si32> & removedObstacles)
  195. {
  196. print("battleObstaclesRemoved called");
  197. }
  198. void CStupidAI::battleCatapultAttacked(const CatapultAttack & ca)
  199. {
  200. print("battleCatapultAttacked called");
  201. }
  202. void CStupidAI::battleStacksRemoved(const BattleStacksRemoved & bsr)
  203. {
  204. print("battleStacksRemoved called");
  205. }
  206. void CStupidAI::print(const std::string &text) const
  207. {
  208. logAi->traceStream() << "CStupidAI [" << this <<"]: " << text;
  209. }
  210. BattleAction CStupidAI::goTowards(const CStack * stack, BattleHex destination)
  211. {
  212. assert(destination.isValid());
  213. auto avHexes = cb->battleGetAvailableHexes(stack, false);
  214. auto reachability = cb->getReachability(stack);
  215. if(vstd::contains(avHexes, destination))
  216. return BattleAction::makeMove(stack, destination);
  217. auto destNeighbours = destination.neighbouringTiles();
  218. if(vstd::contains_if(destNeighbours, [&](BattleHex n) { return stack->coversPos(destination); }))
  219. {
  220. logAi->warnStream() << "Warning: already standing on neighbouring tile!";
  221. //We shouldn't even be here...
  222. return BattleAction::makeDefend(stack);
  223. }
  224. vstd::erase_if(destNeighbours, [&](BattleHex hex){ return !reachability.accessibility.accessible(hex, stack); });
  225. if(!avHexes.size() || !destNeighbours.size()) //we are blocked or dest is blocked
  226. {
  227. print("goTowards: Stack cannot move! That's " + stack->nodeName());
  228. return BattleAction::makeDefend(stack);
  229. }
  230. if(stack->hasBonusOfType(Bonus::FLYING))
  231. {
  232. // Flying stack doesn't go hex by hex, so we can't backtrack using predecessors.
  233. // We just check all available hexes and pick the one closest to the target.
  234. auto distToDestNeighbour = [&](BattleHex hex) -> int
  235. {
  236. auto nearestNeighbourToHex = vstd::minElementByFun(destNeighbours, [&](BattleHex a)
  237. {
  238. return BattleHex::getDistance(a, hex);
  239. });
  240. return BattleHex::getDistance(*nearestNeighbourToHex, hex);
  241. };
  242. auto nearestAvailableHex = vstd::minElementByFun(avHexes, distToDestNeighbour);
  243. return BattleAction::makeMove(stack, *nearestAvailableHex);
  244. }
  245. else
  246. {
  247. BattleHex bestNeighbor = destination;
  248. if(distToNearestNeighbour(destination, reachability.distances, &bestNeighbor) > GameConstants::BFIELD_SIZE)
  249. {
  250. print("goTowards: Cannot reach");
  251. return BattleAction::makeDefend(stack);
  252. }
  253. BattleHex currentDest = bestNeighbor;
  254. while(1)
  255. {
  256. assert(currentDest.isValid());
  257. if(vstd::contains(avHexes, currentDest))
  258. return BattleAction::makeMove(stack, currentDest);
  259. currentDest = reachability.predecessors[currentDest];
  260. }
  261. }
  262. }
  263. void CStupidAI::saveGame(COSer<CSaveFile> &h, const int version)
  264. {
  265. //TODO to be implemented with saving/loading during the battles
  266. assert(0);
  267. }
  268. void CStupidAI::loadGame(CISer<CLoadFile> &h, const int version)
  269. {
  270. //TODO to be implemented with saving/loading during the battles
  271. assert(0);
  272. }