CAdvmapInterface.cpp 42 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556
  1. #include "StdInc.h"
  2. #include "CAdvmapInterface.h"
  3. #include "../CCallback.h"
  4. #include "CCastleInterface.h"
  5. #include "gui/CCursorHandler.h"
  6. #include "CGameInfo.h"
  7. #include "CHeroWindow.h"
  8. #include "CKingdomInterface.h"
  9. #include "CMessage.h"
  10. #include "CPlayerInterface.h"
  11. #include "gui/SDL_Extensions.h"
  12. #include "CBitmapHandler.h"
  13. #include "../lib/CConfigHandler.h"
  14. #include "CSpellWindow.h"
  15. #include "Graphics.h"
  16. #include "CDefHandler.h"
  17. #include "../lib/CGeneralTextHandler.h"
  18. #include "../lib/CHeroHandler.h"
  19. #include "../lib/mapObjects/CGHeroInstance.h"
  20. #include "../lib/CTownHandler.h"
  21. #include "../lib/mapping/CMap.h"
  22. #include "../lib/JsonNode.h"
  23. #include "mapHandler.h"
  24. #include "CPreGame.h"
  25. #include "../lib/VCMI_Lib.h"
  26. #include "../lib/CSpellHandler.h"
  27. #include "CSoundBase.h"
  28. #include "../lib/CGameState.h"
  29. #include "CMusicHandler.h"
  30. #include "gui/CGuiHandler.h"
  31. #include "gui/CIntObjectClasses.h"
  32. #include "../lib/UnlockGuard.h"
  33. #ifdef _MSC_VER
  34. #pragma warning (disable : 4355)
  35. #endif
  36. /*
  37. * CAdvMapInterface.cpp, part of VCMI engine
  38. *
  39. * Authors: listed in file AUTHORS in main folder
  40. *
  41. * License: GNU General Public License v2.0 or later
  42. * Full text of license available in license.txt file, in main folder
  43. *
  44. */
  45. #define ADVOPT (conf.go()->ac)
  46. using namespace boost::logic;
  47. using namespace boost::assign;
  48. using namespace CSDL_Ext;
  49. CAdvMapInt *adventureInt;
  50. CTerrainRect::CTerrainRect()
  51. :curHoveredTile(-1,-1,-1), currentPath(nullptr)
  52. {
  53. tilesw=(ADVOPT.advmapW+31)/32;
  54. tilesh=(ADVOPT.advmapH+31)/32;
  55. pos.x=ADVOPT.advmapX;
  56. pos.y=ADVOPT.advmapY;
  57. pos.w=ADVOPT.advmapW;
  58. pos.h=ADVOPT.advmapH;
  59. moveX = moveY = 0;
  60. addUsedEvents(LCLICK | RCLICK | HOVER | MOVE);
  61. }
  62. void CTerrainRect::deactivate()
  63. {
  64. CIntObject::deactivate();
  65. curHoveredTile = int3(-1,-1,-1); //we lost info about hovered tile when disabling
  66. }
  67. void CTerrainRect::clickLeft(tribool down, bool previousState)
  68. {
  69. if ((down==false) || indeterminate(down))
  70. return;
  71. int3 mp = whichTileIsIt();
  72. if (mp.x<0 || mp.y<0 || mp.x >= LOCPLINT->cb->getMapSize().x || mp.y >= LOCPLINT->cb->getMapSize().y)
  73. return;
  74. adventureInt->tileLClicked(mp);
  75. }
  76. void CTerrainRect::clickRight(tribool down, bool previousState)
  77. {
  78. int3 mp = whichTileIsIt();
  79. if (CGI->mh->map->isInTheMap(mp) && down)
  80. adventureInt->tileRClicked(mp);
  81. }
  82. void CTerrainRect::mouseMoved (const SDL_MouseMotionEvent & sEvent)
  83. {
  84. int3 tHovered = whichTileIsIt(sEvent.x,sEvent.y);
  85. int3 pom = adventureInt->verifyPos(tHovered);
  86. if(tHovered != pom) //tile outside the map
  87. {
  88. CCS->curh->changeGraphic(ECursor::ADVENTURE, 0);
  89. return;
  90. }
  91. if (pom != curHoveredTile)
  92. curHoveredTile=pom;
  93. else
  94. return;
  95. adventureInt->tileHovered(curHoveredTile);
  96. }
  97. void CTerrainRect::hover(bool on)
  98. {
  99. if (!on)
  100. {
  101. adventureInt->statusbar.clear();
  102. CCS->curh->changeGraphic(ECursor::ADVENTURE,0);
  103. }
  104. //Hoverable::hover(on);
  105. }
  106. void CTerrainRect::showPath(const SDL_Rect * extRect, SDL_Surface * to)
  107. {
  108. const static int pns[9][9] = {
  109. {16, 17, 18, 7, -1, 19, 6, 5, -1},
  110. { 8, 9, 18, 7, -1, 19, 6, -1, 20},
  111. { 8, 1, 10, 7, -1, 19, -1, 21, 20},
  112. {24, 17, 18, 15, -1, -1, 6, 5, 4},
  113. {-1, -1, -1, -1, -1, -1, -1, -1, -1},
  114. { 8, 1, 2, -1, -1, 11, 22, 21, 20},
  115. {24, 17, -1, 23, -1, 3, 14, 5, 4},
  116. {24, -1, 2, 23, -1, 3, 22, 13, 4},
  117. {-1, 1, 2, 23, -1, 3, 22, 21, 12}
  118. }; //table of magic values TODO meaning, change variable name
  119. for (int i=0; i < (int)currentPath->nodes.size()-1; ++i)
  120. {
  121. const int3 &curPos = currentPath->nodes[i].coord, &nextPos = currentPath->nodes[i+1].coord;
  122. if(curPos.z != adventureInt->position.z)
  123. continue;
  124. int pn=-1;//number of picture
  125. if (i==0) //last tile
  126. {
  127. int x = 32*(curPos.x-adventureInt->position.x)+CGI->mh->offsetX + pos.x,
  128. y = 32*(curPos.y-adventureInt->position.y)+CGI->mh->offsetY + pos.y;
  129. if (x<0 || y<0 || x>pos.w || y>pos.h)
  130. continue;
  131. pn=0;
  132. }
  133. else
  134. {
  135. const int3 &prevPos = currentPath->nodes[i-1].coord;
  136. std::vector<CGPathNode> & cv = currentPath->nodes;
  137. /* Vector directions
  138. * 0 1 2
  139. * \ | /
  140. * 3 - 4 - 5
  141. * / | \
  142. * 6 7 8
  143. *For example:
  144. * |
  145. * |__\
  146. * /
  147. * is id1=7, id2=5 (pns[7][5])
  148. */
  149. bool pathContinuous = curPos.areNeighbours(nextPos) && curPos.areNeighbours(prevPos);
  150. if(pathContinuous && cv[i].land == cv[i+1].land)
  151. {
  152. int id1=(curPos.x-nextPos.x+1)+3*(curPos.y-nextPos.y+1); //Direction of entering vector
  153. int id2=(cv[i-1].coord.x-curPos.x+1)+3*(cv[i-1].coord.y-curPos.y+1); //Direction of exiting vector
  154. pn=pns[id1][id2];
  155. }
  156. else //path discontinuity or sea/land transition (eg. when moving through Subterranean Gate or Boat)
  157. {
  158. pn = 0;
  159. }
  160. }
  161. if (currentPath->nodes[i].turns)
  162. pn+=25;
  163. if (pn>=0)
  164. {
  165. CDefEssential * arrows = graphics->heroMoveArrows;
  166. int x = 32*(curPos.x-adventureInt->position.x)+CGI->mh->offsetX + pos.x,
  167. y = 32*(curPos.y-adventureInt->position.y)+CGI->mh->offsetY + pos.y;
  168. if (x< -32 || y< -32 || x>pos.w || y>pos.h)
  169. continue;
  170. int hvx = (x+arrows->ourImages[pn].bitmap->w)-(pos.x+pos.w),
  171. hvy = (y+arrows->ourImages[pn].bitmap->h)-(pos.y+pos.h);
  172. SDL_Rect prevClip;
  173. SDL_GetClipRect(to, &prevClip);
  174. SDL_SetClipRect(to, extRect); //preventing blitting outside of that rect
  175. if(ADVOPT.smoothMove) //version for smooth hero move, with pos shifts
  176. {
  177. if (hvx<0 && hvy<0)
  178. {
  179. Rect dstRect = genRect(32, 32, x + moveX, y + moveY);
  180. CSDL_Ext::blit8bppAlphaTo24bpp(arrows->ourImages[pn].bitmap, nullptr, to, &dstRect);
  181. }
  182. else if(hvx<0)
  183. {
  184. Rect srcRect = genRect(arrows->ourImages[pn].bitmap->h-hvy, arrows->ourImages[pn].bitmap->w, 0, 0);
  185. Rect dstRect = genRect(arrows->ourImages[pn].bitmap->h-hvy, arrows->ourImages[pn].bitmap->w, x + moveX, y + moveY);
  186. CSDL_Ext::blit8bppAlphaTo24bpp(arrows->ourImages[pn].bitmap, &srcRect, to, &dstRect);
  187. }
  188. else if (hvy<0)
  189. {
  190. Rect srcRect = genRect(arrows->ourImages[pn].bitmap->h, arrows->ourImages[pn].bitmap->w-hvx, 0, 0);
  191. Rect dstRect = genRect(arrows->ourImages[pn].bitmap->h, arrows->ourImages[pn].bitmap->w-hvx, x + moveX, y + moveY);
  192. CSDL_Ext::blit8bppAlphaTo24bpp(arrows->ourImages[pn].bitmap, &srcRect, to, &dstRect);
  193. }
  194. else
  195. {
  196. Rect srcRect = genRect(arrows->ourImages[pn].bitmap->h-hvy, arrows->ourImages[pn].bitmap->w-hvx, 0, 0);
  197. Rect dstRect = genRect(arrows->ourImages[pn].bitmap->h-hvy, arrows->ourImages[pn].bitmap->w-hvx, x + moveX, y + moveY);
  198. CSDL_Ext::blit8bppAlphaTo24bpp(arrows->ourImages[pn].bitmap, &srcRect, to, &dstRect);
  199. }
  200. }
  201. else //standard version
  202. {
  203. if (hvx<0 && hvy<0)
  204. {
  205. Rect dstRect = genRect(32, 32, x, y);
  206. CSDL_Ext::blit8bppAlphaTo24bpp(arrows->ourImages[pn].bitmap, nullptr, to, &dstRect);
  207. }
  208. else if(hvx<0)
  209. {
  210. Rect srcRect = genRect(arrows->ourImages[pn].bitmap->h-hvy, arrows->ourImages[pn].bitmap->w, 0, 0);
  211. Rect dstRect = genRect(arrows->ourImages[pn].bitmap->h-hvy, arrows->ourImages[pn].bitmap->w, x, y);
  212. CSDL_Ext::blit8bppAlphaTo24bpp(arrows->ourImages[pn].bitmap, &srcRect, to, &dstRect);
  213. }
  214. else if (hvy<0)
  215. {
  216. Rect srcRect = genRect(arrows->ourImages[pn].bitmap->h, arrows->ourImages[pn].bitmap->w-hvx, 0, 0);
  217. Rect dstRect = genRect(arrows->ourImages[pn].bitmap->h, arrows->ourImages[pn].bitmap->w-hvx, x, y);
  218. CSDL_Ext::blit8bppAlphaTo24bpp(arrows->ourImages[pn].bitmap, &srcRect, to, &dstRect);
  219. }
  220. else
  221. {
  222. Rect srcRect = genRect(arrows->ourImages[pn].bitmap->h-hvy, arrows->ourImages[pn].bitmap->w-hvx, 0, 0);
  223. Rect dstRect = genRect(arrows->ourImages[pn].bitmap->h-hvy, arrows->ourImages[pn].bitmap->w-hvx, x, y);
  224. CSDL_Ext::blit8bppAlphaTo24bpp(arrows->ourImages[pn].bitmap, &srcRect, to, &dstRect);
  225. }
  226. }
  227. SDL_SetClipRect(to, &prevClip);
  228. }
  229. } //for (int i=0;i<currentPath->nodes.size()-1;i++)
  230. }
  231. void CTerrainRect::show(SDL_Surface * to)
  232. {
  233. if(ADVOPT.smoothMove)
  234. CGI->mh->terrainRect
  235. (adventureInt->position, adventureInt->anim,
  236. &LOCPLINT->cb->getVisibilityMap(), true, adventureInt->heroAnim,
  237. to, &pos, moveX, moveY, false, int3());
  238. else
  239. CGI->mh->terrainRect
  240. (adventureInt->position, adventureInt->anim,
  241. &LOCPLINT->cb->getVisibilityMap(), true, adventureInt->heroAnim,
  242. to, &pos, 0, 0, false, int3());
  243. //SDL_BlitSurface(teren,&genRect(pos.h,pos.w,0,0),screen,&genRect(547,594,7,6));
  244. //SDL_FreeSurface(teren);
  245. if (currentPath/* && adventureInt->position.z==currentPath->startPos().z*/) //drawing path
  246. {
  247. showPath(&pos, to);
  248. }
  249. }
  250. int3 CTerrainRect::whichTileIsIt(const int & x, const int & y)
  251. {
  252. int3 ret;
  253. ret.x = adventureInt->position.x + ((GH.current->motion.x-CGI->mh->offsetX-pos.x)/32);
  254. ret.y = adventureInt->position.y + ((GH.current->motion.y-CGI->mh->offsetY-pos.y)/32);
  255. ret.z = adventureInt->position.z;
  256. return ret;
  257. }
  258. int3 CTerrainRect::whichTileIsIt()
  259. {
  260. return whichTileIsIt(GH.current->motion.x,GH.current->motion.y);
  261. }
  262. void CResDataBar::clickRight(tribool down, bool previousState)
  263. {
  264. }
  265. CResDataBar::CResDataBar(const std::string &defname, int x, int y, int offx, int offy, int resdist, int datedist)
  266. {
  267. bg = BitmapHandler::loadBitmap(defname);
  268. SDL_SetColorKey(bg,SDL_SRCCOLORKEY,SDL_MapRGB(bg->format,0,255,255));
  269. graphics->blueToPlayersAdv(bg,LOCPLINT->playerID);
  270. pos = genRect(bg->h, bg->w, pos.x+x, pos.y+y);
  271. txtpos.resize(8);
  272. for (int i = 0; i < 8 ; i++)
  273. {
  274. txtpos[i].first = pos.x + offx + resdist*i;
  275. txtpos[i].second = pos.y + offy;
  276. }
  277. txtpos[7].first = txtpos[6].first + datedist;
  278. datetext = CGI->generaltexth->allTexts[62]+": %s, " + CGI->generaltexth->allTexts[63]
  279. + ": %s, " + CGI->generaltexth->allTexts[64] + ": %s";
  280. addUsedEvents(RCLICK);
  281. }
  282. CResDataBar::CResDataBar()
  283. {
  284. bg = BitmapHandler::loadBitmap(ADVOPT.resdatabarG);
  285. SDL_SetColorKey(bg,SDL_SRCCOLORKEY,SDL_MapRGB(bg->format,0,255,255));
  286. graphics->blueToPlayersAdv(bg,LOCPLINT->playerID);
  287. pos = genRect(bg->h,bg->w,ADVOPT.resdatabarX,ADVOPT.resdatabarY);
  288. txtpos.resize(8);
  289. for (int i = 0; i < 8 ; i++)
  290. {
  291. txtpos[i].first = pos.x + ADVOPT.resOffsetX + ADVOPT.resDist*i;
  292. txtpos[i].second = pos.y + ADVOPT.resOffsetY;
  293. }
  294. txtpos[7].first = txtpos[6].first + ADVOPT.resDateDist;
  295. datetext = CGI->generaltexth->allTexts[62]+": %s, " + CGI->generaltexth->allTexts[63]
  296. + ": %s, " + CGI->generaltexth->allTexts[64] + ": %s";
  297. }
  298. CResDataBar::~CResDataBar()
  299. {
  300. SDL_FreeSurface(bg);
  301. }
  302. void CResDataBar::draw(SDL_Surface * to)
  303. {
  304. blitAt(bg,pos.x,pos.y,to);
  305. for (auto i=Res::WOOD; i<=Res::GOLD; vstd::advance(i, 1))
  306. {
  307. std::string text = boost::lexical_cast<std::string>(LOCPLINT->cb->getResourceAmount(i));
  308. graphics->fonts[FONT_SMALL]->renderTextLeft(to, text, Colors::WHITE, Point(txtpos[i].first,txtpos[i].second));
  309. }
  310. std::vector<std::string> temp;
  311. temp.push_back(boost::lexical_cast<std::string>(LOCPLINT->cb->getDate(Date::MONTH)));
  312. temp.push_back(boost::lexical_cast<std::string>(LOCPLINT->cb->getDate(Date::WEEK)));
  313. temp.push_back(boost::lexical_cast<std::string>(LOCPLINT->cb->getDate(Date::DAY_OF_WEEK)));
  314. graphics->fonts[FONT_SMALL]->renderTextLeft(to, processStr(datetext,temp), Colors::WHITE, Point(txtpos[7].first,txtpos[7].second));
  315. }
  316. void CResDataBar::show(SDL_Surface * to)
  317. {
  318. }
  319. void CResDataBar::showAll(SDL_Surface * to)
  320. {
  321. draw(to);
  322. }
  323. CAdvMapInt::CAdvMapInt():
  324. minimap(Rect(ADVOPT.minimapX, ADVOPT.minimapY, ADVOPT.minimapW, ADVOPT.minimapH)),
  325. statusbar(ADVOPT.statusbarX,ADVOPT.statusbarY,ADVOPT.statusbarG),
  326. kingOverview(CGI->generaltexth->zelp[293].first,CGI->generaltexth->zelp[293].second,
  327. boost::bind(&CAdvMapInt::fshowOverview,this),&ADVOPT.kingOverview, SDLK_k),
  328. underground(CGI->generaltexth->zelp[294].first,CGI->generaltexth->zelp[294].second,
  329. boost::bind(&CAdvMapInt::fswitchLevel,this),&ADVOPT.underground, SDLK_u),
  330. questlog(CGI->generaltexth->zelp[295].first,CGI->generaltexth->zelp[295].second,
  331. boost::bind(&CAdvMapInt::fshowQuestlog,this),&ADVOPT.questlog, SDLK_q),
  332. sleepWake(CGI->generaltexth->zelp[296].first,CGI->generaltexth->zelp[296].second,
  333. boost::bind(&CAdvMapInt::fsleepWake,this), &ADVOPT.sleepWake, SDLK_w),
  334. moveHero(CGI->generaltexth->zelp[297].first,CGI->generaltexth->zelp[297].second,
  335. boost::bind(&CAdvMapInt::fmoveHero,this), &ADVOPT.moveHero, SDLK_m),
  336. spellbook(CGI->generaltexth->zelp[298].first,CGI->generaltexth->zelp[298].second,
  337. boost::bind(&CAdvMapInt::fshowSpellbok,this), &ADVOPT.spellbook, SDLK_c),
  338. advOptions(CGI->generaltexth->zelp[299].first,CGI->generaltexth->zelp[299].second,
  339. boost::bind(&CAdvMapInt::fadventureOPtions,this), &ADVOPT.advOptions, SDLK_a),
  340. sysOptions(CGI->generaltexth->zelp[300].first,CGI->generaltexth->zelp[300].second,
  341. boost::bind(&CAdvMapInt::fsystemOptions,this), &ADVOPT.sysOptions, SDLK_o),
  342. nextHero(CGI->generaltexth->zelp[301].first,CGI->generaltexth->zelp[301].second,
  343. boost::bind(&CAdvMapInt::fnextHero,this), &ADVOPT.nextHero, SDLK_h),
  344. endTurn(CGI->generaltexth->zelp[302].first,CGI->generaltexth->zelp[302].second,
  345. boost::bind(&CAdvMapInt::fendTurn,this), &ADVOPT.endTurn, SDLK_e),
  346. heroList(ADVOPT.hlistSize, Point(ADVOPT.hlistX, ADVOPT.hlistY), ADVOPT.hlistAU, ADVOPT.hlistAD),
  347. townList(ADVOPT.tlistSize, Point(ADVOPT.tlistX, ADVOPT.tlistY), ADVOPT.tlistAU, ADVOPT.tlistAD),
  348. infoBar(Rect(ADVOPT.infoboxX, ADVOPT.infoboxY, 192, 192) )
  349. {
  350. duringAITurn = false;
  351. state = NA;
  352. spellBeingCasted = nullptr;
  353. pos.x = pos.y = 0;
  354. pos.w = screen->w;
  355. pos.h = screen->h;
  356. position = int3(0,0,0);
  357. selection = nullptr;
  358. townList.onSelect = boost::bind(&CAdvMapInt::selectionChanged,this);
  359. adventureInt=this;
  360. bg = BitmapHandler::loadBitmap(ADVOPT.mainGraphic);
  361. scrollingDir = 0;
  362. updateScreen = false;
  363. anim=0;
  364. animValHitCount=0; //animation frame
  365. heroAnim=0;
  366. heroAnimValHitCount=0; // hero animation frame
  367. for (int g=0; g<ADVOPT.gemG.size(); ++g)
  368. {
  369. gems.push_back(CDefHandler::giveDef(ADVOPT.gemG[g]));
  370. }
  371. setPlayer(LOCPLINT->playerID);
  372. underground.block(!CGI->mh->map->twoLevel);
  373. addUsedEvents(MOVE);
  374. }
  375. CAdvMapInt::~CAdvMapInt()
  376. {
  377. SDL_FreeSurface(bg);
  378. for(int i=0; i<gems.size(); i++)
  379. delete gems[i];
  380. }
  381. void CAdvMapInt::fshowOverview()
  382. {
  383. GH.pushInt(new CKingdomInterface);
  384. }
  385. void CAdvMapInt::fswitchLevel()
  386. {
  387. if(!CGI->mh->map->twoLevel)
  388. return;
  389. if (position.z)
  390. {
  391. position.z--;
  392. underground.setIndex(0,true);
  393. underground.showAll(screenBuf);
  394. }
  395. else
  396. {
  397. underground.setIndex(1,true);
  398. position.z++;
  399. underground.showAll(screenBuf);
  400. }
  401. updateScreen = true;
  402. minimap.setLevel(position.z);
  403. }
  404. void CAdvMapInt::fshowQuestlog()
  405. {
  406. LOCPLINT->showQuestLog();
  407. }
  408. void CAdvMapInt::fsleepWake()
  409. {
  410. const CGHeroInstance *h = curHero();
  411. if (!h)
  412. return;
  413. bool newSleep = !isHeroSleeping(h);
  414. setHeroSleeping(h, newSleep);
  415. updateSleepWake(h);
  416. if (newSleep)
  417. {
  418. fnextHero();
  419. //moveHero.block(true);
  420. //uncomment to enable original HoMM3 behaviour:
  421. //move button is disabled for hero going to sleep, even though it's enabled when you reselect him
  422. }
  423. }
  424. void CAdvMapInt::fmoveHero()
  425. {
  426. const CGHeroInstance *h = curHero();
  427. if (!h || !terrain.currentPath)
  428. return;
  429. LOCPLINT->moveHero(h, *terrain.currentPath);
  430. }
  431. void CAdvMapInt::fshowSpellbok()
  432. {
  433. if (!curHero()) //checking necessary values
  434. return;
  435. centerOn(selection);
  436. auto spellWindow = new CSpellWindow(genRect(595, 620, (screen->w - 620)/2, (screen->h - 595)/2), curHero(), LOCPLINT, false);
  437. GH.pushInt(spellWindow);
  438. }
  439. void CAdvMapInt::fadventureOPtions()
  440. {
  441. GH.pushInt(new CAdventureOptions);
  442. }
  443. void CAdvMapInt::fsystemOptions()
  444. {
  445. GH.pushInt(new CSystemOptionsWindow());
  446. }
  447. void CAdvMapInt::fnextHero()
  448. {
  449. auto hero = dynamic_cast<const CGHeroInstance*>(selection);
  450. int next = getNextHeroIndex(vstd::find_pos(LOCPLINT->wanderingHeroes, hero));
  451. if (next < 0)
  452. return;
  453. select(LOCPLINT->wanderingHeroes[next], true);
  454. }
  455. void CAdvMapInt::fendTurn()
  456. {
  457. if(!LOCPLINT->makingTurn)
  458. return;
  459. if ( settings["adventure"]["heroReminder"].Bool())
  460. {
  461. for (int i = 0; i < LOCPLINT->wanderingHeroes.size(); i++)
  462. if (!isHeroSleeping(LOCPLINT->wanderingHeroes[i]) && (LOCPLINT->wanderingHeroes[i]->movement > 0))
  463. {
  464. LOCPLINT->showYesNoDialog(CGI->generaltexth->allTexts[55], boost::bind(&CAdvMapInt::endingTurn, this), 0, false);
  465. return;
  466. }
  467. }
  468. endingTurn();
  469. }
  470. void CAdvMapInt::updateSleepWake(const CGHeroInstance *h)
  471. {
  472. sleepWake.block(!h);
  473. if (!h)
  474. return;
  475. bool state = isHeroSleeping(h);
  476. sleepWake.setIndex(state ? 1 : 0, true);
  477. sleepWake.assignedKeys.clear();
  478. sleepWake.assignedKeys.insert(state ? SDLK_w : SDLK_z);
  479. sleepWake.update();
  480. }
  481. void CAdvMapInt::updateMoveHero(const CGHeroInstance *h, tribool hasPath)
  482. {
  483. //default value is for everywhere but CPlayerInterface::moveHero, because paths are not updated from there immediately
  484. if (hasPath == boost::indeterminate)
  485. hasPath = LOCPLINT->paths[h].nodes.size() ? true : false;
  486. if (!h)
  487. {
  488. moveHero.block(true);
  489. return;
  490. }
  491. moveHero.block(!hasPath || (h->movement == 0));
  492. }
  493. int CAdvMapInt::getNextHeroIndex(int startIndex)
  494. {
  495. if (LOCPLINT->wanderingHeroes.size() == 0)
  496. return -1;
  497. if (startIndex < 0)
  498. startIndex = 0;
  499. int i = startIndex;
  500. do
  501. {
  502. i++;
  503. if (i >= LOCPLINT->wanderingHeroes.size())
  504. i = 0;
  505. }
  506. while (((LOCPLINT->wanderingHeroes[i]->movement == 0) || isHeroSleeping(LOCPLINT->wanderingHeroes[i])) && (i != startIndex));
  507. if ((LOCPLINT->wanderingHeroes[i]->movement != 0) && !isHeroSleeping(LOCPLINT->wanderingHeroes[i]))
  508. return i;
  509. else
  510. return -1;
  511. }
  512. void CAdvMapInt::updateNextHero(const CGHeroInstance *h)
  513. {
  514. int start = vstd::find_pos(LOCPLINT->wanderingHeroes, h);
  515. int next = getNextHeroIndex(start);
  516. if (next < 0)
  517. {
  518. nextHero.block(true);
  519. return;
  520. }
  521. const CGHeroInstance *nextH = LOCPLINT->wanderingHeroes[next];
  522. bool noActiveHeroes = (next == start) && ((nextH->movement == 0) || isHeroSleeping(nextH));
  523. nextHero.block(noActiveHeroes);
  524. }
  525. void CAdvMapInt::activate()
  526. {
  527. CIntObject::activate();
  528. if (!(active & KEYBOARD))
  529. CIntObject::activate(KEYBOARD);
  530. screenBuf = screen;
  531. GH.statusbar = &statusbar;
  532. if(!duringAITurn)
  533. {
  534. kingOverview.activate();
  535. underground.activate();
  536. questlog.activate();
  537. sleepWake.activate();
  538. moveHero.activate();
  539. spellbook.activate();
  540. sysOptions.activate();
  541. advOptions.activate();
  542. nextHero.activate();
  543. endTurn.activate();
  544. minimap.activate();
  545. heroList.activate();
  546. townList.activate();
  547. terrain.activate();
  548. infoBar.activate();
  549. LOCPLINT->cingconsole->activate();
  550. GH.fakeMouseMove(); //to restore the cursor
  551. }
  552. }
  553. void CAdvMapInt::deactivate()
  554. {
  555. CIntObject::deactivate();
  556. if(!duringAITurn)
  557. {
  558. scrollingDir = 0;
  559. CCS->curh->changeGraphic(ECursor::ADVENTURE,0);
  560. kingOverview.deactivate();
  561. underground.deactivate();
  562. questlog.deactivate();
  563. sleepWake.deactivate();
  564. moveHero.deactivate();
  565. spellbook.deactivate();
  566. advOptions.deactivate();
  567. sysOptions.deactivate();
  568. nextHero.deactivate();
  569. endTurn.deactivate();
  570. minimap.deactivate();
  571. heroList.deactivate();
  572. townList.deactivate();
  573. terrain.deactivate();
  574. infoBar.deactivate();
  575. if(LOCPLINT)
  576. LOCPLINT->cingconsole->deactivate();
  577. }
  578. }
  579. void CAdvMapInt::showAll(SDL_Surface * to)
  580. {
  581. blitAt(bg,0,0,to);
  582. if(state != INGAME)
  583. return;
  584. kingOverview.showAll(to);
  585. underground.showAll(to);
  586. questlog.showAll(to);
  587. sleepWake.showAll(to);
  588. moveHero.showAll(to);
  589. spellbook.showAll(to);
  590. advOptions.showAll(to);
  591. sysOptions.showAll(to);
  592. nextHero.showAll(to);
  593. endTurn.showAll(to);
  594. minimap.showAll(to);
  595. heroList.showAll(to);
  596. townList.showAll(to);
  597. updateScreen = true;
  598. show(to);
  599. resdatabar.draw(to);
  600. statusbar.show(to);
  601. infoBar.showAll(to);
  602. LOCPLINT->cingconsole->showAll(to);
  603. }
  604. bool CAdvMapInt::isHeroSleeping(const CGHeroInstance *hero)
  605. {
  606. if (!hero)
  607. return false;
  608. return vstd::contains(LOCPLINT->sleepingHeroes, hero);
  609. }
  610. void CAdvMapInt::setHeroSleeping(const CGHeroInstance *hero, bool sleep)
  611. {
  612. if (sleep)
  613. LOCPLINT->sleepingHeroes += hero;
  614. else
  615. LOCPLINT->sleepingHeroes -= hero;
  616. updateNextHero(nullptr);
  617. }
  618. void CAdvMapInt::show(SDL_Surface * to)
  619. {
  620. if(state != INGAME)
  621. return;
  622. ++animValHitCount; //for animations
  623. if(animValHitCount == 8)
  624. {
  625. CGI->mh->updateWater();
  626. animValHitCount = 0;
  627. ++anim;
  628. updateScreen = true;
  629. }
  630. ++heroAnim;
  631. int scrollSpeed = settings["adventure"]["scrollSpeed"].Float();
  632. //if advmap needs updating AND (no dialog is shown OR ctrl is pressed)
  633. if((animValHitCount % (4/scrollSpeed)) == 0
  634. && (
  635. (GH.topInt() == this)
  636. || SDL_GetKeyState(nullptr)[SDLK_LCTRL]
  637. || SDL_GetKeyState(nullptr)[SDLK_RCTRL]
  638. )
  639. )
  640. {
  641. if( (scrollingDir & LEFT) && (position.x>-CGI->mh->frameW) )
  642. position.x--;
  643. if( (scrollingDir & RIGHT) && (position.x < CGI->mh->map->width - CGI->mh->tilesW + CGI->mh->frameW) )
  644. position.x++;
  645. if( (scrollingDir & UP) && (position.y>-CGI->mh->frameH) )
  646. position.y--;
  647. if( (scrollingDir & DOWN) && (position.y < CGI->mh->map->height - CGI->mh->tilesH + CGI->mh->frameH) )
  648. position.y++;
  649. if(scrollingDir)
  650. {
  651. updateScreen = true;
  652. minimap.redraw();
  653. }
  654. }
  655. if(updateScreen)
  656. {
  657. int3 betterPos = LOCPLINT->repairScreenPos(position);
  658. if (betterPos != position)
  659. {
  660. logGlobal->warnStream() << "Incorrect position for adventure map!";
  661. position = betterPos;
  662. }
  663. terrain.show(to);
  664. for(int i=0;i<4;i++)
  665. blitAt(gems[i]->ourImages[LOCPLINT->playerID.getNum()].bitmap,ADVOPT.gemX[i],ADVOPT.gemY[i],to);
  666. updateScreen=false;
  667. LOCPLINT->cingconsole->showAll(to);
  668. }
  669. infoBar.show(to);
  670. statusbar.showAll(to);
  671. }
  672. void CAdvMapInt::selectionChanged()
  673. {
  674. const CGTownInstance *to = LOCPLINT->towns[townList.getSelectedIndex()];
  675. if (selection != to)
  676. select(to);
  677. }
  678. void CAdvMapInt::centerOn(int3 on)
  679. {
  680. bool switchedLevels = on.z != position.z;
  681. on.x -= CGI->mh->frameW;
  682. on.y -= CGI->mh->frameH;
  683. on = LOCPLINT->repairScreenPos(on);
  684. position = on;
  685. updateScreen=true;
  686. underground.setIndex(on.z,true); //change underground switch button image
  687. underground.redraw();
  688. if (switchedLevels)
  689. minimap.setLevel(position.z);
  690. }
  691. void CAdvMapInt::centerOn(const CGObjectInstance *obj)
  692. {
  693. centerOn(obj->getSightCenter());
  694. }
  695. void CAdvMapInt::keyPressed(const SDL_KeyboardEvent & key)
  696. {
  697. ui8 Dir = 0;
  698. int k = key.keysym.sym;
  699. const CGHeroInstance *h = curHero(); //selected hero
  700. const CGTownInstance *t = curTown(); //selected town
  701. switch(k)
  702. {
  703. case SDLK_g:
  704. if(key.state != SDL_PRESSED || GH.topInt()->type & BLOCK_ADV_HOTKEYS)
  705. return;
  706. {
  707. //find first town with tavern
  708. auto itr = range::find_if(LOCPLINT->towns, [](const CGTownInstance * town)
  709. {
  710. return town->hasBuilt(BuildingID::TAVERN);
  711. });
  712. if(itr != LOCPLINT->towns.end())
  713. LOCPLINT->showThievesGuildWindow(*itr);
  714. else
  715. LOCPLINT->showInfoDialog("No available town with tavern!");
  716. }
  717. return;
  718. case SDLK_i:
  719. if(isActive())
  720. CAdventureOptions::showScenarioInfo();
  721. return;
  722. case SDLK_l:
  723. if(isActive())
  724. LOCPLINT->proposeLoadingGame();
  725. return;
  726. case SDLK_s:
  727. if(isActive())
  728. GH.pushInt(new CSavingScreen(CPlayerInterface::howManyPeople > 1));
  729. return;
  730. case SDLK_d:
  731. {
  732. if(h && isActive() && key.state == SDL_PRESSED)
  733. LOCPLINT->tryDiggging(h);
  734. return;
  735. }
  736. case SDLK_p:
  737. if(isActive())
  738. LOCPLINT->showPuzzleMap();
  739. return;
  740. case SDLK_r:
  741. if(isActive() && LOCPLINT->ctrlPressed())
  742. {
  743. LOCPLINT->showYesNoDialog("Are you sure you want to restart game?",
  744. []{ LOCPLINT->sendCustomEvent(RESTART_GAME); },
  745. []{}, true);
  746. }
  747. return;
  748. case SDLK_SPACE: //space - try to revisit current object with selected hero
  749. {
  750. if(!isActive())
  751. return;
  752. if(h && key.state == SDL_PRESSED)
  753. {
  754. auto unlockPim = vstd::makeUnlockGuard(*LOCPLINT->pim);
  755. //TODO!!!!!!! possible freeze, when GS mutex is locked and network thread can't apply package
  756. //this thread leaves scope and tries to lock pim while holding gs,
  757. //network thread tries to lock gs (appluy cl) while holding pim
  758. //this thread should first lock pim, however gs locking/unlocking is done inside cb
  759. LOCPLINT->cb->moveHero(h,h->pos);
  760. }
  761. }
  762. return;
  763. case SDLK_RETURN:
  764. {
  765. if(!isActive() || !selection || key.state != SDL_PRESSED)
  766. return;
  767. if(h)
  768. LOCPLINT->openHeroWindow(h);
  769. else if(t)
  770. LOCPLINT->openTownWindow(t);
  771. return;
  772. }
  773. case SDLK_ESCAPE:
  774. {
  775. if(isActive() || GH.topInt() != this || !spellBeingCasted || key.state != SDL_PRESSED)
  776. return;
  777. leaveCastingMode();
  778. return;
  779. }
  780. case SDLK_t:
  781. {
  782. //act on key down if marketplace windows is not already opened
  783. if(key.state != SDL_PRESSED || GH.topInt()->type & BLOCK_ADV_HOTKEYS)
  784. return;
  785. if(LOCPLINT->ctrlPressed()) //CTRL + T => open marketplace
  786. {
  787. //check if we have any marketplace
  788. const CGTownInstance *townWithMarket = nullptr;
  789. for(const CGTownInstance *t : LOCPLINT->cb->getTownsInfo())
  790. {
  791. if(t->hasBuilt(BuildingID::MARKETPLACE))
  792. {
  793. townWithMarket = t;
  794. break;
  795. }
  796. }
  797. if(townWithMarket) //if any town has marketplace, open window
  798. GH.pushInt(new CMarketplaceWindow(townWithMarket));
  799. else //if not - complain
  800. LOCPLINT->showInfoDialog("No available marketplace!");
  801. }
  802. else if(isActive()) //no ctrl, advmapint is on the top => switch to town
  803. {
  804. townList.selectNext();
  805. }
  806. return;
  807. }
  808. default:
  809. {
  810. static const int3 directions[] = { int3(-1, +1, 0), int3(0, +1, 0), int3(+1, +1, 0),
  811. int3(-1, 0, 0), int3(0, 0, 0), int3(+1, 0, 0),
  812. int3(-1, -1, 0), int3(0, -1, 0), int3(+1, -1, 0) };
  813. //numpad arrow
  814. if(CGuiHandler::isArrowKey(SDLKey(k)))
  815. k = CGuiHandler::arrowToNum(SDLKey(k));
  816. k -= SDLK_KP0 + 1;
  817. if(k < 0 || k > 8)
  818. return;
  819. int3 dir = directions[k];
  820. if(!isActive() || LOCPLINT->ctrlPressed())//ctrl makes arrow move screen, not hero
  821. {
  822. Dir = (dir.x<0 ? LEFT : 0) |
  823. (dir.x>0 ? RIGHT : 0) |
  824. (dir.y<0 ? UP : 0) |
  825. (dir.y>0 ? DOWN : 0) ;
  826. break;
  827. }
  828. if(!h || key.state != SDL_PRESSED)
  829. break;
  830. if(k == 4)
  831. {
  832. centerOn(h);
  833. return;
  834. }
  835. CGPath &path = LOCPLINT->paths[h];
  836. terrain.currentPath = &path;
  837. if(!LOCPLINT->cb->getPath2(h->getPosition(false) + dir, path))
  838. {
  839. terrain.currentPath = nullptr;
  840. return;
  841. }
  842. if (path.nodes.size() > 2)
  843. updateMoveHero(h);
  844. else
  845. if(!path.nodes[0].turns)
  846. LOCPLINT->moveHero(h, path);
  847. }
  848. return;
  849. }
  850. if(Dir && key.state == SDL_PRESSED //arrow is pressed
  851. && LOCPLINT->ctrlPressed()
  852. )
  853. scrollingDir |= Dir;
  854. else
  855. scrollingDir &= ~Dir;
  856. }
  857. void CAdvMapInt::handleRightClick(std::string text, tribool down)
  858. {
  859. if(down)
  860. {
  861. CRClickPopup::createAndPush(text);
  862. }
  863. }
  864. int3 CAdvMapInt::verifyPos(int3 ver)
  865. {
  866. if (ver.x<0)
  867. ver.x=0;
  868. if (ver.y<0)
  869. ver.y=0;
  870. if (ver.z<0)
  871. ver.z=0;
  872. if (ver.x>=CGI->mh->sizes.x)
  873. ver.x=CGI->mh->sizes.x-1;
  874. if (ver.y>=CGI->mh->sizes.y)
  875. ver.y=CGI->mh->sizes.y-1;
  876. if (ver.z>=CGI->mh->sizes.z)
  877. ver.z=CGI->mh->sizes.z-1;
  878. return ver;
  879. }
  880. void CAdvMapInt::select(const CArmedInstance *sel, bool centerView /*= true*/)
  881. {
  882. assert(sel);
  883. LOCPLINT->cb->setSelection(sel);
  884. selection = sel;
  885. if (LOCPLINT->battleInt == nullptr && LOCPLINT->makingTurn)
  886. {
  887. auto pos = sel->visitablePos();
  888. auto tile = LOCPLINT->cb->getTile(pos);
  889. if(tile)
  890. CCS->musich->playMusicFromSet("terrain", tile->terType, true);
  891. }
  892. if(centerView)
  893. centerOn(sel);
  894. terrain.currentPath = nullptr;
  895. if(sel->ID==Obj::TOWN)
  896. {
  897. auto town = dynamic_cast<const CGTownInstance*>(sel);
  898. infoBar.showTownSelection(town);
  899. townList.select(town);
  900. heroList.select(nullptr);
  901. updateSleepWake(nullptr);
  902. updateMoveHero(nullptr);
  903. }
  904. else //hero selected
  905. {
  906. auto hero = dynamic_cast<const CGHeroInstance*>(sel);
  907. infoBar.showHeroSelection(hero);
  908. heroList.select(hero);
  909. townList.select(nullptr);
  910. terrain.currentPath = LOCPLINT->getAndVerifyPath(hero);
  911. updateSleepWake(hero);
  912. updateMoveHero(hero);
  913. }
  914. townList.redraw();
  915. heroList.redraw();
  916. }
  917. void CAdvMapInt::mouseMoved( const SDL_MouseMotionEvent & sEvent )
  918. {
  919. //adventure map scrolling with mouse
  920. if(!SDL_GetKeyState(nullptr)[SDLK_LCTRL] && isActive())
  921. {
  922. if(sEvent.x<15)
  923. {
  924. scrollingDir |= LEFT;
  925. }
  926. else
  927. {
  928. scrollingDir &= ~LEFT;
  929. }
  930. if(sEvent.x>screen->w-15)
  931. {
  932. scrollingDir |= RIGHT;
  933. }
  934. else
  935. {
  936. scrollingDir &= ~RIGHT;
  937. }
  938. if(sEvent.y<15)
  939. {
  940. scrollingDir |= UP;
  941. }
  942. else
  943. {
  944. scrollingDir &= ~UP;
  945. }
  946. if(sEvent.y>screen->h-15)
  947. {
  948. scrollingDir |= DOWN;
  949. }
  950. else
  951. {
  952. scrollingDir &= ~DOWN;
  953. }
  954. }
  955. }
  956. bool CAdvMapInt::isActive()
  957. {
  958. return active & ~CIntObject::KEYBOARD;
  959. }
  960. void CAdvMapInt::startHotSeatWait(PlayerColor Player)
  961. {
  962. state = WAITING;
  963. }
  964. void CAdvMapInt::setPlayer(PlayerColor Player)
  965. {
  966. player = Player;
  967. graphics->blueToPlayersAdv(bg,player);
  968. kingOverview.setPlayerColor(player);
  969. underground.setPlayerColor(player);
  970. questlog.setPlayerColor(player);
  971. sleepWake.setPlayerColor(player);
  972. moveHero.setPlayerColor(player);
  973. spellbook.setPlayerColor(player);
  974. sysOptions.setPlayerColor(player);
  975. advOptions.setPlayerColor(player);
  976. nextHero.setPlayerColor(player);
  977. endTurn.setPlayerColor(player);
  978. graphics->blueToPlayersAdv(resdatabar.bg,player);
  979. //heroList.updateHList();
  980. //townList.genList();
  981. }
  982. void CAdvMapInt::startTurn()
  983. {
  984. state = INGAME;
  985. if(LOCPLINT->cb->getCurrentPlayer() == LOCPLINT->playerID)
  986. {
  987. adjustActiveness(false);
  988. minimap.setAIRadar(false);
  989. }
  990. }
  991. void CAdvMapInt::endingTurn()
  992. {
  993. if(LOCPLINT->cingconsole->active)
  994. LOCPLINT->cingconsole->deactivate();
  995. LOCPLINT->makingTurn = false;
  996. LOCPLINT->cb->endTurn();
  997. }
  998. const CGObjectInstance* CAdvMapInt::getBlockingObject(const int3 &mapPos)
  999. {
  1000. std::vector < const CGObjectInstance * > bobjs = LOCPLINT->cb->getBlockingObjs(mapPos); //blocking objects at tile
  1001. if (bobjs.empty())
  1002. return nullptr;
  1003. if (bobjs.back()->ID == Obj::HERO)
  1004. return bobjs.back();
  1005. else
  1006. return bobjs.front();
  1007. }
  1008. void CAdvMapInt::tileLClicked(const int3 &mapPos)
  1009. {
  1010. if(!LOCPLINT->cb->isVisible(mapPos) || !LOCPLINT->makingTurn)
  1011. return;
  1012. const TerrainTile *tile = LOCPLINT->cb->getTile(mapPos);
  1013. const CGObjectInstance *topBlocking = getBlockingObject(mapPos);
  1014. int3 selPos = selection->getSightCenter();
  1015. if(spellBeingCasted && isInScreenRange(selPos, mapPos))
  1016. {
  1017. const TerrainTile *heroTile = LOCPLINT->cb->getTile(selPos);
  1018. switch(spellBeingCasted->id)
  1019. {
  1020. case SpellID::SCUTTLE_BOAT: //Scuttle Boat
  1021. if(topBlocking && topBlocking->ID == Obj::BOAT)
  1022. leaveCastingMode(true, mapPos);
  1023. break;
  1024. case SpellID::DIMENSION_DOOR:
  1025. if(!tile || tile->isClear(heroTile))
  1026. leaveCastingMode(true, mapPos);
  1027. break;
  1028. }
  1029. return;
  1030. }
  1031. //check if we can select this object
  1032. bool canSelect = topBlocking && topBlocking->ID == Obj::HERO && topBlocking->tempOwner == LOCPLINT->playerID;
  1033. canSelect |= topBlocking && topBlocking->ID == Obj::TOWN && LOCPLINT->cb->getPlayerRelations(LOCPLINT->playerID, topBlocking->tempOwner);
  1034. if (selection->ID != Obj::HERO) //hero is not selected (presumably town)
  1035. {
  1036. assert(!terrain.currentPath); //path can be active only when hero is selected
  1037. if(selection == topBlocking) //selected town clicked
  1038. LOCPLINT->openTownWindow(static_cast<const CGTownInstance*>(topBlocking));
  1039. else if ( canSelect )
  1040. select(static_cast<const CArmedInstance*>(topBlocking), false);
  1041. return;
  1042. }
  1043. else if(const CGHeroInstance * currentHero = curHero()) //hero is selected
  1044. {
  1045. const CGPathNode *pn = LOCPLINT->cb->getPathInfo(mapPos);
  1046. if(currentHero == topBlocking) //clicked selected hero
  1047. {
  1048. LOCPLINT->openHeroWindow(currentHero);
  1049. return;
  1050. }
  1051. else if(canSelect && pn->turns == 255 ) //selectable object at inaccessible tile
  1052. {
  1053. select(static_cast<const CArmedInstance*>(topBlocking), false);
  1054. return;
  1055. }
  1056. else //still here? we need to move hero if we clicked end of already selected path or calculate a new path otherwise
  1057. {
  1058. if (terrain.currentPath && terrain.currentPath->endPos() == mapPos)//we'll be moving
  1059. {
  1060. LOCPLINT->moveHero(currentHero,*terrain.currentPath);
  1061. return;
  1062. }
  1063. else/* if(mp.z == currentHero->pos.z)*/ //remove old path and find a new one if we clicked on the map level on which hero is present
  1064. {
  1065. CGPath &path = LOCPLINT->paths[currentHero];
  1066. terrain.currentPath = &path;
  1067. bool gotPath = LOCPLINT->cb->getPath2(mapPos, path); //try getting path, erase if failed
  1068. updateMoveHero(currentHero);
  1069. if (!gotPath)
  1070. LOCPLINT->eraseCurrentPathOf(currentHero);
  1071. else
  1072. return;
  1073. }
  1074. }
  1075. } //end of hero is selected "case"
  1076. else
  1077. {
  1078. throw std::runtime_error("Nothing is selected...");
  1079. }
  1080. if(const IShipyard *shipyard = ourInaccessibleShipyard(topBlocking))
  1081. {
  1082. LOCPLINT->showShipyardDialogOrProblemPopup(shipyard);
  1083. }
  1084. }
  1085. void CAdvMapInt::tileHovered(const int3 &mapPos)
  1086. {
  1087. if(!LOCPLINT->cb->isVisible(mapPos))
  1088. {
  1089. CCS->curh->changeGraphic(ECursor::ADVENTURE, 0);
  1090. statusbar.clear();
  1091. return;
  1092. }
  1093. const CGObjectInstance *objAtTile = getBlockingObject(mapPos);
  1094. //std::vector<std::string> temp = LOCPLINT->cb->getObjDescriptions(mapPos);
  1095. if (objAtTile)
  1096. {
  1097. std::string text = objAtTile->getHoverText();
  1098. boost::replace_all(text,"\n"," ");
  1099. statusbar.setText(text);
  1100. }
  1101. else
  1102. {
  1103. std::string hlp;
  1104. CGI->mh->getTerrainDescr(mapPos, hlp, false);
  1105. statusbar.setText(hlp);
  1106. }
  1107. const CGPathNode *pnode = LOCPLINT->cb->getPathInfo(mapPos);
  1108. int turns = pnode->turns;
  1109. vstd::amin(turns, 3);
  1110. if(!selection) //may occur just at the start of game (fake move before full intiialization)
  1111. return;
  1112. if(spellBeingCasted)
  1113. {
  1114. switch(spellBeingCasted->id)
  1115. {
  1116. case SpellID::SCUTTLE_BOAT:
  1117. if(objAtTile && objAtTile->ID == Obj::BOAT)
  1118. CCS->curh->changeGraphic(ECursor::ADVENTURE, 42);
  1119. else
  1120. CCS->curh->changeGraphic(ECursor::ADVENTURE, 0);
  1121. return;
  1122. case SpellID::DIMENSION_DOOR:
  1123. {
  1124. const TerrainTile *t = LOCPLINT->cb->getTile(mapPos, false);
  1125. int3 hpos = selection->getSightCenter();
  1126. if((!t || t->isClear(LOCPLINT->cb->getTile(hpos))) && isInScreenRange(hpos, mapPos))
  1127. CCS->curh->changeGraphic(ECursor::ADVENTURE, 41);
  1128. else
  1129. CCS->curh->changeGraphic(ECursor::ADVENTURE, 0);
  1130. return;
  1131. }
  1132. }
  1133. }
  1134. const bool guardingCreature = CGI->mh->map->isInTheMap(LOCPLINT->cb->getGuardingCreaturePosition(mapPos));
  1135. if(selection->ID == Obj::TOWN)
  1136. {
  1137. if(objAtTile)
  1138. {
  1139. if(objAtTile->ID == Obj::TOWN && LOCPLINT->cb->getPlayerRelations(LOCPLINT->playerID, objAtTile->tempOwner) != PlayerRelations::ENEMIES)
  1140. CCS->curh->changeGraphic(ECursor::ADVENTURE, 3);
  1141. else if(objAtTile->ID == Obj::HERO && objAtTile->tempOwner == LOCPLINT->playerID)
  1142. CCS->curh->changeGraphic(ECursor::ADVENTURE, 2);
  1143. else
  1144. CCS->curh->changeGraphic(ECursor::ADVENTURE, 0);
  1145. }
  1146. else
  1147. CCS->curh->changeGraphic(ECursor::ADVENTURE, 0);
  1148. }
  1149. else if(const CGHeroInstance *h = curHero())
  1150. {
  1151. bool accessible = pnode->turns < 255;
  1152. if(objAtTile)
  1153. {
  1154. if(objAtTile->ID == Obj::HERO)
  1155. {
  1156. if(!LOCPLINT->cb->getPlayerRelations( LOCPLINT->playerID, objAtTile->tempOwner)) //enemy hero
  1157. {
  1158. if(accessible)
  1159. CCS->curh->changeGraphic(ECursor::ADVENTURE, 5 + turns*6);
  1160. else
  1161. CCS->curh->changeGraphic(ECursor::ADVENTURE, 0);
  1162. }
  1163. else //our or ally hero
  1164. {
  1165. if(selection == objAtTile)
  1166. CCS->curh->changeGraphic(ECursor::ADVENTURE, 2);
  1167. else if(accessible)
  1168. CCS->curh->changeGraphic(ECursor::ADVENTURE, 8 + turns*6);
  1169. else
  1170. CCS->curh->changeGraphic(ECursor::ADVENTURE, 2);
  1171. }
  1172. }
  1173. else if(objAtTile->ID == Obj::TOWN)
  1174. {
  1175. if(!LOCPLINT->cb->getPlayerRelations( LOCPLINT->playerID, objAtTile->tempOwner)) //enemy town
  1176. {
  1177. if(accessible)
  1178. {
  1179. const CGTownInstance* townObj = dynamic_cast<const CGTownInstance*>(objAtTile);
  1180. // Show movement cursor for unguarded enemy towns, otherwise attack cursor.
  1181. if (townObj && !townObj->armedGarrison())
  1182. CCS->curh->changeGraphic(ECursor::ADVENTURE, 9 + turns*6);
  1183. else
  1184. CCS->curh->changeGraphic(ECursor::ADVENTURE, 5 + turns*6);
  1185. }
  1186. else
  1187. {
  1188. CCS->curh->changeGraphic(ECursor::ADVENTURE, 0);
  1189. }
  1190. }
  1191. else //our or ally town
  1192. {
  1193. if(accessible)
  1194. CCS->curh->changeGraphic(ECursor::ADVENTURE, 9 + turns*6);
  1195. else
  1196. CCS->curh->changeGraphic(ECursor::ADVENTURE, 3);
  1197. }
  1198. }
  1199. else if(objAtTile->ID == Obj::BOAT)
  1200. {
  1201. if(accessible)
  1202. CCS->curh->changeGraphic(ECursor::ADVENTURE, 6 + turns*6);
  1203. else
  1204. CCS->curh->changeGraphic(ECursor::ADVENTURE, 0);
  1205. }
  1206. else if (objAtTile->ID == Obj::GARRISON || objAtTile->ID == Obj::GARRISON2)
  1207. {
  1208. if (accessible)
  1209. {
  1210. const CGGarrison* garrObj = dynamic_cast<const CGGarrison*>(objAtTile); //TODO evil evil cast!
  1211. // Show battle cursor for guarded enemy garrisons, otherwise movement cursor.
  1212. if (garrObj && garrObj->stacksCount()
  1213. && !LOCPLINT->cb->getPlayerRelations( LOCPLINT->playerID, garrObj->tempOwner) )
  1214. CCS->curh->changeGraphic(ECursor::ADVENTURE, 5 + turns*6);
  1215. else
  1216. CCS->curh->changeGraphic(ECursor::ADVENTURE, 9 + turns*6);
  1217. }
  1218. else
  1219. CCS->curh->changeGraphic(ECursor::ADVENTURE, 0);
  1220. }
  1221. else if (guardingCreature && accessible) //(objAtTile->ID == 54) //monster
  1222. {
  1223. CCS->curh->changeGraphic(ECursor::ADVENTURE, 5 + turns*6);
  1224. }
  1225. else
  1226. {
  1227. if(accessible)
  1228. {
  1229. if(pnode->land)
  1230. CCS->curh->changeGraphic(ECursor::ADVENTURE, 9 + turns*6);
  1231. else
  1232. CCS->curh->changeGraphic(ECursor::ADVENTURE, 28 + turns);
  1233. }
  1234. else
  1235. CCS->curh->changeGraphic(ECursor::ADVENTURE, 0);
  1236. }
  1237. }
  1238. else //no objs
  1239. {
  1240. if(accessible/* && pnode->accessible != CGPathNode::FLYABLE*/)
  1241. {
  1242. if (guardingCreature)
  1243. {
  1244. CCS->curh->changeGraphic(ECursor::ADVENTURE, 5 + turns*6);
  1245. }
  1246. else
  1247. {
  1248. if(pnode->land)
  1249. {
  1250. if(LOCPLINT->cb->getTile(h->getPosition(false))->terType != ETerrainType::WATER)
  1251. CCS->curh->changeGraphic(ECursor::ADVENTURE, 4 + turns*6);
  1252. else
  1253. CCS->curh->changeGraphic(ECursor::ADVENTURE, 7 + turns*6); //anchor
  1254. }
  1255. else
  1256. CCS->curh->changeGraphic(ECursor::ADVENTURE, 6 + turns*6);
  1257. }
  1258. }
  1259. else
  1260. CCS->curh->changeGraphic(ECursor::ADVENTURE, 0);
  1261. }
  1262. }
  1263. if(ourInaccessibleShipyard(objAtTile))
  1264. {
  1265. CCS->curh->changeGraphic(ECursor::ADVENTURE, 6);
  1266. }
  1267. }
  1268. void CAdvMapInt::tileRClicked(const int3 &mapPos)
  1269. {
  1270. if(spellBeingCasted)
  1271. {
  1272. leaveCastingMode();
  1273. return;
  1274. }
  1275. if(!LOCPLINT->cb->isVisible(mapPos))
  1276. {
  1277. CRClickPopup::createAndPush(VLC->generaltexth->allTexts[61]); //Uncharted Territory
  1278. return;
  1279. }
  1280. const CGObjectInstance * obj = getBlockingObject(mapPos);
  1281. if(!obj)
  1282. {
  1283. // Bare or undiscovered terrain
  1284. const TerrainTile * tile = LOCPLINT->cb->getTile(mapPos);
  1285. if (tile)
  1286. {
  1287. std::string hlp;
  1288. CGI->mh->getTerrainDescr(mapPos, hlp, true);
  1289. CRClickPopup::createAndPush(hlp);
  1290. }
  1291. return;
  1292. }
  1293. CRClickPopup::createAndPush(obj, GH.current->motion, CENTER);
  1294. }
  1295. void CAdvMapInt::enterCastingMode(const CSpell * sp)
  1296. {
  1297. assert(sp->id == SpellID::SCUTTLE_BOAT || sp->id == SpellID::DIMENSION_DOOR);
  1298. spellBeingCasted = sp;
  1299. deactivate();
  1300. terrain.activate();
  1301. GH.fakeMouseMove();
  1302. }
  1303. void CAdvMapInt::leaveCastingMode(bool cast /*= false*/, int3 dest /*= int3(-1, -1, -1)*/)
  1304. {
  1305. assert(spellBeingCasted);
  1306. SpellID id = spellBeingCasted->id;
  1307. spellBeingCasted = nullptr;
  1308. terrain.deactivate();
  1309. activate();
  1310. if(cast)
  1311. LOCPLINT->cb->castSpell(curHero(), id, dest);
  1312. else
  1313. LOCPLINT->showInfoDialog(CGI->generaltexth->allTexts[731]); //Spell cancelled
  1314. }
  1315. const CGHeroInstance * CAdvMapInt::curHero() const
  1316. {
  1317. if(selection && selection->ID == Obj::HERO)
  1318. return static_cast<const CGHeroInstance *>(selection);
  1319. else
  1320. return nullptr;
  1321. }
  1322. const CGTownInstance * CAdvMapInt::curTown() const
  1323. {
  1324. if(selection && selection->ID == Obj::TOWN)
  1325. return static_cast<const CGTownInstance *>(selection);
  1326. else
  1327. return nullptr;
  1328. }
  1329. const IShipyard * CAdvMapInt::ourInaccessibleShipyard(const CGObjectInstance *obj) const
  1330. {
  1331. const IShipyard *ret = IShipyard::castFrom(obj);
  1332. if(!ret || obj->tempOwner != player || CCS->curh->type || (CCS->curh->frame != 6 && CCS->curh->frame != 0))
  1333. return nullptr;
  1334. return ret;
  1335. }
  1336. void CAdvMapInt::aiTurnStarted()
  1337. {
  1338. adjustActiveness(true);
  1339. CCS->musich->playMusicFromSet("enemy-turn", true);
  1340. adventureInt->minimap.setAIRadar(true);
  1341. adventureInt->infoBar.startEnemyTurn(LOCPLINT->cb->getCurrentPlayer());
  1342. adventureInt->infoBar.showAll(screen);//force refresh on inactive object
  1343. }
  1344. void CAdvMapInt::adjustActiveness(bool aiTurnStart)
  1345. {
  1346. bool wasActive = isActive();
  1347. if(wasActive)
  1348. deactivate();
  1349. adventureInt->duringAITurn = aiTurnStart;
  1350. if(wasActive)
  1351. activate();
  1352. }
  1353. CAdventureOptions::CAdventureOptions():
  1354. CWindowObject(PLAYER_COLORED, "ADVOPTS")
  1355. {
  1356. OBJ_CONSTRUCTION_CAPTURING_ALL;
  1357. exit = new CAdventureMapButton("","",boost::bind(&CAdventureOptions::close, this), 204, 313, "IOK6432.DEF",SDLK_RETURN);
  1358. exit->assignedKeys.insert(SDLK_ESCAPE);
  1359. scenInfo = new CAdventureMapButton("","", boost::bind(&CAdventureOptions::close, this), 24, 198, "ADVINFO.DEF",SDLK_i);
  1360. scenInfo->callback += CAdventureOptions::showScenarioInfo;
  1361. //viewWorld = new CAdventureMapButton("","",boost::bind(&CGuiHandler::popIntTotally, &GH, this), 204, 313, "IOK6432.DEF",SDLK_RETURN);
  1362. puzzle = new CAdventureMapButton("","", boost::bind(&CAdventureOptions::close, this), 24, 81, "ADVPUZ.DEF");
  1363. puzzle->callback += boost::bind(&CPlayerInterface::showPuzzleMap, LOCPLINT);
  1364. dig = new CAdventureMapButton("","", boost::bind(&CAdventureOptions::close, this), 24, 139, "ADVDIG.DEF");
  1365. if(const CGHeroInstance *h = adventureInt->curHero())
  1366. dig->callback += boost::bind(&CPlayerInterface::tryDiggging, LOCPLINT, h);
  1367. else
  1368. dig->block(true);
  1369. }
  1370. void CAdventureOptions::showScenarioInfo()
  1371. {
  1372. auto campState = LOCPLINT->cb->getStartInfo()->campState;
  1373. if(campState)
  1374. {
  1375. GH.pushInt(new CBonusSelection(campState));
  1376. }
  1377. else
  1378. {
  1379. GH.pushInt(new CScenarioInfo(LOCPLINT->cb->getMapHeader(), LOCPLINT->cb->getStartInfo()));
  1380. }
  1381. }