MapRendererContext.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512
  1. /*
  2. * MapRendererContextState.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 "MapRendererContext.h"
  12. #include "MapRendererContextState.h"
  13. #include "mapHandler.h"
  14. #include "../../CCallback.h"
  15. #include "../CGameInfo.h"
  16. #include "../CPlayerInterface.h"
  17. #include "../PlayerLocalState.h"
  18. #include "../adventureMap/CAdventureMapInterface.h"
  19. #include "../../lib/CPathfinder.h"
  20. #include "../../lib/Point.h"
  21. #include "../../lib/mapObjects/CGHeroInstance.h"
  22. #include "../../lib/mapping/CMap.h"
  23. MapRendererBaseContext::MapRendererBaseContext(const MapRendererContextState & viewState)
  24. : viewState(viewState)
  25. {
  26. }
  27. uint32_t MapRendererBaseContext::getObjectRotation(ObjectInstanceID objectID) const
  28. {
  29. const CGObjectInstance * obj = getObject(objectID);
  30. if(obj->ID == Obj::HERO)
  31. {
  32. const auto * hero = dynamic_cast<const CGHeroInstance *>(obj);
  33. return hero->moveDir;
  34. }
  35. if(obj->ID == Obj::BOAT)
  36. {
  37. const auto * boat = dynamic_cast<const CGBoat *>(obj);
  38. if(boat->hero)
  39. return boat->hero->moveDir;
  40. return boat->direction;
  41. }
  42. return 0;
  43. }
  44. int3 MapRendererBaseContext::getMapSize() const
  45. {
  46. return LOCPLINT->cb->getMapSize();
  47. }
  48. bool MapRendererBaseContext::isInMap(const int3 & coordinates) const
  49. {
  50. return LOCPLINT->cb->isInTheMap(coordinates);
  51. }
  52. bool MapRendererBaseContext::isVisible(const int3 & coordinates) const
  53. {
  54. if(settingsSessionSpectate)
  55. return LOCPLINT->cb->isInTheMap(coordinates);
  56. else
  57. return LOCPLINT->cb->isVisible(coordinates);
  58. }
  59. bool MapRendererBaseContext::isActiveHero(const CGObjectInstance * obj) const
  60. {
  61. if(obj->ID == Obj::HERO)
  62. {
  63. assert(dynamic_cast<const CGHeroInstance *>(obj) != nullptr);
  64. if(adventureInt->getCurrentHero() != nullptr)
  65. {
  66. if(obj->id == adventureInt->getCurrentHero()->id)
  67. return true;
  68. }
  69. }
  70. return false;
  71. }
  72. bool MapRendererBaseContext::tileAnimated(const int3 & coordinates) const
  73. {
  74. return false;
  75. }
  76. const TerrainTile & MapRendererBaseContext::getMapTile(const int3 & coordinates) const
  77. {
  78. return CGI->mh->getMap()->getTile(coordinates);
  79. }
  80. const MapRendererBaseContext::MapObjectsList & MapRendererBaseContext::getObjects(const int3 & coordinates) const
  81. {
  82. assert(isInMap(coordinates));
  83. return viewState.objects[coordinates.z][coordinates.x][coordinates.y];
  84. }
  85. const CGObjectInstance * MapRendererBaseContext::getObject(ObjectInstanceID objectID) const
  86. {
  87. return CGI->mh->getMap()->objects.at(objectID.getNum());
  88. }
  89. const CGPath * MapRendererBaseContext::currentPath() const
  90. {
  91. return nullptr;
  92. }
  93. size_t MapRendererBaseContext::objectGroupIndex(ObjectInstanceID objectID) const
  94. {
  95. static const std::vector<size_t> idleGroups = {0, 13, 0, 1, 2, 3, 4, 15, 14};
  96. return idleGroups[getObjectRotation(objectID)];
  97. }
  98. Point MapRendererBaseContext::objectImageOffset(ObjectInstanceID objectID, const int3 & coordinates) const
  99. {
  100. const CGObjectInstance * object = getObject(objectID);
  101. int3 offsetTiles(object->getPosition() - coordinates);
  102. return Point(offsetTiles) * Point(32, 32);
  103. }
  104. double MapRendererBaseContext::objectTransparency(ObjectInstanceID objectID, const int3 & coordinates) const
  105. {
  106. const CGObjectInstance * object = getObject(objectID);
  107. if(object->ID == Obj::HERO)
  108. {
  109. const auto * hero = dynamic_cast<const CGHeroInstance *>(object);
  110. if(hero->inTownGarrison)
  111. return 0;
  112. if(hero->boat)
  113. return 0;
  114. }
  115. return 1;
  116. }
  117. size_t MapRendererBaseContext::objectImageIndex(ObjectInstanceID objectID, size_t groupSize) const
  118. {
  119. return 0;
  120. }
  121. size_t MapRendererBaseContext::terrainImageIndex(size_t groupSize) const
  122. {
  123. return 0;
  124. }
  125. size_t MapRendererBaseContext::overlayImageIndex(const int3 & coordinates) const
  126. {
  127. return std::numeric_limits<size_t>::max();
  128. }
  129. double MapRendererBaseContext::viewTransitionProgress() const
  130. {
  131. return 0;
  132. }
  133. bool MapRendererBaseContext::filterGrayscale() const
  134. {
  135. return false;
  136. }
  137. bool MapRendererBaseContext::showRoads() const
  138. {
  139. return true;
  140. }
  141. bool MapRendererBaseContext::showRivers() const
  142. {
  143. return true;
  144. }
  145. bool MapRendererBaseContext::showBorder() const
  146. {
  147. return false;
  148. }
  149. bool MapRendererBaseContext::showOverlay() const
  150. {
  151. return false;
  152. }
  153. bool MapRendererBaseContext::showGrid() const
  154. {
  155. return false;
  156. }
  157. bool MapRendererBaseContext::showVisitable() const
  158. {
  159. return false;
  160. }
  161. bool MapRendererBaseContext::showBlocked() const
  162. {
  163. return false;
  164. }
  165. MapRendererAdventureContext::MapRendererAdventureContext(const MapRendererContextState & viewState)
  166. : MapRendererBaseContext(viewState)
  167. {
  168. }
  169. const CGPath * MapRendererAdventureContext::currentPath() const
  170. {
  171. const auto * hero = adventureInt->getCurrentHero();
  172. if(!hero)
  173. return nullptr;
  174. if(!LOCPLINT->localState->hasPath(hero))
  175. return nullptr;
  176. return &LOCPLINT->localState->getPath(hero);
  177. }
  178. size_t MapRendererAdventureContext::objectImageIndex(ObjectInstanceID objectID, size_t groupSize) const
  179. {
  180. assert(groupSize > 0);
  181. if(!settingsAdventureObjectAnimation)
  182. return 0;
  183. if(groupSize == 0)
  184. return 0;
  185. // usign objectID for frameCounter to add pseudo-random element per-object.
  186. // Without it, animation of multiple visible objects of the same type will always be in sync
  187. size_t baseFrameTime = 180;
  188. size_t frameCounter = animationTime / baseFrameTime + objectID.getNum();
  189. size_t frameIndex = frameCounter % groupSize;
  190. return frameIndex;
  191. }
  192. size_t MapRendererAdventureContext::terrainImageIndex(size_t groupSize) const
  193. {
  194. if(!settingsAdventureTerrainAnimation)
  195. return 0;
  196. size_t baseFrameTime = 180;
  197. size_t frameCounter = animationTime / baseFrameTime;
  198. size_t frameIndex = frameCounter % groupSize;
  199. return frameIndex;
  200. }
  201. bool MapRendererAdventureContext::showBorder() const
  202. {
  203. return true;
  204. }
  205. bool MapRendererAdventureContext::showGrid() const
  206. {
  207. return settingShowGrid;
  208. }
  209. bool MapRendererAdventureContext::showVisitable() const
  210. {
  211. return settingShowVisitable;
  212. }
  213. bool MapRendererAdventureContext::showBlocked() const
  214. {
  215. return settingShowBlocked;
  216. }
  217. MapRendererAdventureTransitionContext::MapRendererAdventureTransitionContext(const MapRendererContextState & viewState)
  218. : MapRendererAdventureContext(viewState)
  219. {
  220. }
  221. double MapRendererAdventureTransitionContext::viewTransitionProgress() const
  222. {
  223. return progress;
  224. }
  225. MapRendererAdventureFadingContext::MapRendererAdventureFadingContext(const MapRendererContextState & viewState)
  226. : MapRendererAdventureContext(viewState)
  227. {
  228. }
  229. bool MapRendererAdventureFadingContext::tileAnimated(const int3 & coordinates) const
  230. {
  231. if(!isInMap(coordinates))
  232. return false;
  233. auto objects = getObjects(coordinates);
  234. if(vstd::contains(objects, target))
  235. return true;
  236. return false;
  237. }
  238. double MapRendererAdventureFadingContext::objectTransparency(ObjectInstanceID objectID, const int3 & coordinates) const
  239. {
  240. if(objectID == target)
  241. return progress;
  242. return MapRendererAdventureContext::objectTransparency(objectID, coordinates);
  243. }
  244. MapRendererAdventureMovingContext::MapRendererAdventureMovingContext(const MapRendererContextState & viewState)
  245. : MapRendererAdventureContext(viewState)
  246. {
  247. }
  248. size_t MapRendererAdventureMovingContext::objectGroupIndex(ObjectInstanceID objectID) const
  249. {
  250. if(target == objectID)
  251. {
  252. static const std::vector<size_t> moveGroups = {0, 10, 5, 6, 7, 8, 9, 12, 11};
  253. return moveGroups[getObjectRotation(objectID)];
  254. }
  255. return MapRendererAdventureContext::objectGroupIndex(objectID);
  256. }
  257. bool MapRendererAdventureMovingContext::tileAnimated(const int3 & coordinates) const
  258. {
  259. if(!isInMap(coordinates))
  260. return false;
  261. auto objects = getObjects(coordinates);
  262. if(vstd::contains(objects, target))
  263. return true;
  264. return false;
  265. }
  266. Point MapRendererAdventureMovingContext::objectImageOffset(ObjectInstanceID objectID, const int3 & coordinates) const
  267. {
  268. if(target == objectID)
  269. {
  270. int3 offsetTilesFrom = tileFrom - coordinates;
  271. int3 offsetTilesDest = tileDest - coordinates;
  272. Point offsetPixelsFrom = Point(offsetTilesFrom) * Point(32, 32);
  273. Point offsetPixelsDest = Point(offsetTilesDest) * Point(32, 32);
  274. Point result = vstd::lerp(offsetPixelsFrom, offsetPixelsDest, progress);
  275. return result;
  276. }
  277. return MapRendererAdventureContext::objectImageOffset(objectID, coordinates);
  278. }
  279. size_t MapRendererAdventureMovingContext::objectImageIndex(ObjectInstanceID objectID, size_t groupSize) const
  280. {
  281. if(target != objectID)
  282. return MapRendererAdventureContext::objectImageIndex(objectID, groupSize);
  283. int32_t baseFrameTime = 50;
  284. size_t frameCounter = animationTime / baseFrameTime;
  285. size_t frameIndex = frameCounter % groupSize;
  286. return frameIndex;
  287. }
  288. size_t MapRendererWorldViewContext::selectOverlayImageForObject(const ObjectPosInfo & object) const
  289. {
  290. size_t ownerIndex = PlayerColor::PLAYER_LIMIT.getNum() * static_cast<size_t>(EWorldViewIcon::ICONS_PER_PLAYER);
  291. if(object.owner.isValidPlayer())
  292. ownerIndex = object.owner.getNum() * static_cast<size_t>(EWorldViewIcon::ICONS_PER_PLAYER);
  293. switch(object.id)
  294. {
  295. case Obj::MONOLITH_ONE_WAY_ENTRANCE:
  296. case Obj::MONOLITH_ONE_WAY_EXIT:
  297. case Obj::MONOLITH_TWO_WAY:
  298. return ownerIndex + static_cast<size_t>(EWorldViewIcon::TELEPORT);
  299. case Obj::SUBTERRANEAN_GATE:
  300. return ownerIndex + static_cast<size_t>(EWorldViewIcon::GATE);
  301. case Obj::ARTIFACT:
  302. return ownerIndex + static_cast<size_t>(EWorldViewIcon::ARTIFACT);
  303. case Obj::TOWN:
  304. return ownerIndex + static_cast<size_t>(EWorldViewIcon::TOWN);
  305. case Obj::HERO:
  306. return ownerIndex + static_cast<size_t>(EWorldViewIcon::HERO);
  307. case Obj::MINE:
  308. return ownerIndex + static_cast<size_t>(EWorldViewIcon::MINE_WOOD) + object.subId;
  309. case Obj::RESOURCE:
  310. return ownerIndex + static_cast<size_t>(EWorldViewIcon::RES_WOOD) + object.subId;
  311. }
  312. return std::numeric_limits<size_t>::max();
  313. }
  314. MapRendererWorldViewContext::MapRendererWorldViewContext(const MapRendererContextState & viewState)
  315. : MapRendererBaseContext(viewState)
  316. {
  317. }
  318. bool MapRendererWorldViewContext::showOverlay() const
  319. {
  320. return true;
  321. }
  322. size_t MapRendererWorldViewContext::overlayImageIndex(const int3 & coordinates) const
  323. {
  324. if(!isVisible(coordinates))
  325. return std::numeric_limits<size_t>::max();
  326. for(const auto & objectID : getObjects(coordinates))
  327. {
  328. const auto * object = getObject(objectID);
  329. if(!object->visitableAt(coordinates.x, coordinates.y))
  330. continue;
  331. ObjectPosInfo info;
  332. info.pos = coordinates;
  333. info.id = object->ID;
  334. info.subId = object->subID;
  335. info.owner = object->tempOwner;
  336. size_t iconIndex = selectOverlayImageForObject(info);
  337. if(iconIndex != std::numeric_limits<size_t>::max())
  338. return iconIndex;
  339. }
  340. return std::numeric_limits<size_t>::max();
  341. }
  342. MapRendererSpellViewContext::MapRendererSpellViewContext(const MapRendererContextState & viewState)
  343. : MapRendererWorldViewContext(viewState)
  344. {
  345. }
  346. double MapRendererSpellViewContext::objectTransparency(ObjectInstanceID objectID, const int3 & coordinates) const
  347. {
  348. if(showAllTerrain)
  349. {
  350. if(getObject(objectID)->isVisitable() && !MapRendererWorldViewContext::isVisible(coordinates))
  351. return 0;
  352. }
  353. return MapRendererWorldViewContext::objectTransparency(objectID, coordinates);
  354. }
  355. bool MapRendererSpellViewContext::isVisible(const int3 & coordinates) const
  356. {
  357. if(showAllTerrain)
  358. return isInMap(coordinates);
  359. return MapRendererBaseContext::isVisible(coordinates);
  360. }
  361. size_t MapRendererSpellViewContext::overlayImageIndex(const int3 & coordinates) const
  362. {
  363. for(const auto & entry : additionalOverlayIcons)
  364. {
  365. if(entry.pos != coordinates)
  366. continue;
  367. size_t iconIndex = selectOverlayImageForObject(entry);
  368. if(iconIndex != std::numeric_limits<size_t>::max())
  369. return iconIndex;
  370. }
  371. return MapRendererWorldViewContext::overlayImageIndex(coordinates);
  372. }
  373. MapRendererPuzzleMapContext::MapRendererPuzzleMapContext(const MapRendererContextState & viewState)
  374. : MapRendererBaseContext(viewState)
  375. {
  376. }
  377. MapRendererPuzzleMapContext::~MapRendererPuzzleMapContext() = default;
  378. const CGPath * MapRendererPuzzleMapContext::currentPath() const
  379. {
  380. return grailPos.get();
  381. }
  382. double MapRendererPuzzleMapContext::objectTransparency(ObjectInstanceID objectID, const int3 & coordinates) const
  383. {
  384. const auto * object = getObject(objectID);
  385. if(!object)
  386. return 0;
  387. if(object->isVisitable())
  388. return 0;
  389. if(object->ID == Obj::HOLE)
  390. return 0;
  391. return MapRendererBaseContext::objectTransparency(objectID, coordinates);
  392. }
  393. bool MapRendererPuzzleMapContext::isVisible(const int3 & coordinates) const
  394. {
  395. return LOCPLINT->cb->isInTheMap(coordinates);
  396. }
  397. bool MapRendererPuzzleMapContext::filterGrayscale() const
  398. {
  399. return true;
  400. }
  401. bool MapRendererPuzzleMapContext::showRoads() const
  402. {
  403. return false;
  404. }
  405. bool MapRendererPuzzleMapContext::showRivers() const
  406. {
  407. return false;
  408. }