CArtHandler.cpp 28 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091
  1. /*
  2. * CArtHandler.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 "ArtifactUtils.h"
  12. #include "CGeneralTextHandler.h"
  13. #include "GameSettings.h"
  14. #include "mapObjects/MapObjects.h"
  15. #include "constants/StringConstants.h"
  16. #include "json/JsonBonus.h"
  17. #include "mapObjectConstructors/AObjectTypeHandler.h"
  18. #include "mapObjectConstructors/CObjectClassesHandler.h"
  19. #include "serializer/JsonSerializeFormat.h"
  20. // Note: list must match entries in ArtTraits.txt
  21. #define ART_POS_LIST \
  22. ART_POS(SPELLBOOK) \
  23. ART_POS(MACH4) \
  24. ART_POS(MACH3) \
  25. ART_POS(MACH2) \
  26. ART_POS(MACH1) \
  27. ART_POS(MISC5) \
  28. ART_POS(MISC4) \
  29. ART_POS(MISC3) \
  30. ART_POS(MISC2) \
  31. ART_POS(MISC1) \
  32. ART_POS(FEET) \
  33. ART_POS(LEFT_RING) \
  34. ART_POS(RIGHT_RING) \
  35. ART_POS(TORSO) \
  36. ART_POS(LEFT_HAND) \
  37. ART_POS(RIGHT_HAND) \
  38. ART_POS(NECK) \
  39. ART_POS(SHOULDERS) \
  40. ART_POS(HEAD)
  41. VCMI_LIB_NAMESPACE_BEGIN
  42. bool CCombinedArtifact::isCombined() const
  43. {
  44. return !(constituents.empty());
  45. }
  46. const std::vector<const CArtifact*> & CCombinedArtifact::getConstituents() const
  47. {
  48. return constituents;
  49. }
  50. const std::vector<const CArtifact*> & CCombinedArtifact::getPartOf() const
  51. {
  52. return partOf;
  53. }
  54. bool CScrollArtifact::isScroll() const
  55. {
  56. return static_cast<const CArtifact*>(this)->getId() == ArtifactID::SPELL_SCROLL;
  57. }
  58. bool CGrowingArtifact::isGrowing() const
  59. {
  60. return !bonusesPerLevel.empty() || !thresholdBonuses.empty();
  61. }
  62. std::vector <std::pair<ui16, Bonus>> & CGrowingArtifact::getBonusesPerLevel()
  63. {
  64. return bonusesPerLevel;
  65. }
  66. const std::vector <std::pair<ui16, Bonus>> & CGrowingArtifact::getBonusesPerLevel() const
  67. {
  68. return bonusesPerLevel;
  69. }
  70. std::vector <std::pair<ui16, Bonus>> & CGrowingArtifact::getThresholdBonuses()
  71. {
  72. return thresholdBonuses;
  73. }
  74. const std::vector <std::pair<ui16, Bonus>> & CGrowingArtifact::getThresholdBonuses() const
  75. {
  76. return thresholdBonuses;
  77. }
  78. int32_t CArtifact::getIndex() const
  79. {
  80. return id.toEnum();
  81. }
  82. int32_t CArtifact::getIconIndex() const
  83. {
  84. return iconIndex;
  85. }
  86. std::string CArtifact::getJsonKey() const
  87. {
  88. return modScope + ':' + identifier;
  89. }
  90. void CArtifact::registerIcons(const IconRegistar & cb) const
  91. {
  92. cb(getIconIndex(), 0, "ARTIFACT", image);
  93. cb(getIconIndex(), 0, "ARTIFACTLARGE", large);
  94. }
  95. ArtifactID CArtifact::getId() const
  96. {
  97. return id;
  98. }
  99. const IBonusBearer * CArtifact::getBonusBearer() const
  100. {
  101. return this;
  102. }
  103. std::string CArtifact::getDescriptionTranslated() const
  104. {
  105. return VLC->generaltexth->translate(getDescriptionTextID());
  106. }
  107. std::string CArtifact::getEventTranslated() const
  108. {
  109. return VLC->generaltexth->translate(getEventTextID());
  110. }
  111. std::string CArtifact::getNameTranslated() const
  112. {
  113. return VLC->generaltexth->translate(getNameTextID());
  114. }
  115. std::string CArtifact::getDescriptionTextID() const
  116. {
  117. return TextIdentifier("artifact", modScope, identifier, "description").get();
  118. }
  119. std::string CArtifact::getEventTextID() const
  120. {
  121. return TextIdentifier("artifact", modScope, identifier, "event").get();
  122. }
  123. std::string CArtifact::getNameTextID() const
  124. {
  125. return TextIdentifier("artifact", modScope, identifier, "name").get();
  126. }
  127. uint32_t CArtifact::getPrice() const
  128. {
  129. return price;
  130. }
  131. CreatureID CArtifact::getWarMachine() const
  132. {
  133. return warMachine;
  134. }
  135. bool CArtifact::isBig() const
  136. {
  137. return warMachine != CreatureID::NONE;
  138. }
  139. bool CArtifact::isTradable() const
  140. {
  141. switch(id.toEnum())
  142. {
  143. case ArtifactID::SPELLBOOK:
  144. case ArtifactID::GRAIL:
  145. return false;
  146. default:
  147. return !isBig();
  148. }
  149. }
  150. bool CArtifact::canBePutAt(const CArtifactSet * artSet, ArtifactPosition slot, bool assumeDestRemoved) const
  151. {
  152. auto simpleArtCanBePutAt = [this](const CArtifactSet * artSet, ArtifactPosition slot, bool assumeDestRemoved) -> bool
  153. {
  154. if(artSet->bearerType() == ArtBearer::HERO && ArtifactUtils::isSlotBackpack(slot))
  155. {
  156. if(isBig() || (!assumeDestRemoved && !ArtifactUtils::isBackpackFreeSlots(artSet)))
  157. return false;
  158. return true;
  159. }
  160. if(!vstd::contains(possibleSlots.at(artSet->bearerType()), slot))
  161. return false;
  162. return artSet->isPositionFree(slot, assumeDestRemoved);
  163. };
  164. auto artCanBePutAt = [this, simpleArtCanBePutAt](const CArtifactSet * artSet, ArtifactPosition slot, bool assumeDestRemoved) -> bool
  165. {
  166. if(isCombined())
  167. {
  168. if(!simpleArtCanBePutAt(artSet, slot, assumeDestRemoved))
  169. return false;
  170. if(ArtifactUtils::isSlotBackpack(slot))
  171. return true;
  172. CArtifactFittingSet fittingSet(artSet->bearerType());
  173. fittingSet.artifactsWorn = artSet->artifactsWorn;
  174. if(assumeDestRemoved)
  175. fittingSet.removeArtifact(slot);
  176. for(const auto art : constituents)
  177. {
  178. auto possibleSlot = ArtifactUtils::getArtAnyPosition(&fittingSet, art->getId());
  179. if(ArtifactUtils::isSlotEquipment(possibleSlot))
  180. {
  181. fittingSet.setNewArtSlot(possibleSlot, nullptr, true);
  182. }
  183. else
  184. {
  185. return false;
  186. }
  187. }
  188. return true;
  189. }
  190. else
  191. {
  192. return simpleArtCanBePutAt(artSet, slot, assumeDestRemoved);
  193. }
  194. };
  195. if(slot == ArtifactPosition::TRANSITION_POS)
  196. return true;
  197. if(slot == ArtifactPosition::FIRST_AVAILABLE)
  198. {
  199. for(const auto & slot : possibleSlots.at(artSet->bearerType()))
  200. {
  201. if(artCanBePutAt(artSet, slot, assumeDestRemoved))
  202. return true;
  203. }
  204. return artCanBePutAt(artSet, ArtifactPosition::BACKPACK_START, assumeDestRemoved);
  205. }
  206. else if(ArtifactUtils::isSlotBackpack(slot))
  207. {
  208. return artCanBePutAt(artSet, ArtifactPosition::BACKPACK_START, assumeDestRemoved);
  209. }
  210. else
  211. {
  212. return artCanBePutAt(artSet, slot, assumeDestRemoved);
  213. }
  214. }
  215. CArtifact::CArtifact()
  216. : iconIndex(ArtifactID::NONE),
  217. price(0)
  218. {
  219. setNodeType(ARTIFACT);
  220. possibleSlots[ArtBearer::HERO]; //we want to generate map entry even if it will be empty
  221. possibleSlots[ArtBearer::CREATURE]; //we want to generate map entry even if it will be empty
  222. possibleSlots[ArtBearer::COMMANDER];
  223. possibleSlots[ArtBearer::ALTAR];
  224. }
  225. //This destructor should be placed here to avoid side effects
  226. CArtifact::~CArtifact() = default;
  227. int CArtifact::getArtClassSerial() const
  228. {
  229. if(id == ArtifactID::SPELL_SCROLL)
  230. return 4;
  231. switch(aClass)
  232. {
  233. case ART_TREASURE:
  234. return 0;
  235. case ART_MINOR:
  236. return 1;
  237. case ART_MAJOR:
  238. return 2;
  239. case ART_RELIC:
  240. return 3;
  241. case ART_SPECIAL:
  242. return 5;
  243. }
  244. return -1;
  245. }
  246. std::string CArtifact::nodeName() const
  247. {
  248. return "Artifact: " + getNameTranslated();
  249. }
  250. void CArtifact::addNewBonus(const std::shared_ptr<Bonus>& b)
  251. {
  252. b->source = BonusSource::ARTIFACT;
  253. b->duration = BonusDuration::PERMANENT;
  254. b->description.appendTextID(getNameTextID());
  255. b->description.appendRawString(" %+d");
  256. CBonusSystemNode::addNewBonus(b);
  257. }
  258. const std::map<ArtBearer::ArtBearer, std::vector<ArtifactPosition>> & CArtifact::getPossibleSlots() const
  259. {
  260. return possibleSlots;
  261. }
  262. void CArtifact::updateFrom(const JsonNode& data)
  263. {
  264. //TODO:CArtifact::updateFrom
  265. }
  266. void CArtifact::setImage(int32_t iconIndex, std::string image, std::string large)
  267. {
  268. this->iconIndex = iconIndex;
  269. this->image = image;
  270. this->large = large;
  271. }
  272. CArtHandler::~CArtHandler() = default;
  273. std::vector<JsonNode> CArtHandler::loadLegacyData()
  274. {
  275. size_t dataSize = VLC->settings()->getInteger(EGameSettings::TEXTS_ARTIFACT);
  276. objects.resize(dataSize);
  277. std::vector<JsonNode> h3Data;
  278. h3Data.reserve(dataSize);
  279. #define ART_POS(x) #x ,
  280. const std::vector<std::string> artSlots = { ART_POS_LIST };
  281. #undef ART_POS
  282. static const std::map<char, std::string> classes =
  283. {{'S',"SPECIAL"}, {'T',"TREASURE"},{'N',"MINOR"},{'J',"MAJOR"},{'R',"RELIC"},};
  284. CLegacyConfigParser parser(TextPath::builtin("DATA/ARTRAITS.TXT"));
  285. CLegacyConfigParser events(TextPath::builtin("DATA/ARTEVENT.TXT"));
  286. parser.endLine(); // header
  287. parser.endLine();
  288. for (size_t i = 0; i < dataSize; i++)
  289. {
  290. JsonNode artData;
  291. artData["text"]["name"].String() = parser.readString();
  292. artData["text"]["event"].String() = events.readString();
  293. artData["value"].Float() = parser.readNumber();
  294. for(const auto & artSlot : artSlots)
  295. {
  296. if(parser.readString() == "x")
  297. {
  298. artData["slot"].Vector().emplace_back(artSlot);
  299. }
  300. }
  301. artData["class"].String() = classes.at(parser.readString()[0]);
  302. artData["text"]["description"].String() = parser.readString();
  303. parser.endLine();
  304. events.endLine();
  305. h3Data.push_back(artData);
  306. }
  307. return h3Data;
  308. }
  309. void CArtHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
  310. {
  311. auto * object = loadFromJson(scope, data, name, objects.size());
  312. object->iconIndex = object->getIndex() + 5;
  313. objects.emplace_back(object);
  314. registerObject(scope, "artifact", name, object->id.getNum());
  315. }
  316. void CArtHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
  317. {
  318. auto * object = loadFromJson(scope, data, name, index);
  319. object->iconIndex = object->getIndex();
  320. assert(objects[index] == nullptr); // ensure that this id was not loaded before
  321. objects[index] = object;
  322. registerObject(scope, "artifact", name, object->id.getNum());
  323. }
  324. const std::vector<std::string> & CArtHandler::getTypeNames() const
  325. {
  326. static const std::vector<std::string> typeNames = { "artifact" };
  327. return typeNames;
  328. }
  329. CArtifact * CArtHandler::loadFromJson(const std::string & scope, const JsonNode & node, const std::string & identifier, size_t index)
  330. {
  331. assert(identifier.find(':') == std::string::npos);
  332. assert(!scope.empty());
  333. CArtifact * art = new CArtifact();
  334. if(!node["growing"].isNull())
  335. {
  336. for(auto bonus : node["growing"]["bonusesPerLevel"].Vector())
  337. {
  338. art->bonusesPerLevel.emplace_back(static_cast<ui16>(bonus["level"].Float()), Bonus());
  339. JsonUtils::parseBonus(bonus["bonus"], &art->bonusesPerLevel.back().second);
  340. }
  341. for(auto bonus : node["growing"]["thresholdBonuses"].Vector())
  342. {
  343. art->thresholdBonuses.emplace_back(static_cast<ui16>(bonus["level"].Float()), Bonus());
  344. JsonUtils::parseBonus(bonus["bonus"], &art->thresholdBonuses.back().second);
  345. }
  346. }
  347. art->id = ArtifactID(index);
  348. art->identifier = identifier;
  349. art->modScope = scope;
  350. const JsonNode & text = node["text"];
  351. VLC->generaltexth->registerString(scope, art->getNameTextID(), text["name"].String());
  352. VLC->generaltexth->registerString(scope, art->getDescriptionTextID(), text["description"].String());
  353. VLC->generaltexth->registerString(scope, art->getEventTextID(), text["event"].String());
  354. const JsonNode & graphics = node["graphics"];
  355. art->image = graphics["image"].String();
  356. if(!graphics["large"].isNull())
  357. art->large = graphics["large"].String();
  358. else
  359. art->large = art->image;
  360. art->advMapDef = graphics["map"].String();
  361. art->price = static_cast<ui32>(node["value"].Float());
  362. art->onlyOnWaterMap = node["onlyOnWaterMap"].Bool();
  363. loadSlots(art, node);
  364. loadClass(art, node);
  365. loadType(art, node);
  366. loadComponents(art, node);
  367. for(const auto & b : node["bonuses"].Vector())
  368. {
  369. auto bonus = JsonUtils::parseBonus(b);
  370. art->addNewBonus(bonus);
  371. }
  372. const JsonNode & warMachine = node["warMachine"];
  373. if(warMachine.getType() == JsonNode::JsonType::DATA_STRING && !warMachine.String().empty())
  374. {
  375. VLC->identifiers()->requestIdentifier("creature", warMachine, [=](si32 id)
  376. {
  377. art->warMachine = CreatureID(id);
  378. //this assumes that creature object is stored before registration
  379. VLC->creh->objects.at(id)->warMachine = art->id;
  380. });
  381. }
  382. VLC->identifiers()->requestIdentifier(scope, "object", "artifact", [=](si32 index)
  383. {
  384. JsonNode conf;
  385. conf.setModScope(scope);
  386. VLC->objtypeh->loadSubObject(art->identifier, conf, Obj::ARTIFACT, art->getIndex());
  387. if(!art->advMapDef.empty())
  388. {
  389. JsonNode templ;
  390. templ["animation"].String() = art->advMapDef;
  391. templ.setModScope(scope);
  392. // add new template.
  393. // Necessary for objects added via mods that don't have any templates in H3
  394. VLC->objtypeh->getHandlerFor(Obj::ARTIFACT, art->getIndex())->addTemplate(templ);
  395. }
  396. });
  397. if(art->isTradable())
  398. art->possibleSlots.at(ArtBearer::ALTAR).push_back(ArtifactPosition::ALTAR);
  399. return art;
  400. }
  401. int32_t ArtifactPositionBase::decode(const std::string & slotName)
  402. {
  403. #define ART_POS(x) { #x, ArtifactPosition::x },
  404. static const std::map<std::string, ArtifactPosition> artifactPositionMap = { ART_POS_LIST };
  405. #undef ART_POS
  406. auto it = artifactPositionMap.find (slotName);
  407. if (it != artifactPositionMap.end())
  408. return it->second;
  409. else
  410. return PRE_FIRST;
  411. }
  412. void CArtHandler::addSlot(CArtifact * art, const std::string & slotID) const
  413. {
  414. static const std::vector<ArtifactPosition> miscSlots =
  415. {
  416. ArtifactPosition::MISC1, ArtifactPosition::MISC2, ArtifactPosition::MISC3, ArtifactPosition::MISC4, ArtifactPosition::MISC5
  417. };
  418. static const std::vector<ArtifactPosition> ringSlots =
  419. {
  420. ArtifactPosition::RIGHT_RING, ArtifactPosition::LEFT_RING
  421. };
  422. if (slotID == "MISC")
  423. {
  424. vstd::concatenate(art->possibleSlots[ArtBearer::HERO], miscSlots);
  425. }
  426. else if (slotID == "RING")
  427. {
  428. vstd::concatenate(art->possibleSlots[ArtBearer::HERO], ringSlots);
  429. }
  430. else
  431. {
  432. auto slot = ArtifactPosition::decode(slotID);
  433. if (slot != ArtifactPosition::PRE_FIRST)
  434. art->possibleSlots[ArtBearer::HERO].push_back(slot);
  435. }
  436. }
  437. void CArtHandler::loadSlots(CArtifact * art, const JsonNode & node) const
  438. {
  439. if (!node["slot"].isNull()) //we assume non-hero slots are irrelevant?
  440. {
  441. if (node["slot"].getType() == JsonNode::JsonType::DATA_STRING)
  442. addSlot(art, node["slot"].String());
  443. else
  444. {
  445. for (const JsonNode & slot : node["slot"].Vector())
  446. addSlot(art, slot.String());
  447. }
  448. std::sort(art->possibleSlots.at(ArtBearer::HERO).begin(), art->possibleSlots.at(ArtBearer::HERO).end());
  449. }
  450. }
  451. CArtifact::EartClass CArtHandler::stringToClass(const std::string & className)
  452. {
  453. static const std::map<std::string, CArtifact::EartClass> artifactClassMap =
  454. {
  455. {"TREASURE", CArtifact::ART_TREASURE},
  456. {"MINOR", CArtifact::ART_MINOR},
  457. {"MAJOR", CArtifact::ART_MAJOR},
  458. {"RELIC", CArtifact::ART_RELIC},
  459. {"SPECIAL", CArtifact::ART_SPECIAL}
  460. };
  461. auto it = artifactClassMap.find (className);
  462. if (it != artifactClassMap.end())
  463. return it->second;
  464. logMod->warn("Warning! Artifact rarity %s not recognized!", className);
  465. return CArtifact::ART_SPECIAL;
  466. }
  467. void CArtHandler::loadClass(CArtifact * art, const JsonNode & node) const
  468. {
  469. art->aClass = stringToClass(node["class"].String());
  470. }
  471. void CArtHandler::loadType(CArtifact * art, const JsonNode & node) const
  472. {
  473. #define ART_BEARER(x) { #x, ArtBearer::x },
  474. static const std::map<std::string, int> artifactBearerMap = { ART_BEARER_LIST };
  475. #undef ART_BEARER
  476. for (const JsonNode & b : node["type"].Vector())
  477. {
  478. auto it = artifactBearerMap.find (b.String());
  479. if (it != artifactBearerMap.end())
  480. {
  481. int bearerType = it->second;
  482. switch (bearerType)
  483. {
  484. case ArtBearer::HERO://TODO: allow arts having several possible bearers
  485. break;
  486. case ArtBearer::COMMANDER:
  487. makeItCommanderArt (art); //original artifacts should have only one bearer type
  488. break;
  489. case ArtBearer::CREATURE:
  490. makeItCreatureArt (art);
  491. break;
  492. }
  493. }
  494. else
  495. logMod->warn("Warning! Artifact type %s not recognized!", b.String());
  496. }
  497. }
  498. void CArtHandler::loadComponents(CArtifact * art, const JsonNode & node)
  499. {
  500. if (!node["components"].isNull())
  501. {
  502. for(const auto & component : node["components"].Vector())
  503. {
  504. VLC->identifiers()->requestIdentifier("artifact", component, [=](si32 id)
  505. {
  506. // when this code is called both combinational art as well as component are loaded
  507. // so it is safe to access any of them
  508. art->constituents.push_back(ArtifactID(id).toArtifact());
  509. objects[id]->partOf.push_back(art);
  510. });
  511. }
  512. }
  513. }
  514. void CArtHandler::makeItCreatureArt(CArtifact * a, bool onlyCreature)
  515. {
  516. if (onlyCreature)
  517. {
  518. a->possibleSlots[ArtBearer::HERO].clear();
  519. a->possibleSlots[ArtBearer::COMMANDER].clear();
  520. }
  521. a->possibleSlots[ArtBearer::CREATURE].push_back(ArtifactPosition::CREATURE_SLOT);
  522. }
  523. void CArtHandler::makeItCommanderArt(CArtifact * a, bool onlyCommander)
  524. {
  525. if (onlyCommander)
  526. {
  527. a->possibleSlots[ArtBearer::HERO].clear();
  528. a->possibleSlots[ArtBearer::CREATURE].clear();
  529. }
  530. for(const auto & slot : ArtifactUtils::commanderSlots())
  531. a->possibleSlots[ArtBearer::COMMANDER].push_back(ArtifactPosition(slot));
  532. }
  533. bool CArtHandler::legalArtifact(const ArtifactID & id) const
  534. {
  535. auto art = id.toArtifact();
  536. //assert ( (!art->constituents) || art->constituents->size() ); //artifacts is not combined or has some components
  537. if(art->isCombined())
  538. return false; //no combo artifacts spawning
  539. if(art->aClass < CArtifact::ART_TREASURE || art->aClass > CArtifact::ART_RELIC)
  540. return false; // invalid class
  541. if(art->possibleSlots.count(ArtBearer::HERO) && !art->possibleSlots.at(ArtBearer::HERO).empty())
  542. return true;
  543. if(art->possibleSlots.count(ArtBearer::CREATURE) && !art->possibleSlots.at(ArtBearer::CREATURE).empty() && VLC->settings()->getBoolean(EGameSettings::MODULE_STACK_ARTIFACT))
  544. return true;
  545. if(art->possibleSlots.count(ArtBearer::COMMANDER) && !art->possibleSlots.at(ArtBearer::COMMANDER).empty() && VLC->settings()->getBoolean(EGameSettings::MODULE_COMMANDERS))
  546. return true;
  547. return false;
  548. }
  549. std::set<ArtifactID> CArtHandler::getDefaultAllowed() const
  550. {
  551. std::set<ArtifactID> allowedArtifacts;
  552. for (auto artifact : objects)
  553. {
  554. if (!artifact->isCombined())
  555. allowedArtifacts.insert(artifact->getId());
  556. }
  557. return allowedArtifacts;
  558. }
  559. void CArtHandler::afterLoadFinalization()
  560. {
  561. //All artifacts have their id, so we can properly update their bonuses' source ids.
  562. for(auto &art : objects)
  563. {
  564. for(auto &bonus : art->getExportedBonusList())
  565. {
  566. assert(bonus->source == BonusSource::ARTIFACT);
  567. bonus->sid = BonusSourceID(art->id);
  568. }
  569. }
  570. CBonusSystemNode::treeHasChanged();
  571. }
  572. CArtifactSet::~CArtifactSet() = default;
  573. const CArtifactInstance * CArtifactSet::getArt(const ArtifactPosition & pos, bool excludeLocked) const
  574. {
  575. if(const ArtSlotInfo * si = getSlot(pos))
  576. {
  577. if(si->artifact && (!excludeLocked || !si->locked))
  578. return si->artifact;
  579. }
  580. return nullptr;
  581. }
  582. CArtifactInstance * CArtifactSet::getArt(const ArtifactPosition & pos, bool excludeLocked)
  583. {
  584. return const_cast<CArtifactInstance*>((const_cast<const CArtifactSet*>(this))->getArt(pos, excludeLocked));
  585. }
  586. ArtifactPosition CArtifactSet::getArtPos(const ArtifactID & aid, bool onlyWorn, bool allowLocked) const
  587. {
  588. const auto result = getAllArtPositions(aid, onlyWorn, allowLocked, false);
  589. return result.empty() ? ArtifactPosition{ArtifactPosition::PRE_FIRST} : result[0];
  590. }
  591. std::vector<ArtifactPosition> CArtifactSet::getAllArtPositions(const ArtifactID & aid, bool onlyWorn, bool allowLocked, bool getAll) const
  592. {
  593. std::vector<ArtifactPosition> result;
  594. for(const auto & slotInfo : artifactsWorn)
  595. if(slotInfo.second.artifact->getTypeId() == aid && (allowLocked || !slotInfo.second.locked))
  596. result.push_back(slotInfo.first);
  597. if(onlyWorn)
  598. return result;
  599. if(!getAll && !result.empty())
  600. return result;
  601. auto backpackPositions = getBackpackArtPositions(aid);
  602. result.insert(result.end(), backpackPositions.begin(), backpackPositions.end());
  603. return result;
  604. }
  605. std::vector<ArtifactPosition> CArtifactSet::getBackpackArtPositions(const ArtifactID & aid) const
  606. {
  607. std::vector<ArtifactPosition> result;
  608. si32 backpackPosition = ArtifactPosition::BACKPACK_START;
  609. for(const auto & artInfo : artifactsInBackpack)
  610. {
  611. const auto * art = artInfo.getArt();
  612. if(art && art->artType->getId() == aid)
  613. result.emplace_back(backpackPosition);
  614. backpackPosition++;
  615. }
  616. return result;
  617. }
  618. ArtifactPosition CArtifactSet::getArtPos(const CArtifactInstance *art) const
  619. {
  620. for(auto i : artifactsWorn)
  621. if(i.second.artifact == art)
  622. return i.first;
  623. for(int i = 0; i < artifactsInBackpack.size(); i++)
  624. if(artifactsInBackpack[i].artifact == art)
  625. return ArtifactPosition::BACKPACK_START + i;
  626. return ArtifactPosition::PRE_FIRST;
  627. }
  628. const CArtifactInstance * CArtifactSet::getArtByInstanceId(const ArtifactInstanceID & artInstId) const
  629. {
  630. for(auto i : artifactsWorn)
  631. if(i.second.artifact->getId() == artInstId)
  632. return i.second.artifact;
  633. for(auto i : artifactsInBackpack)
  634. if(i.artifact->getId() == artInstId)
  635. return i.artifact;
  636. return nullptr;
  637. }
  638. const ArtifactPosition CArtifactSet::getSlotByInstance(const CArtifactInstance * artInst) const
  639. {
  640. if(artInst)
  641. {
  642. for(const auto & slot : artInst->artType->getPossibleSlots().at(bearerType()))
  643. if(getArt(slot) == artInst)
  644. return slot;
  645. ArtifactPosition backpackSlot = ArtifactPosition::BACKPACK_START;
  646. for(auto & slotInfo : artifactsInBackpack)
  647. {
  648. if(slotInfo.getArt() == artInst)
  649. return backpackSlot;
  650. backpackSlot = ArtifactPosition(backpackSlot + 1);
  651. }
  652. }
  653. return ArtifactPosition::PRE_FIRST;
  654. }
  655. bool CArtifactSet::hasArt(const ArtifactID & aid, bool onlyWorn, bool searchBackpackAssemblies, bool allowLocked) const
  656. {
  657. return getArtPosCount(aid, onlyWorn, searchBackpackAssemblies, allowLocked) > 0;
  658. }
  659. bool CArtifactSet::hasArtBackpack(const ArtifactID & aid) const
  660. {
  661. return !getBackpackArtPositions(aid).empty();
  662. }
  663. unsigned CArtifactSet::getArtPosCount(const ArtifactID & aid, bool onlyWorn, bool searchBackpackAssemblies, bool allowLocked) const
  664. {
  665. const auto allPositions = getAllArtPositions(aid, onlyWorn, allowLocked, true);
  666. if(!allPositions.empty())
  667. return allPositions.size();
  668. if(searchBackpackAssemblies && getHiddenArt(aid))
  669. return 1;
  670. return 0;
  671. }
  672. CArtifactSet::ArtPlacementMap CArtifactSet::putArtifact(ArtifactPosition slot, CArtifactInstance * art)
  673. {
  674. ArtPlacementMap resArtPlacement;
  675. setNewArtSlot(slot, art, false);
  676. if(art->artType->isCombined() && ArtifactUtils::isSlotEquipment(slot))
  677. {
  678. const CArtifactInstance * mainPart = nullptr;
  679. for(const auto & part : art->getPartsInfo())
  680. if(vstd::contains(part.art->artType->getPossibleSlots().at(bearerType()), slot)
  681. && (part.slot == ArtifactPosition::PRE_FIRST))
  682. {
  683. mainPart = part.art;
  684. break;
  685. }
  686. for(const auto & part : art->getPartsInfo())
  687. {
  688. if(part.art != mainPart)
  689. {
  690. auto partSlot = part.slot;
  691. if(!part.art->artType->canBePutAt(this, partSlot))
  692. partSlot = ArtifactUtils::getArtAnyPosition(this, part.art->getTypeId());
  693. assert(ArtifactUtils::isSlotEquipment(partSlot));
  694. setNewArtSlot(partSlot, part.art, true);
  695. resArtPlacement.emplace(std::make_pair(part.art, partSlot));
  696. }
  697. else
  698. {
  699. resArtPlacement.emplace(std::make_pair(part.art, part.slot));
  700. }
  701. }
  702. }
  703. return resArtPlacement;
  704. }
  705. void CArtifactSet::removeArtifact(ArtifactPosition slot)
  706. {
  707. auto art = getArt(slot, false);
  708. if(art)
  709. {
  710. if(art->isCombined())
  711. {
  712. for(auto & part : art->getPartsInfo())
  713. {
  714. if(getArt(part.slot, false))
  715. eraseArtSlot(part.slot);
  716. }
  717. }
  718. eraseArtSlot(slot);
  719. }
  720. }
  721. std::pair<const CArtifactInstance *, const CArtifactInstance *> CArtifactSet::searchForConstituent(const ArtifactID & aid) const
  722. {
  723. for(const auto & slot : artifactsInBackpack)
  724. {
  725. auto art = slot.artifact;
  726. if(art->isCombined())
  727. {
  728. for(auto & ci : art->getPartsInfo())
  729. {
  730. if(ci.art->getTypeId() == aid)
  731. {
  732. return {art, ci.art};
  733. }
  734. }
  735. }
  736. }
  737. return {nullptr, nullptr};
  738. }
  739. const CArtifactInstance * CArtifactSet::getHiddenArt(const ArtifactID & aid) const
  740. {
  741. return searchForConstituent(aid).second;
  742. }
  743. const CArtifactInstance * CArtifactSet::getAssemblyByConstituent(const ArtifactID & aid) const
  744. {
  745. return searchForConstituent(aid).first;
  746. }
  747. const ArtSlotInfo * CArtifactSet::getSlot(const ArtifactPosition & pos) const
  748. {
  749. if(pos == ArtifactPosition::TRANSITION_POS)
  750. {
  751. // Always add to the end. Always take from the beginning.
  752. if(artifactsTransitionPos.empty())
  753. return nullptr;
  754. else
  755. return &(*artifactsTransitionPos.begin());
  756. }
  757. if(vstd::contains(artifactsWorn, pos))
  758. return &artifactsWorn.at(pos);
  759. if(ArtifactUtils::isSlotBackpack(pos))
  760. {
  761. auto backpackPos = pos - ArtifactPosition::BACKPACK_START;
  762. if(backpackPos < 0 || backpackPos >= artifactsInBackpack.size())
  763. return nullptr;
  764. else
  765. return &artifactsInBackpack[backpackPos];
  766. }
  767. return nullptr;
  768. }
  769. bool CArtifactSet::isPositionFree(const ArtifactPosition & pos, bool onlyLockCheck) const
  770. {
  771. if(bearerType() == ArtBearer::ALTAR)
  772. return artifactsInBackpack.size() < GameConstants::ALTAR_ARTIFACTS_SLOTS;
  773. if(const ArtSlotInfo *s = getSlot(pos))
  774. return (onlyLockCheck || !s->artifact) && !s->locked;
  775. return true; //no slot means not used
  776. }
  777. void CArtifactSet::setNewArtSlot(const ArtifactPosition & slot, ConstTransitivePtr<CArtifactInstance> art, bool locked)
  778. {
  779. assert(!vstd::contains(artifactsWorn, slot));
  780. ArtSlotInfo * slotInfo;
  781. if(slot == ArtifactPosition::TRANSITION_POS)
  782. {
  783. // Always add to the end. Always take from the beginning.
  784. artifactsTransitionPos.emplace_back();
  785. slotInfo = &artifactsTransitionPos.back();
  786. }
  787. else if(ArtifactUtils::isSlotEquipment(slot))
  788. {
  789. slotInfo = &artifactsWorn[slot];
  790. }
  791. else
  792. {
  793. auto position = artifactsInBackpack.begin() + slot - ArtifactPosition::BACKPACK_START;
  794. slotInfo = &(*artifactsInBackpack.emplace(position, ArtSlotInfo()));
  795. }
  796. slotInfo->artifact = art;
  797. slotInfo->locked = locked;
  798. }
  799. void CArtifactSet::eraseArtSlot(const ArtifactPosition & slot)
  800. {
  801. if(slot == ArtifactPosition::TRANSITION_POS)
  802. {
  803. assert(!artifactsTransitionPos.empty());
  804. artifactsTransitionPos.erase(artifactsTransitionPos.begin());
  805. }
  806. else if(ArtifactUtils::isSlotBackpack(slot))
  807. {
  808. auto backpackSlot = ArtifactPosition(slot - ArtifactPosition::BACKPACK_START);
  809. assert(artifactsInBackpack.begin() + backpackSlot < artifactsInBackpack.end());
  810. artifactsInBackpack.erase(artifactsInBackpack.begin() + backpackSlot);
  811. }
  812. else
  813. {
  814. artifactsWorn.erase(slot);
  815. }
  816. }
  817. void CArtifactSet::artDeserializationFix(CBonusSystemNode *node)
  818. {
  819. for(auto & elem : artifactsWorn)
  820. if(elem.second.artifact && !elem.second.locked)
  821. node->attachTo(*elem.second.artifact);
  822. }
  823. void CArtifactSet::serializeJsonArtifacts(JsonSerializeFormat & handler, const std::string & fieldName, CMap * map)
  824. {
  825. //todo: creature and commander artifacts
  826. if(handler.saving && artifactsInBackpack.empty() && artifactsWorn.empty())
  827. return;
  828. if(!handler.saving)
  829. {
  830. assert(map);
  831. artifactsInBackpack.clear();
  832. artifactsWorn.clear();
  833. }
  834. auto s = handler.enterStruct(fieldName);
  835. switch(bearerType())
  836. {
  837. case ArtBearer::HERO:
  838. serializeJsonHero(handler, map);
  839. break;
  840. case ArtBearer::CREATURE:
  841. serializeJsonCreature(handler, map);
  842. break;
  843. case ArtBearer::COMMANDER:
  844. serializeJsonCommander(handler, map);
  845. break;
  846. default:
  847. assert(false);
  848. break;
  849. }
  850. }
  851. void CArtifactSet::serializeJsonHero(JsonSerializeFormat & handler, CMap * map)
  852. {
  853. for(const auto & slot : ArtifactUtils::allWornSlots())
  854. {
  855. serializeJsonSlot(handler, slot, map);
  856. }
  857. std::vector<ArtifactID> backpackTemp;
  858. if(handler.saving)
  859. {
  860. backpackTemp.reserve(artifactsInBackpack.size());
  861. for(const ArtSlotInfo & info : artifactsInBackpack)
  862. backpackTemp.push_back(info.artifact->getTypeId());
  863. }
  864. handler.serializeIdArray(NArtifactPosition::backpack, backpackTemp);
  865. if(!handler.saving)
  866. {
  867. for(const ArtifactID & artifactID : backpackTemp)
  868. {
  869. auto * artifact = ArtifactUtils::createArtifact(map, artifactID);
  870. auto slot = ArtifactPosition::BACKPACK_START + artifactsInBackpack.size();
  871. if(artifact->artType->canBePutAt(this, slot))
  872. {
  873. auto artsMap = putArtifact(slot, artifact);
  874. artifact->addPlacementMap(artsMap);
  875. }
  876. }
  877. }
  878. }
  879. void CArtifactSet::serializeJsonCreature(JsonSerializeFormat & handler, CMap * map)
  880. {
  881. logGlobal->error("CArtifactSet::serializeJsonCreature not implemented");
  882. }
  883. void CArtifactSet::serializeJsonCommander(JsonSerializeFormat & handler, CMap * map)
  884. {
  885. logGlobal->error("CArtifactSet::serializeJsonCommander not implemented");
  886. }
  887. void CArtifactSet::serializeJsonSlot(JsonSerializeFormat & handler, const ArtifactPosition & slot, CMap * map)
  888. {
  889. ArtifactID artifactID;
  890. if(handler.saving)
  891. {
  892. const ArtSlotInfo * info = getSlot(slot);
  893. if(info != nullptr && !info->locked)
  894. {
  895. artifactID = info->artifact->getTypeId();
  896. handler.serializeId(NArtifactPosition::namesHero[slot.num], artifactID, ArtifactID::NONE);
  897. }
  898. }
  899. else
  900. {
  901. handler.serializeId(NArtifactPosition::namesHero[slot.num], artifactID, ArtifactID::NONE);
  902. if(artifactID != ArtifactID::NONE)
  903. {
  904. auto * artifact = ArtifactUtils::createArtifact(map, artifactID.toEnum());
  905. if(artifact->artType->canBePutAt(this, slot))
  906. {
  907. auto artsMap = putArtifact(slot, artifact);
  908. artifact->addPlacementMap(artsMap);
  909. }
  910. else
  911. {
  912. logGlobal->debug("Artifact can't be put at the specified location."); //TODO add more debugging information
  913. }
  914. }
  915. }
  916. }
  917. CArtifactFittingSet::CArtifactFittingSet(ArtBearer::ArtBearer Bearer):
  918. Bearer(Bearer)
  919. {
  920. }
  921. ArtBearer::ArtBearer CArtifactFittingSet::bearerType() const
  922. {
  923. return this->Bearer;
  924. }
  925. VCMI_LIB_NAMESPACE_END