AdventureMapInterface.cpp 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936
  1. /*
  2. * AdventureMapInterface.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 "AdventureMapInterface.h"
  12. #include "AdventureOptions.h"
  13. #include "AdventureState.h"
  14. #include "CInGameConsole.h"
  15. #include "CMinimap.h"
  16. #include "CList.h"
  17. #include "CInfoBar.h"
  18. #include "MapAudioPlayer.h"
  19. #include "TurnTimerWidget.h"
  20. #include "AdventureMapWidget.h"
  21. #include "AdventureMapShortcuts.h"
  22. #include "../mapView/mapHandler.h"
  23. #include "../mapView/MapView.h"
  24. #include "../windows/InfoWindows.h"
  25. #include "../widgets/RadialMenu.h"
  26. #include "../CGameInfo.h"
  27. #include "../gui/CursorHandler.h"
  28. #include "../gui/CGuiHandler.h"
  29. #include "../gui/Shortcut.h"
  30. #include "../gui/WindowHandler.h"
  31. #include "../render/Canvas.h"
  32. #include "../render/IRenderHandler.h"
  33. #include "../CMT.h"
  34. #include "../PlayerLocalState.h"
  35. #include "../CPlayerInterface.h"
  36. #include "../../CCallback.h"
  37. #include "../../lib/GameSettings.h"
  38. #include "../../lib/StartInfo.h"
  39. #include "../../lib/CGeneralTextHandler.h"
  40. #include "../../lib/spells/CSpellHandler.h"
  41. #include "../../lib/mapObjects/CGHeroInstance.h"
  42. #include "../../lib/mapObjects/CGTownInstance.h"
  43. #include "../../lib/mapping/CMapDefines.h"
  44. #include "../../lib/pathfinder/CGPathNode.h"
  45. #include "../../lib/spells/ISpellMechanics.h"
  46. #include "../../lib/spells/Problem.h"
  47. std::shared_ptr<AdventureMapInterface> adventureInt;
  48. AdventureMapInterface::AdventureMapInterface():
  49. mapAudio(new MapAudioPlayer()),
  50. spellBeingCasted(nullptr),
  51. scrollingWasActive(false),
  52. scrollingWasBlocked(false),
  53. backgroundDimLevel(settings["adventure"]["backgroundDimLevel"].Integer())
  54. {
  55. OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE;
  56. pos.x = pos.y = 0;
  57. pos.w = GH.screenDimensions().x;
  58. pos.h = GH.screenDimensions().y;
  59. shortcuts = std::make_shared<AdventureMapShortcuts>(*this);
  60. widget = std::make_shared<AdventureMapWidget>(shortcuts);
  61. shortcuts->setState(EAdventureState::MAKING_TURN);
  62. widget->getMapView()->onViewMapActivated();
  63. if(LOCPLINT->cb->getStartInfo()->turnTimerInfo.turnTimer != 0)
  64. watches = std::make_shared<TurnTimerWidget>(Point(24, 24));
  65. addUsedEvents(KEYBOARD | TIME);
  66. }
  67. void AdventureMapInterface::onMapViewMoved(const Rect & visibleArea, int mapLevel)
  68. {
  69. shortcuts->onMapViewMoved(visibleArea, mapLevel);
  70. widget->getMinimap()->onMapViewMoved(visibleArea, mapLevel);
  71. widget->onMapViewMoved(visibleArea, mapLevel);
  72. }
  73. void AdventureMapInterface::onAudioResumed()
  74. {
  75. mapAudio->onAudioResumed();
  76. }
  77. void AdventureMapInterface::onAudioPaused()
  78. {
  79. mapAudio->onAudioPaused();
  80. }
  81. void AdventureMapInterface::onHeroMovementStarted(const CGHeroInstance * hero)
  82. {
  83. if (shortcuts->optionMapViewActive())
  84. {
  85. widget->getInfoBar()->popAll();
  86. widget->getInfoBar()->showSelection();
  87. }
  88. }
  89. void AdventureMapInterface::onHeroChanged(const CGHeroInstance *h)
  90. {
  91. widget->getHeroList()->updateElement(h);
  92. if (h && h == LOCPLINT->localState->getCurrentHero() && !widget->getInfoBar()->showingComponents())
  93. widget->getInfoBar()->showSelection();
  94. widget->updateActiveState();
  95. }
  96. void AdventureMapInterface::onTownChanged(const CGTownInstance * town)
  97. {
  98. widget->getTownList()->updateElement(town);
  99. if (town && town == LOCPLINT->localState->getCurrentTown() && !widget->getInfoBar()->showingComponents())
  100. widget->getInfoBar()->showSelection();
  101. }
  102. void AdventureMapInterface::showInfoBoxMessage(const std::vector<Component> & components, std::string message, int timer)
  103. {
  104. widget->getInfoBar()->pushComponents(components, message, timer);
  105. }
  106. void AdventureMapInterface::activate()
  107. {
  108. CIntObject::activate();
  109. adjustActiveness();
  110. screenBuf = screen;
  111. if(LOCPLINT)
  112. {
  113. LOCPLINT->cingconsole->activate();
  114. LOCPLINT->cingconsole->pos = this->pos;
  115. }
  116. GH.fakeMouseMove(); //to restore the cursor
  117. // workaround for an edge case:
  118. // if player unequips Angel Wings / Boots of Levitation of currently active hero
  119. // game will correctly invalidate paths but current route will not be updated since verifyPath() is not called for current hero
  120. if (LOCPLINT->makingTurn && LOCPLINT->localState->getCurrentHero())
  121. LOCPLINT->localState->verifyPath(LOCPLINT->localState->getCurrentHero());
  122. }
  123. void AdventureMapInterface::deactivate()
  124. {
  125. CIntObject::deactivate();
  126. CCS->curh->set(Cursor::Map::POINTER);
  127. if(LOCPLINT)
  128. LOCPLINT->cingconsole->deactivate();
  129. }
  130. void AdventureMapInterface::showAll(Canvas & to)
  131. {
  132. CIntObject::showAll(to);
  133. dim(to);
  134. LOCPLINT->cingconsole->show(to);
  135. }
  136. void AdventureMapInterface::show(Canvas & to)
  137. {
  138. CIntObject::show(to);
  139. dim(to);
  140. LOCPLINT->cingconsole->show(to);
  141. }
  142. void AdventureMapInterface::dim(Canvas & to)
  143. {
  144. auto const isBigWindow = [&](std::shared_ptr<CIntObject> window) { return window->pos.w >= 800 && window->pos.h >= 600; }; // OH3 fullscreen
  145. if(settings["adventure"]["hideBackground"].Bool())
  146. for (auto window : GH.windows().findWindows<CIntObject>())
  147. {
  148. if(!std::dynamic_pointer_cast<AdventureMapInterface>(window) && std::dynamic_pointer_cast<CIntObject>(window) && isBigWindow(window))
  149. {
  150. to.fillTexture(GH.renderHandler().loadImage(ImagePath::builtin("DiBoxBck")));
  151. return;
  152. }
  153. }
  154. for (auto window : GH.windows().findWindows<CIntObject>())
  155. {
  156. if (!std::dynamic_pointer_cast<AdventureMapInterface>(window) && !std::dynamic_pointer_cast<RadialMenu>(window) && !window->isPopupWindow() && (settings["adventure"]["backgroundDimSmallWindows"].Bool() || isBigWindow(window) || shortcuts->getState() == EAdventureState::HOTSEAT_WAIT))
  157. {
  158. Rect targetRect(0, 0, GH.screenDimensions().x, GH.screenDimensions().y);
  159. ColorRGBA colorToFill(0, 0, 0, std::clamp<int>(backgroundDimLevel, 0, 255));
  160. if(backgroundDimLevel > 0)
  161. to.drawColorBlended(targetRect, colorToFill);
  162. return;
  163. }
  164. }
  165. }
  166. void AdventureMapInterface::tick(uint32_t msPassed)
  167. {
  168. handleMapScrollingUpdate(msPassed);
  169. // we want animations to be active during enemy turn but map itself to be non-interactive
  170. // so call timer update directly on inactive element
  171. widget->getMapView()->tick(msPassed);
  172. }
  173. void AdventureMapInterface::handleMapScrollingUpdate(uint32_t timePassed)
  174. {
  175. /// Width of window border, in pixels, that triggers map scrolling
  176. static constexpr int32_t borderScrollWidth = 15;
  177. int32_t scrollSpeedPixels = settings["adventure"]["scrollSpeedPixels"].Float();
  178. int32_t scrollDistance = scrollSpeedPixels * timePassed / 1000;
  179. Point cursorPosition = GH.getCursorPosition();
  180. Point scrollDirection;
  181. if (cursorPosition.x < borderScrollWidth)
  182. scrollDirection.x = -1;
  183. if (cursorPosition.x > GH.screenDimensions().x - borderScrollWidth)
  184. scrollDirection.x = +1;
  185. if (cursorPosition.y < borderScrollWidth)
  186. scrollDirection.y = -1;
  187. if (cursorPosition.y > GH.screenDimensions().y - borderScrollWidth)
  188. scrollDirection.y = +1;
  189. Point scrollDelta = scrollDirection * scrollDistance;
  190. bool cursorInScrollArea = scrollDelta != Point(0,0);
  191. bool scrollingActive = cursorInScrollArea && shortcuts->optionMapScrollingActive() && !scrollingWasBlocked;
  192. bool scrollingBlocked = GH.isKeyboardCtrlDown() || !settings["adventure"]["borderScroll"].Bool();
  193. if (!scrollingWasActive && scrollingBlocked)
  194. {
  195. scrollingWasBlocked = true;
  196. return;
  197. }
  198. if (!cursorInScrollArea && scrollingWasBlocked)
  199. {
  200. scrollingWasBlocked = false;
  201. return;
  202. }
  203. if (scrollingActive)
  204. widget->getMapView()->onMapScrolled(scrollDelta);
  205. if (!scrollingActive && !scrollingWasActive)
  206. return;
  207. if(scrollDelta.x > 0)
  208. {
  209. if(scrollDelta.y < 0)
  210. CCS->curh->set(Cursor::Map::SCROLL_NORTHEAST);
  211. if(scrollDelta.y > 0)
  212. CCS->curh->set(Cursor::Map::SCROLL_SOUTHEAST);
  213. if(scrollDelta.y == 0)
  214. CCS->curh->set(Cursor::Map::SCROLL_EAST);
  215. }
  216. if(scrollDelta.x < 0)
  217. {
  218. if(scrollDelta.y < 0)
  219. CCS->curh->set(Cursor::Map::SCROLL_NORTHWEST);
  220. if(scrollDelta.y > 0)
  221. CCS->curh->set(Cursor::Map::SCROLL_SOUTHWEST);
  222. if(scrollDelta.y == 0)
  223. CCS->curh->set(Cursor::Map::SCROLL_WEST);
  224. }
  225. if (scrollDelta.x == 0)
  226. {
  227. if(scrollDelta.y < 0)
  228. CCS->curh->set(Cursor::Map::SCROLL_NORTH);
  229. if(scrollDelta.y > 0)
  230. CCS->curh->set(Cursor::Map::SCROLL_SOUTH);
  231. if(scrollDelta.y == 0)
  232. CCS->curh->set(Cursor::Map::POINTER);
  233. }
  234. scrollingWasActive = scrollingActive;
  235. }
  236. void AdventureMapInterface::centerOnTile(int3 on)
  237. {
  238. widget->getMapView()->onCenteredTile(on);
  239. }
  240. void AdventureMapInterface::centerOnObject(const CGObjectInstance * obj)
  241. {
  242. widget->getMapView()->onCenteredObject(obj);
  243. }
  244. void AdventureMapInterface::keyPressed(EShortcut key)
  245. {
  246. if (key == EShortcut::GLOBAL_CANCEL && spellBeingCasted)
  247. hotkeyAbortCastingMode();
  248. //fake mouse use to trigger onTileHovered()
  249. GH.fakeMouseMove();
  250. }
  251. void AdventureMapInterface::onSelectionChanged(const CArmedInstance *sel)
  252. {
  253. assert(sel);
  254. widget->getInfoBar()->popAll();
  255. mapAudio->onSelectionChanged(sel);
  256. bool centerView = !settings["session"]["autoSkip"].Bool();
  257. if (centerView)
  258. centerOnObject(sel);
  259. if(sel->ID==Obj::TOWN)
  260. {
  261. auto town = dynamic_cast<const CGTownInstance*>(sel);
  262. widget->getInfoBar()->showTownSelection(town);
  263. widget->getTownList()->updateWidget();
  264. widget->getTownList()->select(town);
  265. widget->getHeroList()->select(nullptr);
  266. onHeroChanged(nullptr);
  267. }
  268. else //hero selected
  269. {
  270. auto hero = dynamic_cast<const CGHeroInstance*>(sel);
  271. widget->getInfoBar()->showHeroSelection(hero);
  272. widget->getHeroList()->select(hero);
  273. widget->getTownList()->select(nullptr);
  274. LOCPLINT->localState->verifyPath(hero);
  275. onHeroChanged(hero);
  276. }
  277. widget->updateActiveState();
  278. widget->getHeroList()->redraw();
  279. widget->getTownList()->redraw();
  280. }
  281. void AdventureMapInterface::onTownOrderChanged()
  282. {
  283. widget->getTownList()->updateWidget();
  284. }
  285. void AdventureMapInterface::onHeroOrderChanged()
  286. {
  287. widget->getHeroList()->updateWidget();
  288. }
  289. void AdventureMapInterface::onMapTilesChanged(boost::optional<std::unordered_set<int3>> positions)
  290. {
  291. if (positions)
  292. widget->getMinimap()->updateTiles(*positions);
  293. else
  294. widget->getMinimap()->update();
  295. }
  296. void AdventureMapInterface::onHotseatWaitStarted(PlayerColor playerID)
  297. {
  298. backgroundDimLevel = 255;
  299. onCurrentPlayerChanged(playerID);
  300. setState(EAdventureState::HOTSEAT_WAIT);
  301. }
  302. void AdventureMapInterface::onEnemyTurnStarted(PlayerColor playerID, bool isHuman)
  303. {
  304. if(settings["session"]["spectate"].Bool())
  305. return;
  306. mapAudio->onEnemyTurnStarted();
  307. widget->getMinimap()->setAIRadar(!isHuman);
  308. widget->getInfoBar()->startEnemyTurn(playerID);
  309. setState(isHuman ? EAdventureState::OTHER_HUMAN_PLAYER_TURN : EAdventureState::AI_PLAYER_TURN);
  310. }
  311. void AdventureMapInterface::setState(EAdventureState state)
  312. {
  313. shortcuts->setState(state);
  314. adjustActiveness();
  315. widget->updateActiveState();
  316. }
  317. void AdventureMapInterface::adjustActiveness()
  318. {
  319. bool widgetMustBeActive = isActive() && shortcuts->optionSidePanelActive();
  320. bool mapViewMustBeActive = isActive() && (shortcuts->optionMapViewActive());
  321. widget->setInputEnabled(widgetMustBeActive);
  322. widget->getMapView()->setInputEnabled(mapViewMustBeActive);
  323. }
  324. void AdventureMapInterface::onCurrentPlayerChanged(PlayerColor playerID)
  325. {
  326. if (playerID == currentPlayerID)
  327. return;
  328. currentPlayerID = playerID;
  329. widget->setPlayer(playerID);
  330. }
  331. void AdventureMapInterface::onPlayerTurnStarted(PlayerColor playerID)
  332. {
  333. backgroundDimLevel = settings["adventure"]["backgroundDimLevel"].Integer();
  334. onCurrentPlayerChanged(playerID);
  335. setState(EAdventureState::MAKING_TURN);
  336. if(playerID == LOCPLINT->playerID || settings["session"]["spectate"].Bool())
  337. {
  338. widget->getMinimap()->setAIRadar(false);
  339. widget->getInfoBar()->showSelection();
  340. }
  341. widget->getHeroList()->updateWidget();
  342. widget->getTownList()->updateWidget();
  343. const CGHeroInstance * heroToSelect = nullptr;
  344. // find first non-sleeping hero
  345. for (auto hero : LOCPLINT->localState->getWanderingHeroes())
  346. {
  347. if (!LOCPLINT->localState->isHeroSleeping(hero))
  348. {
  349. heroToSelect = hero;
  350. break;
  351. }
  352. }
  353. //select first hero if available.
  354. if (heroToSelect != nullptr)
  355. {
  356. LOCPLINT->localState->setSelection(heroToSelect);
  357. }
  358. else if (LOCPLINT->localState->getOwnedTowns().size())
  359. {
  360. LOCPLINT->localState->setSelection(LOCPLINT->localState->getOwnedTown(0));
  361. }
  362. else
  363. {
  364. LOCPLINT->localState->setSelection(LOCPLINT->localState->getWanderingHero(0));
  365. }
  366. onSelectionChanged(LOCPLINT->localState->getCurrentArmy());
  367. //show new day animation and sound on infobar, except for 1st day of the game
  368. if (LOCPLINT->cb->getDate(Date::DAY) != 1)
  369. widget->getInfoBar()->showDate();
  370. onHeroChanged(nullptr);
  371. Canvas canvas = Canvas::createFromSurface(screen);
  372. showAll(canvas);
  373. mapAudio->onPlayerTurnStarted();
  374. if(settings["session"]["autoSkip"].Bool() && !GH.isKeyboardShiftDown())
  375. {
  376. if(auto iw = GH.windows().topWindow<CInfoWindow>())
  377. iw->close();
  378. GH.dispatchMainThread([this]()
  379. {
  380. hotkeyEndingTurn();
  381. });
  382. }
  383. }
  384. void AdventureMapInterface::hotkeyEndingTurn()
  385. {
  386. if(settings["session"]["spectate"].Bool())
  387. return;
  388. if(!settings["general"]["startTurnAutosave"].Bool())
  389. {
  390. LOCPLINT->performAutosave();
  391. }
  392. LOCPLINT->makingTurn = false;
  393. LOCPLINT->cb->endTurn();
  394. mapAudio->onPlayerTurnEnded();
  395. // Normally, game will receive PlayerStartsTurn call almost instantly with new player ID that will switch UI to waiting mode
  396. // However, when simturns are active it is possible for such call not to come because another player is still acting
  397. // So find first player other than ours that is acting at the moment and update UI as if he had started turn
  398. for (auto player = PlayerColor(0); player < PlayerColor::PLAYER_LIMIT; ++player)
  399. {
  400. if (player != LOCPLINT->playerID && LOCPLINT->cb->isPlayerMakingTurn(player))
  401. {
  402. onEnemyTurnStarted(player, LOCPLINT->cb->getStartInfo()->playerInfos.at(player).isControlledByHuman());
  403. break;
  404. }
  405. }
  406. }
  407. const CGObjectInstance* AdventureMapInterface::getActiveObject(const int3 &mapPos)
  408. {
  409. std::vector < const CGObjectInstance * > bobjs = LOCPLINT->cb->getBlockingObjs(mapPos); //blocking objects at tile
  410. if (bobjs.empty())
  411. return nullptr;
  412. return *boost::range::max_element(bobjs, &CMapHandler::compareObjectBlitOrder);
  413. }
  414. void AdventureMapInterface::onTileLeftClicked(const int3 &targetPosition)
  415. {
  416. if(!shortcuts->optionMapViewActive())
  417. return;
  418. const CGObjectInstance *topBlocking = LOCPLINT->cb->isVisible(targetPosition) ? getActiveObject(targetPosition) : nullptr;
  419. if(spellBeingCasted)
  420. {
  421. assert(shortcuts->optionSpellcasting());
  422. assert(spellBeingCasted->id == SpellID::SCUTTLE_BOAT || spellBeingCasted->id == SpellID::DIMENSION_DOOR);
  423. if(isValidAdventureSpellTarget(targetPosition))
  424. performSpellcasting(targetPosition);
  425. return;
  426. }
  427. if(!LOCPLINT->cb->isVisible(targetPosition))
  428. return;
  429. //check if we can select this object
  430. bool canSelect = topBlocking && topBlocking->ID == Obj::HERO && topBlocking->tempOwner == LOCPLINT->playerID;
  431. canSelect |= topBlocking && topBlocking->ID == Obj::TOWN && LOCPLINT->cb->getPlayerRelations(LOCPLINT->playerID, topBlocking->tempOwner) != PlayerRelations::ENEMIES;
  432. bool isHero = false;
  433. if(LOCPLINT->localState->getCurrentArmy()->ID != Obj::HERO) //hero is not selected (presumably town)
  434. {
  435. if(LOCPLINT->localState->getCurrentArmy() == topBlocking) //selected town clicked
  436. LOCPLINT->openTownWindow(static_cast<const CGTownInstance*>(topBlocking));
  437. else if(canSelect)
  438. LOCPLINT->localState->setSelection(static_cast<const CArmedInstance*>(topBlocking));
  439. }
  440. else if(const CGHeroInstance * currentHero = LOCPLINT->localState->getCurrentHero()) //hero is selected
  441. {
  442. isHero = true;
  443. const CGPathNode *pn = LOCPLINT->cb->getPathsInfo(currentHero)->getPathInfo(targetPosition);
  444. if(currentHero == topBlocking) //clicked selected hero
  445. {
  446. LOCPLINT->openHeroWindow(currentHero);
  447. return;
  448. }
  449. else if(canSelect && pn->turns == 255 ) //selectable object at inaccessible tile
  450. {
  451. LOCPLINT->localState->setSelection(static_cast<const CArmedInstance*>(topBlocking));
  452. return;
  453. }
  454. else //still here? we need to move hero if we clicked end of already selected path or calculate a new path otherwise
  455. {
  456. if(LOCPLINT->localState->hasPath(currentHero) &&
  457. LOCPLINT->localState->getPath(currentHero).endPos() == targetPosition)//we'll be moving
  458. {
  459. assert(!CGI->mh->hasOngoingAnimations());
  460. if(!CGI->mh->hasOngoingAnimations() && LOCPLINT->localState->getPath(currentHero).nextNode().turns == 0)
  461. LOCPLINT->moveHero(currentHero, LOCPLINT->localState->getPath(currentHero));
  462. return;
  463. }
  464. else
  465. {
  466. if(GH.isKeyboardShiftDown()) //normal click behaviour (as no hero selected)
  467. {
  468. if(canSelect)
  469. LOCPLINT->localState->setSelection(static_cast<const CArmedInstance*>(topBlocking));
  470. }
  471. else //remove old path and find a new one if we clicked on accessible tile
  472. {
  473. LOCPLINT->localState->setPath(currentHero, targetPosition);
  474. onHeroChanged(currentHero);
  475. }
  476. }
  477. }
  478. } //end of hero is selected "case"
  479. else
  480. {
  481. throw std::runtime_error("Nothing is selected...");
  482. }
  483. const auto shipyard = ourInaccessibleShipyard(topBlocking);
  484. if(isHero && shipyard != nullptr)
  485. {
  486. LOCPLINT->showShipyardDialogOrProblemPopup(shipyard);
  487. }
  488. }
  489. void AdventureMapInterface::onTileHovered(const int3 &targetPosition)
  490. {
  491. if(!shortcuts->optionMapViewActive())
  492. return;
  493. //may occur just at the start of game (fake move before full initialization)
  494. if(!LOCPLINT->localState->getCurrentArmy())
  495. return;
  496. bool isTargetPositionVisible = LOCPLINT->cb->isVisible(targetPosition);
  497. const CGObjectInstance *objAtTile = isTargetPositionVisible ? getActiveObject(targetPosition) : nullptr;
  498. if(spellBeingCasted)
  499. {
  500. switch(spellBeingCasted->id)
  501. {
  502. case SpellID::SCUTTLE_BOAT:
  503. if(isValidAdventureSpellTarget(targetPosition))
  504. CCS->curh->set(Cursor::Map::SCUTTLE_BOAT);
  505. else
  506. CCS->curh->set(Cursor::Map::POINTER);
  507. return;
  508. case SpellID::DIMENSION_DOOR:
  509. if(isValidAdventureSpellTarget(targetPosition))
  510. {
  511. if(VLC->settings()->getBoolean(EGameSettings::DIMENSION_DOOR_TRIGGERS_GUARDS) && LOCPLINT->cb->isTileGuardedUnchecked(targetPosition))
  512. CCS->curh->set(Cursor::Map::T1_ATTACK);
  513. else
  514. CCS->curh->set(Cursor::Map::TELEPORT);
  515. return;
  516. }
  517. else
  518. CCS->curh->set(Cursor::Map::POINTER);
  519. return;
  520. default:
  521. CCS->curh->set(Cursor::Map::POINTER);
  522. return;
  523. }
  524. }
  525. if(!isTargetPositionVisible)
  526. {
  527. CCS->curh->set(Cursor::Map::POINTER);
  528. return;
  529. }
  530. auto objRelations = PlayerRelations::ALLIES;
  531. if(objAtTile)
  532. {
  533. objRelations = LOCPLINT->cb->getPlayerRelations(LOCPLINT->playerID, objAtTile->tempOwner);
  534. std::string text = LOCPLINT->localState->getCurrentHero() ? objAtTile->getHoverText(LOCPLINT->localState->getCurrentHero()) : objAtTile->getHoverText(LOCPLINT->playerID);
  535. boost::replace_all(text,"\n"," ");
  536. if (GH.isKeyboardCmdDown())
  537. text.append(" (" + std::to_string(targetPosition.x) + ", " + std::to_string(targetPosition.y) + ")");
  538. GH.statusbar()->write(text);
  539. }
  540. else if(isTargetPositionVisible)
  541. {
  542. std::string tileTooltipText = CGI->mh->getTerrainDescr(targetPosition, false);
  543. if (GH.isKeyboardCmdDown())
  544. tileTooltipText.append(" (" + std::to_string(targetPosition.x) + ", " + std::to_string(targetPosition.y) + ")");
  545. GH.statusbar()->write(tileTooltipText);
  546. }
  547. if(LOCPLINT->localState->getCurrentArmy()->ID == Obj::TOWN || GH.isKeyboardShiftDown())
  548. {
  549. if(objAtTile)
  550. {
  551. if(objAtTile->ID == Obj::TOWN && objRelations != PlayerRelations::ENEMIES)
  552. CCS->curh->set(Cursor::Map::TOWN);
  553. else if(objAtTile->ID == Obj::HERO && objRelations == PlayerRelations::SAME_PLAYER)
  554. CCS->curh->set(Cursor::Map::HERO);
  555. else
  556. CCS->curh->set(Cursor::Map::POINTER);
  557. }
  558. else
  559. CCS->curh->set(Cursor::Map::POINTER);
  560. }
  561. else if(const CGHeroInstance * hero = LOCPLINT->localState->getCurrentHero())
  562. {
  563. std::array<Cursor::Map, 4> cursorMove = { Cursor::Map::T1_MOVE, Cursor::Map::T2_MOVE, Cursor::Map::T3_MOVE, Cursor::Map::T4_MOVE, };
  564. std::array<Cursor::Map, 4> cursorAttack = { Cursor::Map::T1_ATTACK, Cursor::Map::T2_ATTACK, Cursor::Map::T3_ATTACK, Cursor::Map::T4_ATTACK, };
  565. std::array<Cursor::Map, 4> cursorSail = { Cursor::Map::T1_SAIL, Cursor::Map::T2_SAIL, Cursor::Map::T3_SAIL, Cursor::Map::T4_SAIL, };
  566. std::array<Cursor::Map, 4> cursorDisembark = { Cursor::Map::T1_DISEMBARK, Cursor::Map::T2_DISEMBARK, Cursor::Map::T3_DISEMBARK, Cursor::Map::T4_DISEMBARK, };
  567. std::array<Cursor::Map, 4> cursorExchange = { Cursor::Map::T1_EXCHANGE, Cursor::Map::T2_EXCHANGE, Cursor::Map::T3_EXCHANGE, Cursor::Map::T4_EXCHANGE, };
  568. std::array<Cursor::Map, 4> cursorVisit = { Cursor::Map::T1_VISIT, Cursor::Map::T2_VISIT, Cursor::Map::T3_VISIT, Cursor::Map::T4_VISIT, };
  569. std::array<Cursor::Map, 4> cursorSailVisit = { Cursor::Map::T1_SAIL_VISIT, Cursor::Map::T2_SAIL_VISIT, Cursor::Map::T3_SAIL_VISIT, Cursor::Map::T4_SAIL_VISIT, };
  570. const CGPathNode * pathNode = LOCPLINT->cb->getPathsInfo(hero)->getPathInfo(targetPosition);
  571. assert(pathNode);
  572. if((GH.isKeyboardAltDown() || settings["gameTweaks"]["forceMovementInfo"].Bool()) && pathNode->reachable()) //overwrite status bar text with movement info
  573. {
  574. showMoveDetailsInStatusbar(*hero, *pathNode);
  575. }
  576. int turns = pathNode->turns;
  577. vstd::amin(turns, 3);
  578. switch(pathNode->action)
  579. {
  580. case EPathNodeAction::NORMAL:
  581. case EPathNodeAction::TELEPORT_NORMAL:
  582. if(pathNode->layer == EPathfindingLayer::LAND)
  583. CCS->curh->set(cursorMove[turns]);
  584. else
  585. CCS->curh->set(cursorSail[turns]);
  586. break;
  587. case EPathNodeAction::VISIT:
  588. case EPathNodeAction::BLOCKING_VISIT:
  589. case EPathNodeAction::TELEPORT_BLOCKING_VISIT:
  590. if(objAtTile && objAtTile->ID == Obj::HERO)
  591. {
  592. if(LOCPLINT->localState->getCurrentArmy() == objAtTile)
  593. CCS->curh->set(Cursor::Map::HERO);
  594. else
  595. CCS->curh->set(cursorExchange[turns]);
  596. }
  597. else if(pathNode->layer == EPathfindingLayer::LAND)
  598. CCS->curh->set(cursorVisit[turns]);
  599. else if (pathNode->layer == EPathfindingLayer::SAIL &&
  600. objAtTile &&
  601. objAtTile->isCoastVisitable() &&
  602. pathNode->theNodeBefore &&
  603. pathNode->theNodeBefore->layer == EPathfindingLayer::LAND )
  604. {
  605. // exception - when visiting shipwreck located on coast from land - show 'horse' cursor, not 'ship' cursor
  606. CCS->curh->set(cursorVisit[turns]);
  607. }
  608. else
  609. CCS->curh->set(cursorSailVisit[turns]);
  610. break;
  611. case EPathNodeAction::BATTLE:
  612. case EPathNodeAction::TELEPORT_BATTLE:
  613. CCS->curh->set(cursorAttack[turns]);
  614. break;
  615. case EPathNodeAction::EMBARK:
  616. CCS->curh->set(cursorSail[turns]);
  617. break;
  618. case EPathNodeAction::DISEMBARK:
  619. CCS->curh->set(cursorDisembark[turns]);
  620. break;
  621. default:
  622. if(objAtTile && objRelations != PlayerRelations::ENEMIES)
  623. {
  624. if(objAtTile->ID == Obj::TOWN)
  625. CCS->curh->set(Cursor::Map::TOWN);
  626. else if(objAtTile->ID == Obj::HERO && objRelations == PlayerRelations::SAME_PLAYER)
  627. CCS->curh->set(Cursor::Map::HERO);
  628. else
  629. CCS->curh->set(Cursor::Map::POINTER);
  630. }
  631. else
  632. CCS->curh->set(Cursor::Map::POINTER);
  633. break;
  634. }
  635. }
  636. if(ourInaccessibleShipyard(objAtTile))
  637. {
  638. CCS->curh->set(Cursor::Map::T1_SAIL);
  639. }
  640. }
  641. void AdventureMapInterface::showMoveDetailsInStatusbar(const CGHeroInstance & hero, const CGPathNode & pathNode)
  642. {
  643. const int maxMovementPointsAtStartOfLastTurn = pathNode.turns > 0 ? hero.movementPointsLimit(pathNode.layer == EPathfindingLayer::LAND) : hero.movementPointsRemaining();
  644. const int movementPointsLastTurnCost = maxMovementPointsAtStartOfLastTurn - pathNode.moveRemains;
  645. const int remainingPointsAfterMove = pathNode.turns == 0 ? pathNode.moveRemains : 0;
  646. std::string result = VLC->generaltexth->translate("vcmi.adventureMap", pathNode.turns > 0 ? "moveCostDetails" : "moveCostDetailsNoTurns");
  647. boost::replace_first(result, "%TURNS", std::to_string(pathNode.turns));
  648. boost::replace_first(result, "%POINTS", std::to_string(movementPointsLastTurnCost));
  649. boost::replace_first(result, "%REMAINING", std::to_string(remainingPointsAfterMove));
  650. GH.statusbar()->write(result);
  651. }
  652. void AdventureMapInterface::onTileRightClicked(const int3 &mapPos)
  653. {
  654. if(!shortcuts->optionMapViewActive())
  655. return;
  656. if(spellBeingCasted)
  657. {
  658. hotkeyAbortCastingMode();
  659. return;
  660. }
  661. if(!LOCPLINT->cb->isVisible(mapPos))
  662. {
  663. CRClickPopup::createAndPush(VLC->generaltexth->allTexts[61]); //Uncharted Territory
  664. return;
  665. }
  666. const CGObjectInstance * obj = getActiveObject(mapPos);
  667. if(!obj)
  668. {
  669. // Bare or undiscovered terrain
  670. const TerrainTile * tile = LOCPLINT->cb->getTile(mapPos);
  671. if(tile)
  672. {
  673. std::string hlp = CGI->mh->getTerrainDescr(mapPos, true);
  674. CRClickPopup::createAndPush(hlp);
  675. }
  676. return;
  677. }
  678. CRClickPopup::createAndPush(obj, GH.getCursorPosition(), ETextAlignment::CENTER);
  679. }
  680. void AdventureMapInterface::enterCastingMode(const CSpell * sp)
  681. {
  682. assert(sp->id == SpellID::SCUTTLE_BOAT || sp->id == SpellID::DIMENSION_DOOR);
  683. spellBeingCasted = sp;
  684. Settings config = settings.write["session"]["showSpellRange"];
  685. config->Bool() = true;
  686. setState(EAdventureState::CASTING_SPELL);
  687. }
  688. void AdventureMapInterface::exitCastingMode()
  689. {
  690. assert(spellBeingCasted);
  691. spellBeingCasted = nullptr;
  692. setState(EAdventureState::MAKING_TURN);
  693. Settings config = settings.write["session"]["showSpellRange"];
  694. config->Bool() = false;
  695. }
  696. void AdventureMapInterface::hotkeyAbortCastingMode()
  697. {
  698. exitCastingMode();
  699. LOCPLINT->showInfoDialog(CGI->generaltexth->allTexts[731]); //Spell cancelled
  700. }
  701. void AdventureMapInterface::performSpellcasting(const int3 & dest)
  702. {
  703. SpellID id = spellBeingCasted->id;
  704. exitCastingMode();
  705. LOCPLINT->cb->castSpell(LOCPLINT->localState->getCurrentHero(), id, dest);
  706. }
  707. Rect AdventureMapInterface::terrainAreaPixels() const
  708. {
  709. return widget->getMapView()->pos;
  710. }
  711. const IShipyard * AdventureMapInterface::ourInaccessibleShipyard(const CGObjectInstance *obj) const
  712. {
  713. const auto *ret = dynamic_cast<const IShipyard *>(obj);
  714. if(!ret ||
  715. obj->tempOwner != currentPlayerID ||
  716. (CCS->curh->get<Cursor::Map>() != Cursor::Map::T1_SAIL && CCS->curh->get<Cursor::Map>() != Cursor::Map::POINTER))
  717. return nullptr;
  718. return ret;
  719. }
  720. void AdventureMapInterface::hotkeyExitWorldView()
  721. {
  722. setState(EAdventureState::MAKING_TURN);
  723. widget->getMapView()->onViewMapActivated();
  724. }
  725. void AdventureMapInterface::openWorldView(int tileSize)
  726. {
  727. setState(EAdventureState::WORLD_VIEW);
  728. widget->getMapView()->onViewWorldActivated(tileSize);
  729. }
  730. void AdventureMapInterface::openWorldView()
  731. {
  732. openWorldView(11);
  733. }
  734. void AdventureMapInterface::openWorldView(const std::vector<ObjectPosInfo>& objectPositions, bool showTerrain)
  735. {
  736. openWorldView(11);
  737. widget->getMapView()->onViewSpellActivated(11, objectPositions, showTerrain);
  738. }
  739. void AdventureMapInterface::hotkeyNextTown()
  740. {
  741. widget->getTownList()->selectNext();
  742. }
  743. void AdventureMapInterface::hotkeySwitchMapLevel()
  744. {
  745. widget->getMapView()->onMapLevelSwitched();
  746. }
  747. void AdventureMapInterface::hotkeyZoom(int delta, bool useDeadZone)
  748. {
  749. widget->getMapView()->onMapZoomLevelChanged(delta, useDeadZone);
  750. }
  751. void AdventureMapInterface::onScreenResize()
  752. {
  753. OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE;
  754. // remember our activation state and reactive after reconstruction
  755. // since othervice activate() calls for created elements will bypass virtual dispatch
  756. // and will call directly CIntObject::activate() instead of dispatching virtual function call
  757. bool widgetActive = isActive();
  758. if (widgetActive)
  759. deactivate();
  760. widget.reset();
  761. pos.x = pos.y = 0;
  762. pos.w = GH.screenDimensions().x;
  763. pos.h = GH.screenDimensions().y;
  764. widget = std::make_shared<AdventureMapWidget>(shortcuts);
  765. widget->getMapView()->onViewMapActivated();
  766. widget->setPlayer(currentPlayerID);
  767. widget->updateActiveState();
  768. widget->getMinimap()->update();
  769. widget->getInfoBar()->showSelection();
  770. if (LOCPLINT && LOCPLINT->localState->getCurrentArmy())
  771. widget->getMapView()->onCenteredObject(LOCPLINT->localState->getCurrentArmy());
  772. adjustActiveness();
  773. if (widgetActive)
  774. activate();
  775. }
  776. bool AdventureMapInterface::isValidAdventureSpellTarget(int3 targetPosition) const
  777. {
  778. spells::detail::ProblemImpl problem;
  779. return spellBeingCasted->getAdventureMechanics().canBeCastAt(problem, LOCPLINT->cb.get(), LOCPLINT->localState->getCurrentHero(), targetPosition);
  780. }