Graphics.cpp 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787
  1. #include "../stdafx.h"
  2. #include "Graphics.h"
  3. #include "CDefHandler.h"
  4. #include "SDL_Extensions.h"
  5. #include <SDL_ttf.h>
  6. #include <boost/assign/std/vector.hpp>
  7. #include <sstream>
  8. #include <iomanip>
  9. #include <boost/thread.hpp>
  10. #include <boost/function.hpp>
  11. #include <boost/bind.hpp>
  12. #include <boost/foreach.hpp>
  13. #include "../CThreadHelper.h"
  14. #include "CGameInfo.h"
  15. #include "../lib/CLodHandler.h"
  16. #include "../lib/VCMI_Lib.h"
  17. #include "../CCallback.h"
  18. #include "../lib/CTownHandler.h"
  19. #include "../lib/CObjectHandler.h"
  20. #include "../lib/CGeneralTextHandler.h"
  21. #include "../lib/CCreatureHandler.h"
  22. #include "CBitmapHandler.h"
  23. #include "../lib/CObjectHandler.h"
  24. #include "../lib/CDefObjInfoHandler.h"
  25. #include "../lib/CGameState.h"
  26. #include "../lib/JsonNode.h"
  27. using namespace boost::assign;
  28. using namespace CSDL_Ext;
  29. #ifdef min
  30. #undef min
  31. #endif
  32. #ifdef max
  33. #undef max
  34. #endif
  35. /*
  36. * Graphics.cpp, part of VCMI engine
  37. *
  38. * Authors: listed in file AUTHORS in main folder
  39. *
  40. * License: GNU General Public License v2.0 or later
  41. * Full text of license available in license.txt file, in main folder
  42. *
  43. */
  44. Graphics * graphics = NULL;
  45. SDL_Surface * Graphics::drawHeroInfoWin(const InfoAboutHero &curh)
  46. {
  47. char buf[15];
  48. blueToPlayersAdv(hInfo,curh.owner);
  49. SDL_Surface * ret = SDL_DisplayFormat(hInfo);
  50. SDL_SetColorKey(ret,SDL_SRCCOLORKEY,SDL_MapRGB(ret->format,0,255,255));
  51. printAt(curh.name,75,13,FONT_SMALL,zwykly,ret); //name
  52. blitAt(graphics->portraitLarge[curh.portrait],11,12,ret); //portrait
  53. //army
  54. for (ArmyDescriptor::const_iterator i = curh.army.begin(); i!=curh.army.end();i++)
  55. {
  56. blitAt(graphics->smallImgs[i->second.type->idNumber],slotsPos[(*i).first].first+1,slotsPos[(*i).first].second+1,ret);
  57. if(curh.details)
  58. {
  59. SDL_itoa((*i).second.count,buf,10);
  60. printAtMiddle(buf,slotsPos[(*i).first].first+17,slotsPos[(*i).first].second+41,FONT_TINY,zwykly,ret);
  61. }
  62. else
  63. {
  64. printAtMiddle(VLC->generaltexth->arraytxt[174 + 3*(i->second.count)],slotsPos[(*i).first].first+17,slotsPos[(*i).first].second+41,FONT_TINY,zwykly,ret);
  65. }
  66. }
  67. if(curh.details)
  68. {
  69. for (int i = 0; i < PRIMARY_SKILLS; i++)
  70. {
  71. SDL_itoa(curh.details->primskills[i], buf, 10);
  72. printAtMiddle(buf,84+28*i,70,FONT_SMALL,zwykly,ret);
  73. }
  74. //mana points
  75. SDL_itoa(curh.details->mana,buf,10);
  76. printAtMiddle(buf,167,108,FONT_TINY,zwykly,ret);
  77. blitAt(morale22->ourImages[curh.details->morale+3].bitmap,14,84,ret); //luck
  78. blitAt(luck22->ourImages[curh.details->morale+3].bitmap,14,101,ret); //morale
  79. }
  80. return ret;
  81. }
  82. SDL_Surface * Graphics::drawHeroInfoWin(const CGHeroInstance * curh)
  83. {
  84. InfoAboutHero iah;
  85. iah.initFromHero(curh, true);
  86. return drawHeroInfoWin(iah);
  87. }
  88. SDL_Surface * Graphics::drawTownInfoWin(const CGTownInstance * curh)
  89. {
  90. InfoAboutTown iah;
  91. iah.initFromTown(curh, true);
  92. return drawTownInfoWin(iah);
  93. }
  94. SDL_Surface * Graphics::drawTownInfoWin( const InfoAboutTown & curh )
  95. {
  96. char buf[10];
  97. blueToPlayersAdv(tInfo,curh.owner);
  98. SDL_Surface * ret = SDL_DisplayFormat(tInfo);
  99. SDL_SetColorKey(ret,SDL_SRCCOLORKEY,SDL_MapRGB(ret->format,0,255,255));
  100. printAt(curh.name,75,12,FONT_SMALL,zwykly,ret); //name
  101. int pom = curh.fortLevel - 1; if(pom<0) pom = 3; //fort pic id
  102. blitAt(forts->ourImages[pom].bitmap,115,42,ret); //fort
  103. for (ArmyDescriptor::const_iterator i=curh.army.begin(); i!=curh.army.end();i++)
  104. {
  105. //if(!i->second.second)
  106. // continue;
  107. blitAt(graphics->smallImgs[(*i).second.type->idNumber],slotsPos[(*i).first].first+1,slotsPos[(*i).first].second+1,ret);
  108. if(curh.details)
  109. {
  110. // Show exact creature amount.
  111. SDL_itoa((*i).second.count,buf,10);
  112. printAtMiddle(buf,slotsPos[(*i).first].first+17,slotsPos[(*i).first].second+41,FONT_TINY,zwykly,ret);
  113. }
  114. else
  115. {
  116. // Show only a rough amount for creature stacks.
  117. // TODO: Deal with case when no information at all about size shold be presented.
  118. std::string roughAmount = curh.obj->getRoughAmount(i->first);
  119. printAtMiddle(roughAmount,slotsPos[(*i).first].first+17,slotsPos[(*i).first].second+41,FONT_TINY,zwykly,ret);
  120. }
  121. }
  122. //blit town icon
  123. if (curh.tType) {
  124. pom = curh.tType->typeID*2;
  125. if (!curh.fortLevel)
  126. pom += F_NUMBER*2;
  127. if(curh.built)
  128. pom++;
  129. blitAt(bigTownPic->ourImages[pom].bitmap,13,13,ret);
  130. }
  131. if(curh.details)
  132. {
  133. //hall level icon
  134. if((pom=curh.details->hallLevel) >= 0)
  135. blitAt(halls->ourImages[pom].bitmap, 77, 42, ret);
  136. if (curh.details->goldIncome >= 0) {
  137. SDL_itoa(curh.details->goldIncome, buf, 10); //gold income
  138. printAtMiddle(buf, 167, 70, FONT_TINY, zwykly, ret);
  139. }
  140. if(curh.details->garrisonedHero) //garrisoned hero icon
  141. blitAt(graphics->heroInGarrison,158,87,ret);
  142. }
  143. return ret;
  144. }
  145. void Graphics::loadPaletteAndColors()
  146. {
  147. std::string pals = bitmaph->getTextFile("PLAYERS.PAL", FILE_OTHER);
  148. playerColorPalette = new SDL_Color[256];
  149. neutralColor = new SDL_Color;
  150. playerColors = new SDL_Color[PLAYER_LIMIT];
  151. int startPoint = 24; //beginning byte; used to read
  152. for(int i=0; i<256; ++i)
  153. {
  154. SDL_Color col;
  155. col.r = pals[startPoint++];
  156. col.g = pals[startPoint++];
  157. col.b = pals[startPoint++];
  158. col.unused = pals[startPoint++];
  159. playerColorPalette[i] = col;
  160. }
  161. neutralColorPalette = new SDL_Color[32];
  162. std::ifstream ncp;
  163. ncp.open(DATA_DIR "/config/NEUTRAL.PAL", std::ios::binary);
  164. for(int i=0; i<32; ++i)
  165. {
  166. ncp.read((char*)&neutralColorPalette[i].r,1);
  167. ncp.read((char*)&neutralColorPalette[i].g,1);
  168. ncp.read((char*)&neutralColorPalette[i].b,1);
  169. ncp.read((char*)&neutralColorPalette[i].unused,1);
  170. }
  171. //colors initialization
  172. int3 kolory[] = {int3(0xff,0,0),int3(0x31,0x52,0xff),int3(0x9c,0x73,0x52),int3(0x42,0x94,0x29),
  173. int3(0xff,0x84,0x0),int3(0x8c,0x29,0xa5),int3(0x09,0x9c,0xa5),int3(0xc6,0x7b,0x8c)};
  174. for(int i=0;i<8;i++)
  175. {
  176. playerColors[i].r = kolory[i].x;
  177. playerColors[i].g = kolory[i].y;
  178. playerColors[i].b = kolory[i].z;
  179. playerColors[i].unused = 0;
  180. }
  181. neutralColor->r = 0x84; neutralColor->g = 0x84; neutralColor->b = 0x84; neutralColor->unused = 0x0;//gray
  182. const JsonNode config(DATA_DIR "/config/town_pictures.json");
  183. BOOST_FOREACH(const JsonNode &p, config["town_pictures"].Vector()) {
  184. townBgs.push_back(p["town_background"].String());
  185. guildBgs.push_back(p["guild_background"].String());
  186. buildingPics.push_back(p["building_picture"].String());
  187. }
  188. }
  189. void Graphics::initializeBattleGraphics()
  190. {
  191. const JsonNode config(DATA_DIR "/config/battles_graphics.json");
  192. // Reserve enough space for the terrains
  193. // TODO: there should be a method to count the number of elements
  194. int idx = 0;
  195. BOOST_FOREACH(const JsonNode &t, config["backgrounds"].Vector()) {
  196. idx++;
  197. }
  198. battleBacks.resize(idx);
  199. idx = 0;
  200. BOOST_FOREACH(const JsonNode &t, config["backgrounds"].Vector()) {
  201. battleBacks[idx].push_back(t.String());
  202. idx++;
  203. }
  204. //initializing battle hero animation
  205. idx = 0;
  206. BOOST_FOREACH(const JsonNode &h, config["heroes"].Vector()) {
  207. idx++;
  208. }
  209. battleHeroes.resize(idx);
  210. idx = 0;
  211. BOOST_FOREACH(const JsonNode &h, config["heroes"].Vector()) {
  212. battleHeroes[idx] = h.String();
  213. idx ++;
  214. }
  215. //initialization of AC->def name mapping
  216. BOOST_FOREACH(const JsonNode &ac, config["ac_mapping"].Vector()) {
  217. int ACid = ac["id"].Float();
  218. std::vector< std::string > toAdd;
  219. BOOST_FOREACH(const JsonNode &defname, ac["defnames"].Vector()) {
  220. toAdd.push_back(defname.String());
  221. }
  222. battleACToDef[ACid] = toAdd;
  223. }
  224. spellEffectsPics = CDefHandler::giveDefEss("SpellInt.def");
  225. }
  226. Graphics::Graphics()
  227. {
  228. slotsPos.push_back(std::pair<int,int>(44,82));
  229. slotsPos.push_back(std::pair<int,int>(80,82));
  230. slotsPos.push_back(std::pair<int,int>(116,82));
  231. slotsPos.push_back(std::pair<int,int>(26,131));
  232. slotsPos.push_back(std::pair<int,int>(62,131));
  233. slotsPos.push_back(std::pair<int,int>(98,131));
  234. slotsPos.push_back(std::pair<int,int>(134,131));
  235. CDefHandler *smi, *smi2;
  236. std::vector<Task> tasks; //preparing list of graphics to load
  237. tasks += boost::bind(&Graphics::loadFonts,this);
  238. tasks += boost::bind(&Graphics::loadTrueType,this);
  239. tasks += boost::bind(&Graphics::loadPaletteAndColors,this);
  240. tasks += boost::bind(&Graphics::loadHeroFlags,this);
  241. tasks += boost::bind(&Graphics::loadHeroPortraits,this);
  242. tasks += boost::bind(&Graphics::initializeBattleGraphics,this);
  243. tasks += boost::bind(&Graphics::loadWallPositions,this);
  244. tasks += boost::bind(&Graphics::loadErmuToPicture,this);
  245. tasks += GET_SURFACE(hInfo,"HEROQVBK.bmp");
  246. tasks += GET_SURFACE(tInfo,"TOWNQVBK.bmp");
  247. tasks += GET_SURFACE(heroInGarrison,"TOWNQKGH.bmp");
  248. tasks += GET_DEF_ESS(artDefs,"ARTIFACT.DEF");
  249. tasks += GET_DEF_ESS(forts,"ITMCLS.DEF");
  250. tasks += GET_DEF_ESS(luck22,"ILCK22.DEF");
  251. tasks += GET_DEF_ESS(luck30,"ILCK30.DEF");
  252. tasks += GET_DEF_ESS(luck42,"ILCK42.DEF");
  253. tasks += GET_DEF_ESS(luck82,"ILCK82.DEF");
  254. tasks += GET_DEF_ESS(morale22,"IMRL22.DEF");
  255. tasks += GET_DEF_ESS(morale30,"IMRL30.DEF");
  256. tasks += GET_DEF_ESS(morale42,"IMRL42.DEF");
  257. tasks += GET_DEF_ESS(morale82,"IMRL82.DEF");
  258. tasks += GET_DEF_ESS(halls,"ITMTLS.DEF");
  259. tasks += GET_DEF_ESS(bigTownPic,"ITPT.DEF");
  260. tasks += GET_DEF_ESS(pskillsb,"PSKILL.DEF");
  261. tasks += GET_DEF_ESS(pskillsm,"PSKIL42.DEF");
  262. tasks += GET_DEF_ESS(pskillst,"PSKIL32.DEF");
  263. tasks += GET_DEF_ESS(resources,"RESOUR82.DEF");
  264. tasks += GET_DEF_ESS(un32,"UN32.DEF");
  265. tasks += GET_DEF_ESS(un44,"UN44.DEF");
  266. tasks += GET_DEF_ESS(smallIcons,"ITPA.DEF");
  267. tasks += GET_DEF_ESS(resources32,"RESOURCE.DEF");
  268. tasks += GET_DEF(smi,"CPRSMALL.DEF");
  269. tasks += GET_DEF(smi2,"TWCRPORT.DEF");
  270. tasks += GET_DEF_ESS(flags,"CREST58.DEF");
  271. tasks += GET_DEF_ESS(abils32,"SECSK32.DEF");
  272. tasks += GET_DEF_ESS(abils44,"SECSKILL.DEF");
  273. tasks += GET_DEF_ESS(abils82,"SECSK82.DEF");
  274. tasks += GET_DEF_ESS(spellscr,"SPELLSCR.DEF");
  275. tasks += GET_DEF_ESS(heroMoveArrows,"ADAG.DEF");
  276. const JsonNode config(DATA_DIR "/config/creature_backgrounds.json");
  277. BOOST_FOREACH(const JsonNode &b, config["backgrounds"].Vector()) {
  278. const int id = b["id"].Float();
  279. tasks += GET_SURFACE(backgrounds[id], b["bg130"].String());
  280. tasks += GET_SURFACE(backgroundsm[id], b["bg120"].String());
  281. }
  282. CThreadHelper th(&tasks,std::max((unsigned int)1,boost::thread::hardware_concurrency()));
  283. th.run();
  284. for(size_t y=0; y < heroMoveArrows->ourImages.size(); ++y)
  285. {
  286. CSDL_Ext::alphaTransform(heroMoveArrows->ourImages[y].bitmap);
  287. }
  288. //handling 32x32px imgs
  289. smi->notFreeImgs = true;
  290. for (size_t i=0; i<smi->ourImages.size(); ++i)
  291. {
  292. smallImgs[i-2] = smi->ourImages[i].bitmap;
  293. }
  294. delete smi;
  295. smi2->notFreeImgs = true;
  296. for (size_t i=0; i<smi2->ourImages.size(); ++i)
  297. {
  298. bigImgs[i-2] = smi2->ourImages[i].bitmap;
  299. }
  300. delete smi2;
  301. }
  302. void Graphics::loadHeroPortraits()
  303. {
  304. const JsonNode config(DATA_DIR "/config/portraits.json");
  305. const JsonVector &portraits_vec = config["hero_portrait"].Vector();
  306. for (JsonVector::const_iterator it = portraits_vec.begin(); it!=portraits_vec.end(); ++it) {
  307. const JsonNode &portrait_node = *it;
  308. std::string filename = portrait_node["filename"].String();
  309. /* Small portrait. */
  310. portraitSmall.push_back(BitmapHandler::loadBitmap(filename));
  311. /* Large portrait. Alter the filename. Size letter is usually
  312. * third one, but there are exceptions and it should fix the
  313. * problem. */
  314. for (int ff=0; ff<filename.size(); ++ff)
  315. {
  316. if (filename[ff]=='S') {
  317. filename[ff]='L';
  318. break;
  319. }
  320. }
  321. portraitLarge.push_back(BitmapHandler::loadBitmap(filename));
  322. SDL_SetColorKey(portraitLarge[portraitLarge.size()-1],SDL_SRCCOLORKEY,SDL_MapRGB(portraitLarge[portraitLarge.size()-1]->format,0,255,255));
  323. }
  324. }
  325. void Graphics::loadWallPositions()
  326. {
  327. const JsonNode config(DATA_DIR "/config/wall_pos.json");
  328. BOOST_FOREACH(const JsonNode &town, config["towns"].Vector()) {
  329. int townID = town["id"].Float();
  330. BOOST_FOREACH(const JsonNode &coords, town["pos"].Vector()) {
  331. Point pt(coords["x"].Float(), coords["y"].Float());
  332. wallPositions[townID].push_back(pt);
  333. }
  334. assert(wallPositions[townID].size() == 21);
  335. }
  336. }
  337. void Graphics::loadHeroAnims()
  338. {
  339. std::vector<std::pair<int,int> > rotations; //first - group number to be rotated1, second - group number after rotation1
  340. rotations += std::make_pair(6,10), std::make_pair(7,11), std::make_pair(8,12), std::make_pair(1,13),
  341. std::make_pair(2,14), std::make_pair(3,15);
  342. for(size_t i=0; i<F_NUMBER * 2; ++i)
  343. {
  344. std::ostringstream nm;
  345. nm << "AH" << std::setw(2) << std::setfill('0') << i << "_.DEF";
  346. loadHeroAnim(nm.str(), rotations, &Graphics::heroAnims);
  347. std::string name = nm.str();
  348. }
  349. loadHeroAnim("AB01_.DEF", rotations, &Graphics::boatAnims);
  350. loadHeroAnim("AB02_.DEF", rotations, &Graphics::boatAnims);
  351. loadHeroAnim("AB03_.DEF", rotations, &Graphics::boatAnims);
  352. }
  353. void Graphics::loadHeroAnim( const std::string &name, const std::vector<std::pair<int,int> > &rotations, std::vector<CDefEssential *> Graphics::*dst )
  354. {
  355. CDefEssential *anim = CDefHandler::giveDefEss(name);
  356. (this->*dst).push_back(anim);
  357. int pom = 0; //how many groups has been rotated
  358. for(int o=7; pom<6; ++o)
  359. {
  360. for(int p=0;p<6;p++)
  361. {
  362. if(anim->ourImages[o].groupNumber == rotations[p].first)
  363. {
  364. for(int e=0; e<8; ++e)
  365. {
  366. Cimage nci;
  367. nci.bitmap = CSDL_Ext::rotate01(anim->ourImages[o+e].bitmap);
  368. nci.groupNumber = rotations[p].second;
  369. nci.imName = std::string();
  370. anim->ourImages.push_back(nci);
  371. if(pom>2) //we need only one frame for groups 13/14/15
  372. break;
  373. }
  374. if(pom<3) //there are eight frames of animtion of groups 6/7/8 so for speed we'll skip them
  375. o+=8;
  376. else //there is only one frame of 1/2/3
  377. o+=1;
  378. ++pom;
  379. if(p==2 && pom<4) //group1 starts at index 1
  380. o = 1;
  381. }
  382. }
  383. }
  384. for(size_t ff=0; ff<anim->ourImages.size(); ++ff)
  385. {
  386. CSDL_Ext::alphaTransform(anim->ourImages[ff].bitmap);
  387. }
  388. }
  389. void Graphics::loadHeroFlags(std::pair<std::vector<CDefEssential *> Graphics::*, std::vector<const char *> > &pr, bool mode)
  390. {
  391. for(int i=0;i<8;i++)
  392. (this->*pr.first).push_back(CDefHandler::giveDefEss(pr.second[i]));
  393. std::vector<std::pair<int,int> > rotations; //first - group number to be rotated1, second - group number after rotation1
  394. rotations += std::make_pair(6,10), std::make_pair(7,11), std::make_pair(8,12);
  395. for(int q=0; q<8; ++q)
  396. {
  397. std::vector<Cimage> &curImgs = (this->*pr.first)[q]->ourImages;
  398. for(size_t o=0; o<curImgs.size(); ++o)
  399. {
  400. for(size_t p=0; p<rotations.size(); p++)
  401. {
  402. if(curImgs[o].groupNumber==rotations[p].first)
  403. {
  404. for(int e=0; e<8; ++e)
  405. {
  406. Cimage nci;
  407. nci.bitmap = CSDL_Ext::rotate01(curImgs[o+e].bitmap);
  408. nci.groupNumber = rotations[p].second;
  409. nci.imName = std::string();
  410. curImgs.push_back(nci);
  411. }
  412. o+=8;
  413. }
  414. }
  415. }
  416. if (mode)
  417. {
  418. for(size_t o=0; o<curImgs.size(); ++o)
  419. {
  420. if(curImgs[o].groupNumber==1 || curImgs[o].groupNumber==2 || curImgs[o].groupNumber==3)
  421. {
  422. for(int e=0; e<8; ++e)
  423. {
  424. Cimage nci;
  425. nci.bitmap = CSDL_Ext::rotate01(curImgs[o+e].bitmap);
  426. nci.groupNumber = 12 + curImgs[o].groupNumber;
  427. nci.imName = std::string();
  428. curImgs.push_back(nci);
  429. }
  430. o+=8;
  431. }
  432. }
  433. }
  434. for(size_t ff=0; ff<curImgs.size(); ++ff)
  435. {
  436. SDL_SetColorKey(curImgs[ff].bitmap, SDL_SRCCOLORKEY,
  437. SDL_MapRGB(curImgs[ff].bitmap->format, 0, 255, 255)
  438. );
  439. }
  440. }
  441. }
  442. void Graphics::loadHeroFlags()
  443. {
  444. using namespace boost::assign;
  445. timeHandler th;
  446. std::pair<std::vector<CDefEssential *> Graphics::*, std::vector<const char *> > pr[4];
  447. pr[0].first = &Graphics::flags1;
  448. pr[0].second+=("ABF01L.DEF"),("ABF01G.DEF"),("ABF01R.DEF"),("ABF01D.DEF"),("ABF01B.DEF"),
  449. ("ABF01P.DEF"),("ABF01W.DEF"),("ABF01K.DEF");
  450. pr[1].first = &Graphics::flags2;
  451. pr[1].second+=("ABF02L.DEF"),("ABF02G.DEF"),("ABF02R.DEF"),("ABF02D.DEF"),("ABF02B.DEF"),
  452. ("ABF02P.DEF"),("ABF02W.DEF"),("ABF02K.DEF");
  453. pr[2].first = &Graphics::flags3;
  454. pr[2].second+=("ABF03L.DEF"),("ABF03G.DEF"),("ABF03R.DEF"),("ABF03D.DEF"),("ABF03B.DEF"),
  455. ("ABF03P.DEF"),("ABF03W.DEF"),("ABF03K.DEF");
  456. pr[3].first = &Graphics::flags4;
  457. pr[3].second+=("AF00.DEF"),("AF01.DEF"),("AF02.DEF"),("AF03.DEF"),("AF04.DEF"),
  458. ("AF05.DEF"),("AF06.DEF"),("AF07.DEF");
  459. boost::thread_group grupa;
  460. for(int g=3; g>=0; --g)
  461. {
  462. grupa.create_thread(boost::bind(&Graphics::loadHeroFlags,this,boost::ref(pr[g]),true));
  463. }
  464. grupa.join_all();
  465. tlog0 << "Loading and transforming heroes' flags: "<<th.getDif()<<std::endl;
  466. }
  467. SDL_Surface * Graphics::getPic(int ID, bool fort, bool builded)
  468. {
  469. if (ID==-1)
  470. return smallIcons->ourImages[0].bitmap;
  471. else if (ID==-2)
  472. return smallIcons->ourImages[1].bitmap;
  473. else if (ID==-3)
  474. return smallIcons->ourImages[2+F_NUMBER*4].bitmap;
  475. else if (ID>F_NUMBER || ID<-3)
  476. #ifndef __GNUC__
  477. throw new std::exception("Invalid ID");
  478. #else
  479. throw new std::exception();
  480. #endif
  481. else
  482. {
  483. int pom = 3;
  484. if(!fort)
  485. pom+=F_NUMBER*2;
  486. pom += ID*2;
  487. if (!builded)
  488. pom--;
  489. return smallIcons->ourImages[pom].bitmap;
  490. }
  491. }
  492. void Graphics::blueToPlayersAdv(SDL_Surface * sur, int player)
  493. {
  494. // if(player==1) //it is actually blue...
  495. // return;
  496. if(sur->format->BitsPerPixel == 8)
  497. {
  498. SDL_Color *palette = NULL;
  499. if(player < PLAYER_LIMIT && player >= 0)
  500. {
  501. palette = playerColorPalette + 32*player;
  502. }
  503. else if(player == 255 || player == -1)
  504. {
  505. palette = neutralColorPalette;
  506. }
  507. else
  508. {
  509. tlog1 << "Wrong player id in blueToPlayersAdv (" << player << ")!\n";
  510. return;
  511. }
  512. SDL_SetColors(sur, palette, 224, 32);
  513. //for(int i=0; i<32; ++i)
  514. //{
  515. // sur->format->palette->colors[224+i] = palette[i];
  516. //}
  517. }
  518. else if(sur->format->BitsPerPixel == 24) //should never happen in general
  519. {
  520. for(int y=0; y<sur->h; ++y)
  521. {
  522. for(int x=0; x<sur->w; ++x)
  523. {
  524. Uint8* cp = (Uint8*)sur->pixels + y*sur->pitch + x*3;
  525. if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
  526. {
  527. if(cp[2]>cp[1] && cp[2]>cp[0])
  528. {
  529. std::vector<long long int> sort1;
  530. sort1.push_back(cp[0]);
  531. sort1.push_back(cp[1]);
  532. sort1.push_back(cp[2]);
  533. std::vector< std::pair<long long int, Uint8*> > sort2;
  534. sort2.push_back(std::make_pair(graphics->playerColors[player].r, &(cp[0])));
  535. sort2.push_back(std::make_pair(graphics->playerColors[player].g, &(cp[1])));
  536. sort2.push_back(std::make_pair(graphics->playerColors[player].b, &(cp[2])));
  537. std::sort(sort1.begin(), sort1.end());
  538. if(sort2[0].first>sort2[1].first)
  539. std::swap(sort2[0], sort2[1]);
  540. if(sort2[1].first>sort2[2].first)
  541. std::swap(sort2[1], sort2[2]);
  542. if(sort2[0].first>sort2[1].first)
  543. std::swap(sort2[0], sort2[1]);
  544. for(int hh=0; hh<3; ++hh)
  545. {
  546. (*sort2[hh].second) = (sort1[hh] + sort2[hh].first)/2.2;
  547. }
  548. }
  549. }
  550. else
  551. {
  552. if(
  553. (/*(mode==0) && (cp[0]>cp[1]) && (cp[0]>cp[2])) ||
  554. ((mode==1) &&*/ (cp[2]<45) && (cp[0]>80) && (cp[1]<70) && ((cp[0]-cp[1])>40))
  555. )
  556. {
  557. std::vector<long long int> sort1;
  558. sort1.push_back(cp[2]);
  559. sort1.push_back(cp[1]);
  560. sort1.push_back(cp[0]);
  561. std::vector< std::pair<long long int, Uint8*> > sort2;
  562. sort2.push_back(std::make_pair(graphics->playerColors[player].r, &(cp[2])));
  563. sort2.push_back(std::make_pair(graphics->playerColors[player].g, &(cp[1])));
  564. sort2.push_back(std::make_pair(graphics->playerColors[player].b, &(cp[0])));
  565. std::sort(sort1.begin(), sort1.end());
  566. if(sort2[0].first>sort2[1].first)
  567. std::swap(sort2[0], sort2[1]);
  568. if(sort2[1].first>sort2[2].first)
  569. std::swap(sort2[1], sort2[2]);
  570. if(sort2[0].first>sort2[1].first)
  571. std::swap(sort2[0], sort2[1]);
  572. for(int hh=0; hh<3; ++hh)
  573. {
  574. (*sort2[hh].second) = (sort1[hh]*0.8 + sort2[hh].first)/2;
  575. }
  576. }
  577. }
  578. }
  579. }
  580. }
  581. }
  582. void Graphics::loadTrueType()
  583. {
  584. bool ttfPresent = false;//was TTF initialised or not
  585. for(int i = 0; i < FONTS_NUMBER; i++)
  586. fontsTrueType[i] = NULL;
  587. std::ifstream ff(DATA_DIR "/config/fonts.txt");
  588. while(!ff.eof())
  589. {
  590. int enabl, fntID, fntSize;
  591. std::string fntName;
  592. ff >> enabl;//enabled font or not
  593. if (enabl==-1)
  594. break;//end of data
  595. ff >> fntID;//what font will be replaced
  596. ff >> fntName;//name of truetype font
  597. ff >> fntSize;//size of font
  598. if (enabl)
  599. {
  600. if (!ttfPresent)
  601. {
  602. ttfPresent = true;
  603. TTF_Init();
  604. atexit(TTF_Quit);
  605. };
  606. fntName = DATA_DIR + ( "/Fonts/" + fntName);
  607. fontsTrueType[fntID] = TTF_OpenFont(fntName.c_str(),fntSize);
  608. }
  609. }
  610. ff.close();
  611. ff.clear();
  612. }
  613. Font * Graphics::loadFont( const char * name )
  614. {
  615. int len = 0;
  616. unsigned char * hlp = bitmaph->giveFile(name, FILE_FONT, &len);
  617. if(!hlp || !len)
  618. {
  619. tlog1 << "Error: cannot load font: " << name << std::endl;
  620. return NULL;
  621. }
  622. int magic = *(const int*)hlp;
  623. if(len < 10000 || (magic != 589598 && magic != 589599))
  624. {
  625. tlog1 << "Suspicious font file (length " << len <<", fname " << name << "), logging to suspicious_" << name << ".fnt\n";
  626. std::string suspFName = "suspicious_" + std::string(name) + ".fnt";
  627. std::ofstream o(suspFName.c_str());
  628. o.write((const char*)hlp, len);
  629. }
  630. Font *ret = new Font(hlp);
  631. return ret;
  632. }
  633. void Graphics::loadFonts()
  634. {
  635. static const char *fontnames [] = {"BIGFONT.FNT", "CALLI10R.FNT", "CREDITS.FNT", "HISCORE.FNT", "MEDFONT.FNT",
  636. "SMALFONT.FNT", "TIMES08R.FNT", "TINY.FNT", "VERD10B.FNT"} ;
  637. assert(ARRAY_COUNT(fontnames) == FONTS_NUMBER);
  638. for(int i = 0; i < FONTS_NUMBER; i++)
  639. fonts[i] = loadFont(fontnames[i]);
  640. }
  641. CDefEssential * Graphics::getDef( const CGObjectInstance * obj )
  642. {
  643. return advmapobjGraphics[obj->defInfo->id][obj->defInfo->subid];
  644. }
  645. CDefEssential * Graphics::getDef( const CGDefInfo * info )
  646. {
  647. return advmapobjGraphics[info->id][info->subid];
  648. }
  649. void Graphics::loadErmuToPicture()
  650. {
  651. //loading ERMU to picture
  652. std::ifstream etp(DATA_DIR "/config/ERMU_to_picture.txt");
  653. assert(etp.is_open());
  654. for(int g=0; g<44; ++g)
  655. {
  656. for (int b=0; b<ARRAY_COUNT(ERMUtoPicture); ++b)
  657. {
  658. std::string buf;
  659. etp >> buf;
  660. ERMUtoPicture[b][g] = buf;
  661. }
  662. }
  663. etp.close();
  664. }
  665. Font::Font(unsigned char *Data)
  666. {
  667. data = Data;
  668. int i = 0;
  669. height = data[5];
  670. i = 32;
  671. for(int ci = 0; ci < 256; ci++)
  672. {
  673. chars[ci].unknown1 = readNormalNr(data, i); i+=4;
  674. chars[ci].width = readNormalNr(data, i); i+=4;
  675. chars[ci].unknown2 =readNormalNr(data, i); i+=4;
  676. //if(ci>=30)
  677. // tlog0 << ci << ". (" << (char)ci << "). Width: " << chars[ci].width << " U1/U2:" << chars[ci].unknown1 << "/" << chars[ci].unknown2 << std::endl;
  678. }
  679. for(int ci = 0; ci < 256; ci++)
  680. {
  681. chars[ci].offset = readNormalNr(data, i); i+=4;
  682. chars[ci].pixels = data + 4128 + chars[ci].offset;
  683. }
  684. }
  685. Font::~Font()
  686. {
  687. delete [] data;
  688. }
  689. int Font::getWidth(const char *text ) const
  690. {
  691. int length = std::strlen(text);
  692. int ret = 0;
  693. for(int i = 0; i < length; i++)
  694. {
  695. unsigned char c = text[i];
  696. ret += chars[c].width + chars[c].unknown1 + chars[c].unknown2;
  697. }
  698. return ret;
  699. }
  700. int Font::getCharWidth( char c ) const
  701. {
  702. const Char &C = chars[(unsigned char)c];
  703. return C.width + C.unknown1 + C.unknown2;;
  704. }
  705. /*
  706. void Font::WriteAt(const char *text, SDL_Surface *sur, int x, int y )
  707. {
  708. SDL_Surface *SDL_CreateRGBSurfaceFrom(pixels, w, h, 8, int pitch,
  709. 224, 28, 3, 0);
  710. }
  711. */