MapReaderH3M.cpp 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438
  1. /*
  2. * MapReaderH3M.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 "MapReaderH3M.h"
  12. #include "../filesystem/CBinaryReader.h"
  13. #include "../int3.h"
  14. #include "../mapObjects/ObjectTemplate.h"
  15. VCMI_LIB_NAMESPACE_BEGIN
  16. template<>
  17. BuildingID MapReaderH3M::remapIdentifier(const BuildingID & identifier)
  18. {
  19. return identifier;
  20. }
  21. template<>
  22. GameResID MapReaderH3M::remapIdentifier(const GameResID & identifier)
  23. {
  24. return identifier;
  25. }
  26. template<>
  27. SpellID MapReaderH3M::remapIdentifier(const SpellID & identifier)
  28. {
  29. return identifier;
  30. }
  31. template<>
  32. PlayerColor MapReaderH3M::remapIdentifier(const PlayerColor & identifier)
  33. {
  34. return identifier;
  35. }
  36. template<class Identifier>
  37. Identifier MapReaderH3M::remapIdentifier(const Identifier & identifier)
  38. {
  39. return remapper.remap(identifier);
  40. }
  41. MapReaderH3M::MapReaderH3M(CInputStream * stream)
  42. : reader(std::make_unique<CBinaryReader>(stream))
  43. {
  44. }
  45. void MapReaderH3M::setFormatLevel(const MapFormatFeaturesH3M & newFeatures)
  46. {
  47. features = newFeatures;
  48. }
  49. void MapReaderH3M::setIdentifierRemapper(const MapIdentifiersH3M & newRemapper)
  50. {
  51. remapper = newRemapper;
  52. }
  53. ArtifactID MapReaderH3M::readArtifact()
  54. {
  55. ArtifactID result;
  56. if(features.levelAB)
  57. result = ArtifactID(reader->readUInt16());
  58. else
  59. result = ArtifactID(reader->readUInt8());
  60. if(result.getNum() == features.artifactIdentifierInvalid)
  61. return ArtifactID::NONE;
  62. if (result.getNum() < features.artifactsCount)
  63. return remapIdentifier(result);
  64. logGlobal->warn("Map contains invalid artifact %d. Will be removed!", result.getNum());
  65. return ArtifactID::NONE;
  66. }
  67. ArtifactID MapReaderH3M::readArtifact8()
  68. {
  69. ArtifactID result(reader->readInt8());
  70. if (result.getNum() < features.artifactsCount)
  71. return remapIdentifier(result);
  72. logGlobal->warn("Map contains invalid artifact %d. Will be removed!", result.getNum());
  73. return ArtifactID::NONE;
  74. }
  75. ArtifactID MapReaderH3M::readArtifact32()
  76. {
  77. ArtifactID result(reader->readInt32());
  78. if(result == ArtifactID::NONE)
  79. return ArtifactID::NONE;
  80. if (result.getNum() < features.artifactsCount)
  81. return remapIdentifier(result);
  82. logGlobal->warn("Map contains invalid artifact %d. Will be removed!", result.getNum());
  83. return ArtifactID::NONE;
  84. }
  85. HeroTypeID MapReaderH3M::readHero()
  86. {
  87. HeroTypeID result(reader->readUInt8());
  88. if(result.getNum() == features.heroIdentifierInvalid)
  89. return HeroTypeID(-1);
  90. assert(result.getNum() < features.heroesCount);
  91. return remapIdentifier(result);
  92. }
  93. HeroTypeID MapReaderH3M::readHeroPortrait()
  94. {
  95. HeroTypeID result(reader->readUInt8());
  96. if(result.getNum() == features.heroIdentifierInvalid)
  97. return HeroTypeID::NONE;
  98. if (result.getNum() >= features.heroesPortraitsCount)
  99. {
  100. logGlobal->warn("Map contains invalid hero portrait ID %d. Will be reset!", result.getNum() );
  101. return HeroTypeID::NONE;
  102. }
  103. return remapper.remapPortrait(result);
  104. }
  105. CreatureID MapReaderH3M::readCreature()
  106. {
  107. CreatureID result;
  108. if(features.levelAB)
  109. result = CreatureID(reader->readUInt16());
  110. else
  111. result = CreatureID(reader->readUInt8());
  112. if(result.getNum() == features.creatureIdentifierInvalid)
  113. return CreatureID::NONE;
  114. if(result.getNum() < features.creaturesCount)
  115. return remapIdentifier(result);;
  116. // this may be random creature in army/town, to be randomized later
  117. CreatureID randomIndex(result.getNum() - features.creatureIdentifierInvalid - 1);
  118. assert(randomIndex < CreatureID::NONE);
  119. if (randomIndex.getNum() > -16)
  120. return randomIndex;
  121. logGlobal->warn("Map contains invalid creature %d. Will be removed!", result.getNum());
  122. return CreatureID::NONE;
  123. }
  124. TerrainId MapReaderH3M::readTerrain()
  125. {
  126. TerrainId result(readUInt8());
  127. assert(result.getNum() < features.terrainsCount);
  128. return remapIdentifier(result);;
  129. }
  130. RoadId MapReaderH3M::readRoad()
  131. {
  132. RoadId result(readInt8());
  133. assert(result.getNum() <= features.roadsCount);
  134. return result;
  135. }
  136. RiverId MapReaderH3M::readRiver()
  137. {
  138. RiverId result(readInt8());
  139. assert(result.getNum() <= features.riversCount);
  140. return result;
  141. }
  142. SecondarySkill MapReaderH3M::readSkill()
  143. {
  144. SecondarySkill result(readUInt8());
  145. assert(result.getNum() < features.skillsCount);
  146. return remapIdentifier(result);;
  147. }
  148. SpellID MapReaderH3M::readSpell()
  149. {
  150. SpellID result(readUInt8());
  151. if(result.getNum() == features.spellIdentifierInvalid)
  152. return SpellID::NONE;
  153. if(result.getNum() == features.spellIdentifierInvalid - 1)
  154. return SpellID::PRESET;
  155. assert(result.getNum() < features.spellsCount);
  156. return remapIdentifier(result);;
  157. }
  158. SpellID MapReaderH3M::readSpell32()
  159. {
  160. SpellID result(readInt32());
  161. if(result.getNum() == features.spellIdentifierInvalid)
  162. return SpellID::NONE;
  163. assert(result.getNum() < features.spellsCount);
  164. return result;
  165. }
  166. GameResID MapReaderH3M::readGameResID()
  167. {
  168. GameResID result(readInt8());
  169. assert(result.getNum() < features.resourcesCount);
  170. return result;
  171. }
  172. PlayerColor MapReaderH3M::readPlayer()
  173. {
  174. uint8_t value = readUInt8();
  175. if (value == 255)
  176. return PlayerColor::NEUTRAL;
  177. if (value >= PlayerColor::PLAYER_LIMIT_I)
  178. {
  179. logGlobal->warn("Map contains invalid player ID %d. Will be reset!", value );
  180. return PlayerColor::NEUTRAL;
  181. }
  182. return PlayerColor(value);
  183. }
  184. PlayerColor MapReaderH3M::readPlayer32()
  185. {
  186. uint32_t value = readUInt32();
  187. if (value == 255)
  188. return PlayerColor::NEUTRAL;
  189. if (value >= PlayerColor::PLAYER_LIMIT_I)
  190. {
  191. logGlobal->warn("Map contains invalid player ID %d. Will be reset!", value );
  192. return PlayerColor::NEUTRAL;
  193. }
  194. return PlayerColor(value);
  195. }
  196. void MapReaderH3M::readBitmaskBuildings(std::set<BuildingID> & dest, std::optional<FactionID> faction)
  197. {
  198. std::set<BuildingID> h3m;
  199. readBitmask(h3m, features.buildingsBytes, features.buildingsCount, false);
  200. for (auto const & h3mEntry : h3m)
  201. {
  202. BuildingID mapped = remapper.remapBuilding(faction, h3mEntry);
  203. if (mapped != BuildingID::NONE) // artifact merchant may be set in random town, but not present in actual town
  204. dest.insert(mapped);
  205. }
  206. }
  207. void MapReaderH3M::readBitmaskFactions(std::set<FactionID> & dest, bool invert)
  208. {
  209. readBitmask(dest, features.factionsBytes, features.factionsCount, invert);
  210. }
  211. void MapReaderH3M::readBitmaskPlayers(std::set<PlayerColor> & dest, bool invert)
  212. {
  213. readBitmask(dest, 1, 8, invert);
  214. }
  215. void MapReaderH3M::readBitmaskResources(std::set<GameResID> & dest, bool invert)
  216. {
  217. readBitmask(dest, features.resourcesBytes, features.resourcesCount, invert);
  218. }
  219. void MapReaderH3M::readBitmaskHeroClassesSized(std::set<HeroClassID> & dest, bool invert)
  220. {
  221. uint32_t classesCount = reader->readUInt32();
  222. uint32_t classesBytes = (classesCount + 7) / 8;
  223. readBitmask(dest, classesBytes, classesCount, invert);
  224. }
  225. void MapReaderH3M::readBitmaskHeroes(std::set<HeroTypeID> & dest, bool invert)
  226. {
  227. readBitmask<HeroTypeID>(dest, features.heroesBytes, features.heroesCount, invert);
  228. }
  229. void MapReaderH3M::readBitmaskHeroesSized(std::set<HeroTypeID> & dest, bool invert)
  230. {
  231. uint32_t heroesCount = readUInt32();
  232. uint32_t heroesBytes = (heroesCount + 7) / 8;
  233. assert(heroesCount <= features.heroesCount);
  234. readBitmask<HeroTypeID>(dest, heroesBytes, heroesCount, invert);
  235. }
  236. void MapReaderH3M::readBitmaskArtifacts(std::set<ArtifactID> &dest, bool invert)
  237. {
  238. readBitmask<ArtifactID>(dest, features.artifactsBytes, features.artifactsCount, invert);
  239. }
  240. void MapReaderH3M::readBitmaskArtifactsSized(std::set<ArtifactID> &dest, bool invert)
  241. {
  242. uint32_t artifactsCount = reader->readUInt32();
  243. uint32_t artifactsBytes = (artifactsCount + 7) / 8;
  244. assert(artifactsCount <= features.artifactsCount);
  245. readBitmask<ArtifactID>(dest, artifactsBytes, artifactsCount, invert);
  246. }
  247. void MapReaderH3M::readBitmaskSpells(std::set<SpellID> & dest, bool invert)
  248. {
  249. readBitmask(dest, features.spellsBytes, features.spellsCount, invert);
  250. }
  251. void MapReaderH3M::readBitmaskSkills(std::set<SecondarySkill> & dest, bool invert)
  252. {
  253. readBitmask(dest, features.skillsBytes, features.skillsCount, invert);
  254. }
  255. template<class Identifier>
  256. void MapReaderH3M::readBitmask(std::set<Identifier> & dest, int bytesToRead, int objectsToRead, bool invert)
  257. {
  258. for(int byte = 0; byte < bytesToRead; ++byte)
  259. {
  260. const ui8 mask = reader->readUInt8();
  261. for(int bit = 0; bit < 8; ++bit)
  262. {
  263. if(byte * 8 + bit < objectsToRead)
  264. {
  265. const size_t index = byte * 8 + bit;
  266. const bool flag = mask & (1 << bit);
  267. const bool result = (flag != invert);
  268. Identifier h3mID(index);
  269. Identifier vcmiID = remapIdentifier(h3mID);
  270. if (result)
  271. dest.insert(vcmiID);
  272. }
  273. }
  274. }
  275. }
  276. int3 MapReaderH3M::readInt3()
  277. {
  278. int3 p;
  279. p.x = reader->readUInt8();
  280. p.y = reader->readUInt8();
  281. p.z = reader->readUInt8();
  282. return p;
  283. }
  284. std::shared_ptr<ObjectTemplate> MapReaderH3M::readObjectTemplate()
  285. {
  286. auto tmpl = std::make_shared<ObjectTemplate>();
  287. tmpl->readMap(*reader);
  288. remapper.remapTemplate(*tmpl);
  289. return tmpl;
  290. }
  291. void MapReaderH3M::skipUnused(size_t amount)
  292. {
  293. reader->skip(amount);
  294. }
  295. void MapReaderH3M::skipZero(size_t amount)
  296. {
  297. #ifdef NDEBUG
  298. skipUnused(amount);
  299. #else
  300. for(size_t i = 0; i < amount; ++i)
  301. {
  302. uint8_t value = reader->readUInt8();
  303. assert(value == 0);
  304. }
  305. #endif
  306. }
  307. void MapReaderH3M::readResourses(TResources & resources)
  308. {
  309. for(int x = 0; x < features.resourcesCount; ++x)
  310. resources[x] = reader->readInt32();
  311. }
  312. bool MapReaderH3M::readBool()
  313. {
  314. uint8_t result = readUInt8();
  315. assert(result == 0 || result == 1);
  316. return result != 0;
  317. }
  318. ui8 MapReaderH3M::readUInt8()
  319. {
  320. return reader->readUInt8();
  321. }
  322. si8 MapReaderH3M::readInt8()
  323. {
  324. return reader->readInt8();
  325. }
  326. ui16 MapReaderH3M::readUInt16()
  327. {
  328. return reader->readUInt16();
  329. }
  330. si16 MapReaderH3M::readInt16()
  331. {
  332. return reader->readInt16();
  333. }
  334. ui32 MapReaderH3M::readUInt32()
  335. {
  336. return reader->readUInt32();
  337. }
  338. si32 MapReaderH3M::readInt32()
  339. {
  340. return reader->readInt32();
  341. }
  342. std::string MapReaderH3M::readBaseString()
  343. {
  344. return reader->readBaseString();
  345. }
  346. CBinaryReader & MapReaderH3M::getInternalReader()
  347. {
  348. return *reader;
  349. }
  350. VCMI_LIB_NAMESPACE_END