CGameInfoCallback.cpp 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032
  1. /*
  2. * CGameInfoCallback.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 "CGameInfoCallback.h"
  12. #include "entities/building/CBuilding.h"
  13. #include "gameState/CGameState.h"
  14. #include "gameState/InfoAboutArmy.h"
  15. #include "gameState/SThievesGuildInfo.h"
  16. #include "gameState/TavernHeroesPool.h"
  17. #include "gameState/QuestInfo.h"
  18. #include "mapObjects/CGHeroInstance.h"
  19. #include "mapObjects/CGTownInstance.h"
  20. #include "mapObjects/MiscObjects.h"
  21. #include "networkPacks/ArtifactLocation.h"
  22. #include "texts/CGeneralTextHandler.h"
  23. #include "StartInfo.h" // for StartInfo
  24. #include "battle/BattleInfo.h" // for BattleInfo
  25. #include "IGameSettings.h"
  26. #include "TerrainHandler.h"
  27. #include "spells/CSpellHandler.h"
  28. #include "mapping/CMap.h"
  29. #include "CPlayerState.h"
  30. VCMI_LIB_NAMESPACE_BEGIN
  31. //TODO make clean
  32. #define ERROR_VERBOSE_OR_NOT_RET_VAL_IF(cond, verbose, txt, retVal) do {if(cond){if(verbose)logGlobal->error("%s: %s",BOOST_CURRENT_FUNCTION, txt); return retVal;}} while(0)
  33. #define ERROR_RET_IF(cond, txt) do {if(cond){logGlobal->error("%s: %s", BOOST_CURRENT_FUNCTION, txt); return;}} while(0)
  34. #define ERROR_RET_VAL_IF(cond, txt, retVal) do {if(cond){logGlobal->error("%s: %s", BOOST_CURRENT_FUNCTION, txt); return retVal;}} while(0)
  35. PlayerColor CGameInfoCallback::getOwner(ObjectInstanceID heroID) const
  36. {
  37. const CGObjectInstance *obj = getObj(heroID);
  38. ERROR_RET_VAL_IF(!obj, "No such object!", PlayerColor::CANNOT_DETERMINE);
  39. return obj->tempOwner;
  40. }
  41. int CGameInfoCallback::getResource(PlayerColor Player, GameResID which) const
  42. {
  43. const PlayerState *p = getPlayerState(Player);
  44. ERROR_RET_VAL_IF(!p, "No player info!", -1);
  45. ERROR_RET_VAL_IF(p->resources.size() <= which.getNum() || which.getNum() < 0, "No such resource!", -1);
  46. return p->resources[which];
  47. }
  48. const PlayerSettings * CGameInfoCallback::getPlayerSettings(PlayerColor color) const
  49. {
  50. return &gs->scenarioOps->getIthPlayersSettings(color);
  51. }
  52. bool CGameInfoCallback::isAllowed(SpellID id) const
  53. {
  54. return gs->map->allowedSpells.count(id) != 0;
  55. }
  56. bool CGameInfoCallback::isAllowed(ArtifactID id) const
  57. {
  58. return gs->map->allowedArtifact.count(id) != 0;
  59. }
  60. bool CGameInfoCallback::isAllowed(SecondarySkill id) const
  61. {
  62. return gs->map->allowedAbilities.count(id) != 0;
  63. }
  64. std::optional<PlayerColor> CGameInfoCallback::getPlayerID() const
  65. {
  66. return std::nullopt;
  67. }
  68. const Player * CGameInfoCallback::getPlayer(PlayerColor color) const
  69. {
  70. return getPlayerState(color, false);
  71. }
  72. const PlayerState * CGameInfoCallback::getPlayerState(PlayerColor color, bool verbose) const
  73. {
  74. //function written from scratch since it's accessed A LOT by AI
  75. if(!color.isValidPlayer())
  76. {
  77. return nullptr;
  78. }
  79. auto player = gs->players.find(color);
  80. if (player != gs->players.end())
  81. {
  82. if (hasAccess(color))
  83. return &player->second;
  84. else
  85. {
  86. if (verbose)
  87. logGlobal->error("Cannot access player %d info!", color);
  88. return nullptr;
  89. }
  90. }
  91. else
  92. {
  93. if (verbose)
  94. logGlobal->error("Cannot find player %d info!", color);
  95. return nullptr;
  96. }
  97. }
  98. TurnTimerInfo CGameInfoCallback::getPlayerTurnTime(PlayerColor color) const
  99. {
  100. if(!color.isValidPlayer())
  101. {
  102. return TurnTimerInfo{};
  103. }
  104. auto player = gs->players.find(color);
  105. if(player != gs->players.end())
  106. {
  107. return player->second.turnTimer;
  108. }
  109. return TurnTimerInfo{};
  110. }
  111. /************************************************************************/
  112. /* */
  113. /************************************************************************/
  114. const CGObjectInstance* CGameInfoCallback::getObj(ObjectInstanceID objid, bool verbose) const
  115. {
  116. si32 oid = objid.num;
  117. if(oid < 0 || oid >= gs->map->objects.size())
  118. {
  119. if(verbose)
  120. logGlobal->error("Cannot get object with id %d", oid);
  121. return nullptr;
  122. }
  123. const CGObjectInstance *ret = gs->map->objects[oid];
  124. if(!ret)
  125. {
  126. if(verbose)
  127. logGlobal->error("Cannot get object with id %d. Object was removed", oid);
  128. return nullptr;
  129. }
  130. if(!isVisible(ret, getPlayerID()) && ret->tempOwner != getPlayerID())
  131. {
  132. if(verbose)
  133. logGlobal->error("Cannot get object with id %d. Object is not visible.", oid);
  134. return nullptr;
  135. }
  136. return ret;
  137. }
  138. const CGHeroInstance* CGameInfoCallback::getHero(ObjectInstanceID objid) const
  139. {
  140. const CGObjectInstance *obj = getObj(objid, false);
  141. if(obj)
  142. return dynamic_cast<const CGHeroInstance*>(obj);
  143. else
  144. return nullptr;
  145. }
  146. const CGTownInstance* CGameInfoCallback::getTown(ObjectInstanceID objid) const
  147. {
  148. const CGObjectInstance *obj = getObj(objid, false);
  149. if(obj)
  150. return dynamic_cast<const CGTownInstance*>(obj);
  151. else
  152. return nullptr;
  153. }
  154. const IMarket * CGameInfoCallback::getMarket(ObjectInstanceID objid) const
  155. {
  156. const CGObjectInstance * obj = getObj(objid, false);
  157. if(obj)
  158. return dynamic_cast<const IMarket*>(obj);
  159. else
  160. return nullptr;
  161. }
  162. void CGameInfoCallback::fillUpgradeInfo(const CArmedInstance *obj, SlotID stackPos, UpgradeInfo & out) const
  163. {
  164. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  165. ERROR_RET_IF(!canGetFullInfo(obj), "Cannot get info about not owned object!");
  166. ERROR_RET_IF(!obj->hasStackAtSlot(stackPos), "There is no such stack!");
  167. gs->fillUpgradeInfo(obj, stackPos, out);
  168. //return gs->fillUpgradeInfo(obj->getStack(stackPos));
  169. }
  170. const StartInfo * CGameInfoCallback::getStartInfo(bool beforeRandomization) const
  171. {
  172. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  173. if(beforeRandomization)
  174. return gs->initialOpts;
  175. else
  176. return gs->scenarioOps;
  177. }
  178. int32_t CGameInfoCallback::getSpellCost(const spells::Spell * sp, const CGHeroInstance * caster) const
  179. {
  180. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  181. ERROR_RET_VAL_IF(!canGetFullInfo(caster), "Cannot get info about caster!", -1);
  182. //if there is a battle
  183. auto casterBattle = gs->getBattle(caster->getOwner());
  184. if(casterBattle)
  185. return casterBattle->battleGetSpellCost(sp, caster);
  186. //if there is no battle
  187. return caster->getSpellCost(sp);
  188. }
  189. int64_t CGameInfoCallback::estimateSpellDamage(const CSpell * sp, const CGHeroInstance * hero) const
  190. {
  191. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  192. ERROR_RET_VAL_IF(hero && !canGetFullInfo(hero), "Cannot get info about caster!", -1);
  193. if(hero) //we see hero's spellbook
  194. return sp->calculateDamage(hero);
  195. else
  196. return 0; //mage guild
  197. }
  198. void CGameInfoCallback::getThievesGuildInfo(SThievesGuildInfo & thi, const CGObjectInstance * obj)
  199. {
  200. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  201. ERROR_RET_IF(!obj, "No guild object!");
  202. ERROR_RET_IF(obj->ID == Obj::TOWN && !canGetFullInfo(obj), "Cannot get info about town guild object!");
  203. //TODO: advmap object -> check if they're visited by our hero
  204. if(obj->ID == Obj::TOWN || obj->ID == Obj::TAVERN)
  205. {
  206. int taverns = gs->players[*getPlayerID()].valOfBonuses(BonusType::THIEVES_GUILD_ACCESS);
  207. gs->obtainPlayersStats(thi, taverns);
  208. }
  209. else if(obj->ID == Obj::DEN_OF_THIEVES)
  210. {
  211. gs->obtainPlayersStats(thi, 20);
  212. }
  213. }
  214. int CGameInfoCallback::howManyTowns(PlayerColor Player) const
  215. {
  216. ERROR_RET_VAL_IF(!hasAccess(Player), "Access forbidden!", -1);
  217. return static_cast<int>(gs->players[Player].getTowns().size());
  218. }
  219. bool CGameInfoCallback::getTownInfo(const CGObjectInstance * town, InfoAboutTown & dest, const CGObjectInstance * selectedObject) const
  220. {
  221. ERROR_RET_VAL_IF(!isVisible(town, getPlayerID()), "Town is not visible!", false); //it's not a town or it's not visible for layer
  222. bool detailed = hasAccess(town->tempOwner);
  223. if(town->ID == Obj::TOWN)
  224. {
  225. if(!detailed && nullptr != selectedObject)
  226. {
  227. const auto * selectedHero = dynamic_cast<const CGHeroInstance *>(selectedObject);
  228. if(nullptr != selectedHero)
  229. detailed = selectedHero->hasVisions(town, BonusCustomSubtype::visionsTowns);
  230. }
  231. dest.initFromTown(dynamic_cast<const CGTownInstance *>(town), detailed);
  232. }
  233. else if(town->ID == Obj::GARRISON || town->ID == Obj::GARRISON2)
  234. dest.initFromArmy(dynamic_cast<const CArmedInstance *>(town), detailed);
  235. else
  236. return false;
  237. return true;
  238. }
  239. const IGameSettings & CGameInfoCallback::getSettings() const
  240. {
  241. return gs->getSettings();
  242. }
  243. int3 CGameInfoCallback::guardingCreaturePosition (int3 pos) const //FIXME: redundant?
  244. {
  245. ERROR_RET_VAL_IF(!isVisible(pos), "Tile is not visible!", int3(-1,-1,-1));
  246. return gs->guardingCreaturePosition(pos);
  247. }
  248. std::vector<const CGObjectInstance*> CGameInfoCallback::getGuardingCreatures (int3 pos) const
  249. {
  250. ERROR_RET_VAL_IF(!isVisible(pos), "Tile is not visible!", std::vector<const CGObjectInstance*>());
  251. std::vector<const CGObjectInstance*> ret;
  252. for(auto * cr : gs->guardingCreatures(pos))
  253. {
  254. ret.push_back(cr);
  255. }
  256. return ret;
  257. }
  258. bool CGameInfoCallback::isTileGuardedUnchecked(int3 tile) const
  259. {
  260. return !gs->guardingCreatures(tile).empty();
  261. }
  262. bool CGameInfoCallback::getHeroInfo(const CGObjectInstance * hero, InfoAboutHero & dest, const CGObjectInstance * selectedObject) const
  263. {
  264. const auto * h = dynamic_cast<const CGHeroInstance *>(hero);
  265. ERROR_RET_VAL_IF(!h, "That's not a hero!", false);
  266. InfoAboutHero::EInfoLevel infoLevel = InfoAboutHero::EInfoLevel::BASIC;
  267. if(hasAccess(h->tempOwner))
  268. infoLevel = InfoAboutHero::EInfoLevel::DETAILED;
  269. if (infoLevel == InfoAboutHero::EInfoLevel::BASIC)
  270. {
  271. auto ourBattle = gs->getBattle(*getPlayerID());
  272. if(ourBattle && ourBattle->playerHasAccessToHeroInfo(*getPlayerID(), h)) //if it's battle we can get enemy hero full data
  273. infoLevel = InfoAboutHero::EInfoLevel::INBATTLE;
  274. else
  275. ERROR_RET_VAL_IF(!isVisible(h->visitablePos()), "That hero is not visible!", false);
  276. }
  277. if( (infoLevel == InfoAboutHero::EInfoLevel::BASIC) && nullptr != selectedObject)
  278. {
  279. const auto * selectedHero = dynamic_cast<const CGHeroInstance *>(selectedObject);
  280. if(nullptr != selectedHero)
  281. if(selectedHero->hasVisions(hero, BonusCustomSubtype::visionsHeroes))
  282. infoLevel = InfoAboutHero::EInfoLevel::DETAILED;
  283. }
  284. dest.initFromHero(h, infoLevel);
  285. //DISGUISED bonus implementation
  286. if(getPlayerRelations(*getPlayerID(), hero->tempOwner) == PlayerRelations::ENEMIES)
  287. {
  288. //todo: bonus cashing
  289. int disguiseLevel = h->valOfBonuses(BonusType::DISGUISED);
  290. auto doBasicDisguise = [](InfoAboutHero & info)
  291. {
  292. int maxAIValue = 0;
  293. const CCreature * mostStrong = nullptr;
  294. for(auto & elem : info.army)
  295. {
  296. if(static_cast<int>(elem.second.getCreature()->getAIValue()) > maxAIValue)
  297. {
  298. maxAIValue = elem.second.getCreature()->getAIValue();
  299. mostStrong = elem.second.getCreature();
  300. }
  301. }
  302. if(nullptr == mostStrong)//just in case
  303. logGlobal->error("CGameInfoCallback::getHeroInfo: Unable to select most strong stack");
  304. else
  305. for(auto & elem : info.army)
  306. {
  307. elem.second.setType(mostStrong);
  308. }
  309. };
  310. auto doAdvancedDisguise = [&doBasicDisguise](InfoAboutHero & info)
  311. {
  312. doBasicDisguise(info);
  313. for(auto & elem : info.army)
  314. elem.second.count = 0;
  315. };
  316. auto doExpertDisguise = [this,h](InfoAboutHero & info)
  317. {
  318. for(auto & elem : info.army)
  319. elem.second.count = 0;
  320. const auto factionIndex = getStartInfo(false)->playerInfos.at(h->tempOwner).castle;
  321. int maxAIValue = 0;
  322. const CCreature * mostStrong = nullptr;
  323. for(const auto & creature : VLC->creh->objects)
  324. {
  325. if(creature->getFactionID() == factionIndex && static_cast<int>(creature->getAIValue()) > maxAIValue)
  326. {
  327. maxAIValue = creature->getAIValue();
  328. mostStrong = creature.get();
  329. }
  330. }
  331. if(nullptr != mostStrong) //possible, faction may have no creatures at all
  332. for(auto & elem : info.army)
  333. elem.second.setType(mostStrong);
  334. };
  335. switch (disguiseLevel)
  336. {
  337. case 0:
  338. //no bonus at all - do nothing
  339. break;
  340. case 1:
  341. doBasicDisguise(dest);
  342. break;
  343. case 2:
  344. doAdvancedDisguise(dest);
  345. break;
  346. case 3:
  347. doExpertDisguise(dest);
  348. break;
  349. default:
  350. //invalid value
  351. logGlobal->error("CGameInfoCallback::getHeroInfo: Invalid DISGUISED bonus value %d", disguiseLevel);
  352. break;
  353. }
  354. }
  355. return true;
  356. }
  357. int CGameInfoCallback::getDate(Date mode) const
  358. {
  359. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  360. return gs->getDate(mode);
  361. }
  362. bool CGameInfoCallback::isVisible(int3 pos, const std::optional<PlayerColor> & Player) const
  363. {
  364. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  365. return gs->isVisible(pos, Player);
  366. }
  367. bool CGameInfoCallback::isVisible(int3 pos) const
  368. {
  369. return isVisible(pos, getPlayerID());
  370. }
  371. bool CGameInfoCallback::isVisible(const CGObjectInstance * obj, const std::optional<PlayerColor> & Player) const
  372. {
  373. return gs->isVisible(obj, Player);
  374. }
  375. bool CGameInfoCallback::isVisible(const CGObjectInstance *obj) const
  376. {
  377. return isVisible(obj, getPlayerID());
  378. }
  379. // const CCreatureSet* CInfoCallback::getGarrison(const CGObjectInstance *obj) const
  380. // {
  381. // //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  382. // if()
  383. // const CArmedInstance *armi = dynamic_cast<const CArmedInstance*>(obj);
  384. // if(!armi)
  385. // return nullptr;
  386. // else
  387. // return armi;
  388. // }
  389. std::vector <const CGObjectInstance *> CGameInfoCallback::getBlockingObjs( int3 pos ) const
  390. {
  391. std::vector<const CGObjectInstance *> ret;
  392. const TerrainTile *t = getTile(pos);
  393. ERROR_RET_VAL_IF(!t, "Not a valid tile requested!", ret);
  394. for(const CGObjectInstance * obj : t->blockingObjects)
  395. ret.push_back(obj);
  396. return ret;
  397. }
  398. std::vector <const CGObjectInstance *> CGameInfoCallback::getVisitableObjs(int3 pos, bool verbose) const
  399. {
  400. std::vector<const CGObjectInstance *> ret;
  401. const TerrainTile *t = getTile(pos, verbose);
  402. ERROR_VERBOSE_OR_NOT_RET_VAL_IF(!t, verbose, pos.toString() + " is not visible!", ret);
  403. for(const CGObjectInstance * obj : t->visitableObjects)
  404. {
  405. if(getPlayerID() || obj->ID != Obj::EVENT) //hide events from players
  406. ret.push_back(obj);
  407. }
  408. return ret;
  409. }
  410. std::vector<ConstTransitivePtr<CGObjectInstance>> CGameInfoCallback::getAllVisitableObjs() const
  411. {
  412. std::vector<ConstTransitivePtr<CGObjectInstance>> ret;
  413. for(auto & obj : gs->map->objects)
  414. if(obj && obj->isVisitable() && obj->ID != Obj::EVENT && isVisible(obj))
  415. ret.push_back(obj);
  416. return ret;
  417. }
  418. const CGObjectInstance * CGameInfoCallback::getTopObj (int3 pos) const
  419. {
  420. return vstd::backOrNull(getVisitableObjs(pos));
  421. }
  422. std::vector <const CGObjectInstance *> CGameInfoCallback::getFlaggableObjects(int3 pos) const
  423. {
  424. std::vector<const CGObjectInstance *> ret;
  425. const TerrainTile *t = getTile(pos);
  426. ERROR_RET_VAL_IF(!t, "Not a valid tile requested!", ret);
  427. for(const CGObjectInstance *obj : t->blockingObjects)
  428. if(obj->tempOwner != PlayerColor::UNFLAGGABLE)
  429. ret.push_back(obj);
  430. return ret;
  431. }
  432. int3 CGameInfoCallback::getMapSize() const
  433. {
  434. return int3(gs->map->width, gs->map->height, gs->map->twoLevel ? 2 : 1);
  435. }
  436. std::vector<const CGHeroInstance *> CGameInfoCallback::getAvailableHeroes(const CGObjectInstance * townOrTavern) const
  437. {
  438. ASSERT_IF_CALLED_WITH_PLAYER
  439. std::vector<const CGHeroInstance *> ret;
  440. //ERROR_RET_VAL_IF(!isOwnedOrVisited(townOrTavern), "Town or tavern must be owned or visited!", ret);
  441. //TODO: town needs to be owned, advmap tavern needs to be visited; to be reimplemented when visit tracking is done
  442. const CGTownInstance * town = getTown(townOrTavern->id);
  443. if(townOrTavern->ID == Obj::TAVERN || (town && town->hasBuilt(BuildingID::TAVERN)))
  444. return gs->heroesPool->getHeroesFor(*getPlayerID());
  445. return ret;
  446. }
  447. const TerrainTile * CGameInfoCallback::getTile(int3 tile, bool verbose) const
  448. {
  449. if(isVisible(tile))
  450. return &gs->map->getTile(tile);
  451. if(verbose)
  452. logGlobal->error("\r\n%s: %s\r\n", BOOST_CURRENT_FUNCTION, tile.toString() + " is not visible!");
  453. return nullptr;
  454. }
  455. const TerrainTile * CGameInfoCallback::getTileUnchecked(int3 tile) const
  456. {
  457. if (isInTheMap(tile))
  458. return &gs->map->getTile(tile);
  459. return nullptr;
  460. }
  461. EDiggingStatus CGameInfoCallback::getTileDigStatus(int3 tile, bool verbose) const
  462. {
  463. if(!isVisible(tile))
  464. return EDiggingStatus::UNKNOWN;
  465. for(const auto & object : gs->map->objects)
  466. {
  467. if(object && object->ID == Obj::HOLE && object->anchorPos() == tile)
  468. return EDiggingStatus::TILE_OCCUPIED;
  469. }
  470. return getTile(tile)->getDiggingStatus();
  471. }
  472. //TODO: typedef?
  473. std::shared_ptr<const boost::multi_array<TerrainTile*, 3>> CGameInfoCallback::getAllVisibleTiles() const
  474. {
  475. assert(getPlayerID().has_value());
  476. const auto * team = getPlayerTeam(getPlayerID().value());
  477. size_t width = gs->map->width;
  478. size_t height = gs->map->height;
  479. size_t levels = gs->map->levels();
  480. auto * ptr = new boost::multi_array<TerrainTile *, 3>(boost::extents[levels][width][height]);
  481. int3 tile;
  482. for(tile.z = 0; tile.z < levels; tile.z++)
  483. for(tile.x = 0; tile.x < width; tile.x++)
  484. for(tile.y = 0; tile.y < height; tile.y++)
  485. {
  486. if (team->fogOfWarMap[tile.z][tile.x][tile.y])
  487. (*ptr)[tile.z][tile.x][tile.y] = &gs->map->getTile(tile);
  488. else
  489. (*ptr)[tile.z][tile.x][tile.y] = nullptr;
  490. }
  491. return std::shared_ptr<const boost::multi_array<TerrainTile*, 3>>(ptr);
  492. }
  493. EBuildingState CGameInfoCallback::canBuildStructure( const CGTownInstance *t, BuildingID ID )
  494. {
  495. ERROR_RET_VAL_IF(!canGetFullInfo(t), "Town is not owned!", EBuildingState::TOWN_NOT_OWNED);
  496. if(!t->getTown()->buildings.count(ID))
  497. return EBuildingState::BUILDING_ERROR;
  498. const CBuilding * building = t->getTown()->buildings.at(ID);
  499. if(t->hasBuilt(ID)) //already built
  500. return EBuildingState::ALREADY_PRESENT;
  501. //can we build it?
  502. if(vstd::contains(t->forbiddenBuildings, ID))
  503. return EBuildingState::FORBIDDEN; //forbidden
  504. auto possiblyNotBuiltTest = [&](const BuildingID & id) -> bool
  505. {
  506. return ((id == BuildingID::CAPITOL) ? true : !t->hasBuilt(id));
  507. };
  508. std::function<bool(BuildingID id)> allowedTest = [&](const BuildingID & id) -> bool
  509. {
  510. return !vstd::contains(t->forbiddenBuildings, id);
  511. };
  512. if (!t->genBuildingRequirements(ID, true).satisfiable(allowedTest, possiblyNotBuiltTest))
  513. return EBuildingState::FORBIDDEN;
  514. if(ID == BuildingID::CAPITOL)
  515. {
  516. const PlayerState *ps = getPlayerState(t->tempOwner, false);
  517. if(ps)
  518. {
  519. for(const CGTownInstance *town : ps->getTowns())
  520. {
  521. if(town->hasBuilt(BuildingID::CAPITOL))
  522. {
  523. return EBuildingState::HAVE_CAPITAL; //no more than one capitol
  524. }
  525. }
  526. }
  527. }
  528. else if(ID == BuildingID::SHIPYARD)
  529. {
  530. const TerrainTile *tile = getTile(t->bestLocation(), false);
  531. if(!tile || !tile->isWater())
  532. return EBuildingState::NO_WATER; //lack of water
  533. }
  534. auto buildTest = [&](const BuildingID & id) -> bool
  535. {
  536. return t->hasBuilt(id);
  537. };
  538. if (!t->genBuildingRequirements(ID).test(buildTest))
  539. return EBuildingState::PREREQUIRES;
  540. if(t->built >= getSettings().getInteger(EGameSettings::TOWNS_BUILDINGS_PER_TURN_CAP))
  541. return EBuildingState::CANT_BUILD_TODAY; //building limit
  542. //checking resources
  543. if(!building->resources.canBeAfforded(getPlayerState(t->tempOwner)->resources))
  544. return EBuildingState::NO_RESOURCES; //lack of res
  545. return EBuildingState::ALLOWED;
  546. }
  547. const CMapHeader * CGameInfoCallback::getMapHeader() const
  548. {
  549. return gs->map;
  550. }
  551. bool CGameInfoCallback::hasAccess(std::optional<PlayerColor> playerId) const
  552. {
  553. return !getPlayerID() || getPlayerID()->isSpectator() || gs->getPlayerRelations(*playerId, *getPlayerID()) != PlayerRelations::ENEMIES;
  554. }
  555. EPlayerStatus CGameInfoCallback::getPlayerStatus(PlayerColor player, bool verbose) const
  556. {
  557. const PlayerState *ps = gs->getPlayerState(player, verbose);
  558. ERROR_VERBOSE_OR_NOT_RET_VAL_IF(!ps, verbose, "No such player!", EPlayerStatus::WRONG);
  559. return ps->status;
  560. }
  561. std::string CGameInfoCallback::getTavernRumor(const CGObjectInstance * townOrTavern) const
  562. {
  563. MetaString text;
  564. text.appendLocalString(EMetaText::GENERAL_TXT, 216);
  565. std::string extraText;
  566. if(gs->currentRumor.type == RumorState::TYPE_NONE)
  567. return text.toString();
  568. auto rumor = gs->currentRumor.last[gs->currentRumor.type];
  569. switch(gs->currentRumor.type)
  570. {
  571. case RumorState::TYPE_SPECIAL:
  572. text.replaceLocalString(EMetaText::GENERAL_TXT, rumor.first);
  573. if(rumor.first == RumorState::RUMOR_GRAIL)
  574. text.replaceTextID(TextIdentifier("core", "arraytxt", 158 + rumor.second).get());
  575. else
  576. text.replaceTextID(TextIdentifier("core", "plcolors", rumor.second).get());
  577. break;
  578. case RumorState::TYPE_MAP:
  579. text.replaceRawString(gs->map->rumors[rumor.first].text.toString());
  580. break;
  581. case RumorState::TYPE_RAND:
  582. text.replaceTextID(TextIdentifier("core", "randtvrn", rumor.first).get());
  583. break;
  584. }
  585. return text.toString();
  586. }
  587. PlayerRelations CGameInfoCallback::getPlayerRelations( PlayerColor color1, PlayerColor color2 ) const
  588. {
  589. return gs->getPlayerRelations(color1, color2);
  590. }
  591. bool CGameInfoCallback::canGetFullInfo(const CGObjectInstance *obj) const
  592. {
  593. return !obj || hasAccess(obj->tempOwner);
  594. }
  595. int CGameInfoCallback::getHeroCount( PlayerColor player, bool includeGarrisoned ) const
  596. {
  597. int ret = 0;
  598. const PlayerState *p = gs->getPlayerState(player);
  599. ERROR_RET_VAL_IF(!p, "No such player!", -1);
  600. if(includeGarrisoned)
  601. return static_cast<int>(p->getHeroes().size());
  602. else
  603. for(const auto & elem : p->getHeroes())
  604. if(!elem->inTownGarrison)
  605. ret++;
  606. return ret;
  607. }
  608. bool CGameInfoCallback::isOwnedOrVisited(const CGObjectInstance *obj) const
  609. {
  610. if(canGetFullInfo(obj))
  611. return true;
  612. const TerrainTile *t = getTile(obj->visitablePos()); //get entrance tile
  613. const CGObjectInstance *visitor = t->visitableObjects.back(); //visitong hero if present or the object itself at last
  614. return visitor->ID == Obj::HERO && canGetFullInfo(visitor); //owned or allied hero is a visitor
  615. }
  616. bool CGameInfoCallback::isPlayerMakingTurn(PlayerColor player) const
  617. {
  618. return gs->actingPlayers.count(player);
  619. }
  620. CGameInfoCallback::CGameInfoCallback():
  621. gs(nullptr)
  622. {
  623. }
  624. CGameInfoCallback::CGameInfoCallback(CGameState * GS):
  625. gs(GS)
  626. {
  627. }
  628. int CPlayerSpecificInfoCallback::howManyTowns() const
  629. {
  630. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  631. ERROR_RET_VAL_IF(!getPlayerID(), "Applicable only for player callbacks", -1);
  632. return CGameInfoCallback::howManyTowns(*getPlayerID());
  633. }
  634. std::vector < const CGTownInstance *> CPlayerSpecificInfoCallback::getTownsInfo(bool onlyOur) const
  635. {
  636. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  637. auto ret = std::vector < const CGTownInstance *>();
  638. for(const auto & i : gs->players)
  639. {
  640. for(const auto & town : i.second.getTowns())
  641. {
  642. if(i.first == getPlayerID() || (!onlyOur && isVisible(town, getPlayerID())))
  643. {
  644. ret.push_back(town);
  645. }
  646. }
  647. } // for ( std::map<int, PlayerState>::iterator i=gs->players.begin() ; i!=gs->players.end();i++)
  648. return ret;
  649. }
  650. std::vector < const CGHeroInstance *> CPlayerSpecificInfoCallback::getHeroesInfo(bool onlyOur) const
  651. {
  652. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  653. std::vector < const CGHeroInstance *> ret;
  654. for(auto hero : gs->map->heroesOnMap)
  655. {
  656. // !player || // - why would we even get access to hero not owned by any player?
  657. if((hero->tempOwner == *getPlayerID()) ||
  658. (isVisible(hero->visitablePos(), getPlayerID()) && !onlyOur) )
  659. {
  660. ret.push_back(hero);
  661. }
  662. }
  663. return ret;
  664. }
  665. int CPlayerSpecificInfoCallback::getHeroSerial(const CGHeroInstance * hero, bool includeGarrisoned) const
  666. {
  667. if (hero->inTownGarrison && !includeGarrisoned)
  668. return -1;
  669. size_t index = 0;
  670. const auto & heroes = gs->players[*getPlayerID()].getHeroes();
  671. for (auto & possibleHero : heroes)
  672. {
  673. if (includeGarrisoned || !(possibleHero)->inTownGarrison)
  674. index++;
  675. if (possibleHero == hero)
  676. return static_cast<int>(index);
  677. }
  678. return -1;
  679. }
  680. int3 CPlayerSpecificInfoCallback::getGrailPos( double *outKnownRatio )
  681. {
  682. if (!getPlayerID() || gs->map->obeliskCount == 0)
  683. {
  684. *outKnownRatio = 0.0;
  685. }
  686. else
  687. {
  688. TeamID t = gs->getPlayerTeam(*getPlayerID())->id;
  689. double visited = 0.0;
  690. if(gs->map->obelisksVisited.count(t))
  691. visited = static_cast<double>(gs->map->obelisksVisited[t]);
  692. *outKnownRatio = visited / gs->map->obeliskCount;
  693. }
  694. return gs->map->grailPos;
  695. }
  696. std::vector < const CGObjectInstance * > CPlayerSpecificInfoCallback::getMyObjects() const
  697. {
  698. return gs->getPlayerState(*getPlayerID())->getOwnedObjects();
  699. }
  700. std::vector <QuestInfo> CPlayerSpecificInfoCallback::getMyQuests() const
  701. {
  702. return gs->getPlayerState(*getPlayerID())->quests;
  703. }
  704. int CPlayerSpecificInfoCallback::howManyHeroes(bool includeGarrisoned) const
  705. {
  706. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  707. ERROR_RET_VAL_IF(!getPlayerID(), "Applicable only for player callbacks", -1);
  708. return getHeroCount(*getPlayerID(), includeGarrisoned);
  709. }
  710. const CGHeroInstance* CPlayerSpecificInfoCallback::getHeroBySerial(int serialId, bool includeGarrisoned) const
  711. {
  712. ASSERT_IF_CALLED_WITH_PLAYER
  713. const PlayerState *p = getPlayerState(*getPlayerID());
  714. ERROR_RET_VAL_IF(!p, "No player info", nullptr);
  715. if (!includeGarrisoned)
  716. {
  717. for(ui32 i = 0; i < p->getHeroes().size() && static_cast<int>(i) <= serialId; i++)
  718. if(p->getHeroes()[i]->inTownGarrison)
  719. serialId++;
  720. }
  721. ERROR_RET_VAL_IF(serialId < 0 || serialId >= p->getHeroes().size(), "No player info", nullptr);
  722. return p->getHeroes()[serialId];
  723. }
  724. const CGTownInstance* CPlayerSpecificInfoCallback::getTownBySerial(int serialId) const
  725. {
  726. ASSERT_IF_CALLED_WITH_PLAYER
  727. const PlayerState *p = getPlayerState(*getPlayerID());
  728. ERROR_RET_VAL_IF(!p, "No player info", nullptr);
  729. ERROR_RET_VAL_IF(serialId < 0 || serialId >= p->getTowns().size(), "No player info", nullptr);
  730. return p->getTowns()[serialId];
  731. }
  732. int CPlayerSpecificInfoCallback::getResourceAmount(GameResID type) const
  733. {
  734. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  735. ERROR_RET_VAL_IF(!getPlayerID(), "Applicable only for player callbacks", -1);
  736. return getResource(*getPlayerID(), type);
  737. }
  738. TResources CPlayerSpecificInfoCallback::getResourceAmount() const
  739. {
  740. //boost::shared_lock<boost::shared_mutex> lock(*gs->mx);
  741. ERROR_RET_VAL_IF(!getPlayerID(), "Applicable only for player callbacks", TResources());
  742. return gs->players[*getPlayerID()].resources;
  743. }
  744. const TeamState * CGameInfoCallback::getTeam( TeamID teamID ) const
  745. {
  746. //rewritten by hand, AI calls this function a lot
  747. auto team = gs->teams.find(teamID);
  748. if (team != gs->teams.end())
  749. {
  750. const TeamState *ret = &team->second;
  751. if(!getPlayerID().has_value()) //neutral (or invalid) player
  752. return ret;
  753. else
  754. {
  755. if (vstd::contains(ret->players, *getPlayerID())) //specific player
  756. return ret;
  757. else
  758. {
  759. logGlobal->error("Illegal attempt to access team data!");
  760. return nullptr;
  761. }
  762. }
  763. }
  764. else
  765. {
  766. logGlobal->error("Cannot find info for team %d", teamID);
  767. return nullptr;
  768. }
  769. }
  770. const TeamState * CGameInfoCallback::getPlayerTeam( PlayerColor color ) const
  771. {
  772. auto player = gs->players.find(color);
  773. if (player != gs->players.end())
  774. {
  775. return getTeam (player->second.team);
  776. }
  777. else
  778. {
  779. return nullptr;
  780. }
  781. }
  782. const CGHeroInstance * CGameInfoCallback::getHeroWithSubid( int subid ) const
  783. {
  784. if(subid<0)
  785. return nullptr;
  786. if(subid>= gs->map->allHeroes.size())
  787. return nullptr;
  788. return gs->map->allHeroes.at(subid).get();
  789. }
  790. bool CGameInfoCallback::isInTheMap(const int3 &pos) const
  791. {
  792. return gs->map->isInTheMap(pos);
  793. }
  794. void CGameInfoCallback::getVisibleTilesInRange(std::unordered_set<int3> &tiles, int3 pos, int radious, int3::EDistanceFormula distanceFormula) const
  795. {
  796. gs->getTilesInRange(tiles, pos, radious, ETileVisibility::REVEALED, *getPlayerID(), distanceFormula);
  797. }
  798. void CGameInfoCallback::calculatePaths(const std::shared_ptr<PathfinderConfig> & config)
  799. {
  800. gs->calculatePaths(config);
  801. }
  802. void CGameInfoCallback::calculatePaths( const CGHeroInstance *hero, CPathsInfo &out)
  803. {
  804. gs->calculatePaths(hero, out);
  805. }
  806. const CArtifactInstance * CGameInfoCallback::getArtInstance( ArtifactInstanceID aid ) const
  807. {
  808. return gs->map->artInstances.at(aid.num);
  809. }
  810. const CGObjectInstance * CGameInfoCallback::getObjInstance( ObjectInstanceID oid ) const
  811. {
  812. return gs->map->objects.at(oid.num);
  813. }
  814. const CArtifactSet * CGameInfoCallback::getArtSet(const ArtifactLocation & loc) const
  815. {
  816. return gs->getArtSet(loc);
  817. }
  818. std::vector<ObjectInstanceID> CGameInfoCallback::getVisibleTeleportObjects(std::vector<ObjectInstanceID> ids, PlayerColor player) const
  819. {
  820. vstd::erase_if(ids, [&](const ObjectInstanceID & id) -> bool
  821. {
  822. const auto * obj = getObj(id, false);
  823. return player != PlayerColor::UNFLAGGABLE && (!obj || !isVisible(obj->visitablePos(), player));
  824. });
  825. return ids;
  826. }
  827. std::vector<ObjectInstanceID> CGameInfoCallback::getTeleportChannelEntrances(TeleportChannelID id, PlayerColor player) const
  828. {
  829. return getVisibleTeleportObjects(gs->map->teleportChannels[id]->entrances, player);
  830. }
  831. std::vector<ObjectInstanceID> CGameInfoCallback::getTeleportChannelExits(TeleportChannelID id, PlayerColor player) const
  832. {
  833. return getVisibleTeleportObjects(gs->map->teleportChannels[id]->exits, player);
  834. }
  835. ETeleportChannelType CGameInfoCallback::getTeleportChannelType(TeleportChannelID id, PlayerColor player) const
  836. {
  837. std::vector<ObjectInstanceID> entrances = getTeleportChannelEntrances(id, player);
  838. std::vector<ObjectInstanceID> exits = getTeleportChannelExits(id, player);
  839. if((entrances.empty() || exits.empty()) // impassable if exits or entrances list are empty
  840. || (entrances.size() == 1 && entrances == exits)) // impassable if only entrance and only exit is same object. e.g bidirectional monolith
  841. {
  842. return ETeleportChannelType::IMPASSABLE;
  843. }
  844. auto intersection = vstd::intersection(entrances, exits);
  845. if(intersection.size() == entrances.size() && intersection.size() == exits.size())
  846. return ETeleportChannelType::BIDIRECTIONAL;
  847. else if(intersection.empty())
  848. return ETeleportChannelType::UNIDIRECTIONAL;
  849. else
  850. return ETeleportChannelType::MIXED;
  851. }
  852. bool CGameInfoCallback::isTeleportChannelImpassable(TeleportChannelID id, PlayerColor player) const
  853. {
  854. return ETeleportChannelType::IMPASSABLE == getTeleportChannelType(id, player);
  855. }
  856. bool CGameInfoCallback::isTeleportChannelBidirectional(TeleportChannelID id, PlayerColor player) const
  857. {
  858. return ETeleportChannelType::BIDIRECTIONAL == getTeleportChannelType(id, player);
  859. }
  860. bool CGameInfoCallback::isTeleportChannelUnidirectional(TeleportChannelID id, PlayerColor player) const
  861. {
  862. return ETeleportChannelType::UNIDIRECTIONAL == getTeleportChannelType(id, player);
  863. }
  864. bool CGameInfoCallback::isTeleportEntrancePassable(const CGTeleport * obj, PlayerColor player) const
  865. {
  866. return obj && obj->isEntrance() && !isTeleportChannelImpassable(obj->channel, player);
  867. }
  868. VCMI_LIB_NAMESPACE_END