JsonRandom.cpp 8.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309
  1. /*
  2. * JsonRandom.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 "JsonRandom.h"
  12. #include "../JsonNode.h"
  13. #include "../CRandomGenerator.h"
  14. #include "../StringConstants.h"
  15. #include "../VCMI_Lib.h"
  16. #include "../CModHandler.h"
  17. #include "../CArtHandler.h"
  18. #include "../CCreatureHandler.h"
  19. #include "../CCreatureSet.h"
  20. #include "../spells/CSpellHandler.h"
  21. #include "../CSkillHandler.h"
  22. #include "../mapObjects/CObjectHandler.h"
  23. #include "../IGameCallback.h"
  24. VCMI_LIB_NAMESPACE_BEGIN
  25. namespace JsonRandom
  26. {
  27. si32 loadValue(const JsonNode & value, CRandomGenerator & rng, si32 defaultValue)
  28. {
  29. if (value.isNull())
  30. return defaultValue;
  31. if (value.isNumber())
  32. return static_cast<si32>(value.Float());
  33. if (value.isVector())
  34. {
  35. const auto & vector = value.Vector();
  36. size_t index= rng.getIntRange(0, vector.size()-1)();
  37. return loadValue(vector[index], rng, 0);
  38. }
  39. if (!value["amount"].isNull())
  40. return static_cast<si32>(loadValue(value["amount"], rng, defaultValue));
  41. si32 min = static_cast<si32>(loadValue(value["min"], rng, 0));
  42. si32 max = static_cast<si32>(loadValue(value["max"], rng, 0));
  43. return rng.getIntRange(min, max)();
  44. }
  45. std::string loadKey(const JsonNode & value, CRandomGenerator & rng, std::set<std::string> valuesSet)
  46. {
  47. if (value.isNull())
  48. return valuesSet.empty() ? "" : *RandomGeneratorUtil::nextItem(valuesSet, rng);
  49. if (value.isString())
  50. return value.String();
  51. if (!value["type"].isNull())
  52. return value["type"].String();
  53. if(!value["anyOf"].isNull())
  54. return RandomGeneratorUtil::nextItem(value["anyOf"].Vector(), rng)->String();
  55. if(!value["noneOf"].isNull())
  56. {
  57. for(auto & s : value["noneOf"].Vector())
  58. valuesSet.erase(s.String());
  59. }
  60. return valuesSet.empty() ? "" : *RandomGeneratorUtil::nextItem(valuesSet, rng);
  61. }
  62. TResources loadResources(const JsonNode & value, CRandomGenerator & rng)
  63. {
  64. TResources ret;
  65. if (value.isVector())
  66. {
  67. for (const auto & entry : value.Vector())
  68. ret += loadResource(entry, rng);
  69. return ret;
  70. }
  71. for (size_t i=0; i<GameConstants::RESOURCE_QUANTITY; i++)
  72. {
  73. ret[i] = loadValue(value[GameConstants::RESOURCE_NAMES[i]], rng);
  74. }
  75. return ret;
  76. }
  77. TResources loadResource(const JsonNode & value, CRandomGenerator & rng)
  78. {
  79. std::set<std::string> defaultResources(GameConstants::RESOURCE_NAMES, GameConstants::RESOURCE_NAMES + GameConstants::RESOURCE_QUANTITY - 2); //except mithril
  80. std::string resourceName = loadKey(value, rng, defaultResources);
  81. si32 resourceAmount = loadValue(value, rng, 0);
  82. si32 resourceID(VLC->modh->identifiers.getIdentifier(value.meta, "resource", resourceName).get());
  83. TResources ret;
  84. ret[resourceID] = resourceAmount;
  85. return ret;
  86. }
  87. std::vector<si32> loadPrimary(const JsonNode & value, CRandomGenerator & rng)
  88. {
  89. std::vector<si32> ret;
  90. for(const auto & name : PrimarySkill::names)
  91. {
  92. ret.push_back(loadValue(value[name], rng));
  93. }
  94. if(!value["random"].isNull())
  95. {
  96. *RandomGeneratorUtil::nextItem(ret, rng) = loadValue(value["random"], rng);
  97. }
  98. return ret;
  99. }
  100. std::map<SecondarySkill, si32> loadSecondary(const JsonNode & value, CRandomGenerator & rng)
  101. {
  102. std::map<SecondarySkill, si32> ret;
  103. if(value.isStruct())
  104. {
  105. for(const auto & pair : value.Struct())
  106. {
  107. SecondarySkill id(VLC->modh->identifiers.getIdentifier(pair.second.meta, "skill", pair.first).get());
  108. ret[id] = loadValue(pair.second, rng);
  109. }
  110. }
  111. if(value.isVector())
  112. {
  113. std::set<std::string> defaultSkills;
  114. for(const auto & skill : VLC->skillh->objects)
  115. {
  116. IObjectInterface::cb->isAllowed(2, skill->getIndex());
  117. defaultSkills.insert(skill->getNameTextID());
  118. }
  119. for(const auto & element : value.Vector())
  120. {
  121. SecondarySkill id(VLC->modh->identifiers.getIdentifier(value.meta, "skill", loadKey(element, rng, defaultSkills)).get());
  122. ret[id] = loadValue(value, rng);
  123. }
  124. }
  125. return ret;
  126. }
  127. ArtifactID loadArtifact(const JsonNode & value, CRandomGenerator & rng)
  128. {
  129. if (value.getType() == JsonNode::JsonType::DATA_STRING)
  130. return ArtifactID(VLC->modh->identifiers.getIdentifier("artifact", value).get());
  131. std::set<CArtifact::EartClass> allowedClasses;
  132. std::set<ArtifactPosition> allowedPositions;
  133. ui32 minValue = 0;
  134. ui32 maxValue = std::numeric_limits<ui32>::max();
  135. if (value["class"].getType() == JsonNode::JsonType::DATA_STRING)
  136. allowedClasses.insert(CArtHandler::stringToClass(value["class"].String()));
  137. else
  138. for(const auto & entry : value["class"].Vector())
  139. allowedClasses.insert(CArtHandler::stringToClass(entry.String()));
  140. if (value["slot"].getType() == JsonNode::JsonType::DATA_STRING)
  141. allowedPositions.insert(ArtifactPosition(value["class"].String()));
  142. else
  143. for(const auto & entry : value["slot"].Vector())
  144. allowedPositions.insert(ArtifactPosition(entry.String()));
  145. if (!value["minValue"].isNull()) minValue = static_cast<ui32>(value["minValue"].Float());
  146. if (!value["maxValue"].isNull()) maxValue = static_cast<ui32>(value["maxValue"].Float());
  147. return VLC->arth->pickRandomArtifact(rng, [=](const ArtifactID & artID) -> bool
  148. {
  149. CArtifact * art = VLC->arth->objects[artID];
  150. if(!vstd::iswithin(art->price, minValue, maxValue))
  151. return false;
  152. if(!allowedClasses.empty() && !allowedClasses.count(art->aClass))
  153. return false;
  154. if(!IObjectInterface::cb->isAllowed(1, art->getIndex()))
  155. return false;
  156. if(!allowedPositions.empty())
  157. {
  158. for(const auto & pos : art->possibleSlots[ArtBearer::HERO])
  159. {
  160. if(allowedPositions.count(pos))
  161. return true;
  162. }
  163. return false;
  164. }
  165. return true;
  166. });
  167. }
  168. std::vector<ArtifactID> loadArtifacts(const JsonNode & value, CRandomGenerator & rng)
  169. {
  170. std::vector<ArtifactID> ret;
  171. for (const JsonNode & entry : value.Vector())
  172. {
  173. ret.push_back(loadArtifact(entry, rng));
  174. }
  175. return ret;
  176. }
  177. SpellID loadSpell(const JsonNode & value, CRandomGenerator & rng, std::vector<SpellID> spells)
  178. {
  179. if (value.getType() == JsonNode::JsonType::DATA_STRING)
  180. return SpellID(VLC->modh->identifiers.getIdentifier("spell", value).get());
  181. vstd::erase_if(spells, [=](const SpellID & spell)
  182. {
  183. return VLC->spellh->getById(spell)->getLevel() != si32(value["level"].Float());
  184. });
  185. return SpellID(*RandomGeneratorUtil::nextItem(spells, rng));
  186. }
  187. std::vector<SpellID> loadSpells(const JsonNode & value, CRandomGenerator & rng, const std::vector<SpellID> & spells)
  188. {
  189. // possible extensions: (taken from spell json config)
  190. // "type": "adventure",//"adventure", "combat", "ability"
  191. // "school": {"air":true, "earth":true, "fire":true, "water":true},
  192. // "level": 1,
  193. std::vector<SpellID> ret;
  194. for (const JsonNode & entry : value.Vector())
  195. {
  196. ret.push_back(loadSpell(entry, rng, spells));
  197. }
  198. return ret;
  199. }
  200. CStackBasicDescriptor loadCreature(const JsonNode & value, CRandomGenerator & rng)
  201. {
  202. CStackBasicDescriptor stack;
  203. stack.type = VLC->creh->objects[VLC->modh->identifiers.getIdentifier("creature", value["type"]).get()];
  204. stack.count = loadValue(value, rng);
  205. if (!value["upgradeChance"].isNull() && !stack.type->upgrades.empty())
  206. {
  207. if (int(value["upgradeChance"].Float()) > rng.nextInt(99)) // select random upgrade
  208. {
  209. stack.type = VLC->creh->objects[*RandomGeneratorUtil::nextItem(stack.type->upgrades, rng)];
  210. }
  211. }
  212. return stack;
  213. }
  214. std::vector<CStackBasicDescriptor> loadCreatures(const JsonNode & value, CRandomGenerator & rng)
  215. {
  216. std::vector<CStackBasicDescriptor> ret;
  217. for (const JsonNode & node : value.Vector())
  218. {
  219. ret.push_back(loadCreature(node, rng));
  220. }
  221. return ret;
  222. }
  223. std::vector<RandomStackInfo> evaluateCreatures(const JsonNode & value)
  224. {
  225. std::vector<RandomStackInfo> ret;
  226. for (const JsonNode & node : value.Vector())
  227. {
  228. RandomStackInfo info;
  229. if (!node["amount"].isNull())
  230. info.minAmount = info.maxAmount = static_cast<si32>(node["amount"].Float());
  231. else
  232. {
  233. info.minAmount = static_cast<si32>(node["min"].Float());
  234. info.maxAmount = static_cast<si32>(node["max"].Float());
  235. }
  236. const CCreature * crea = VLC->creh->objects[VLC->modh->identifiers.getIdentifier("creature", node["type"]).get()];
  237. info.allowedCreatures.push_back(crea);
  238. if (node["upgradeChance"].Float() > 0)
  239. {
  240. for(const auto & creaID : crea->upgrades)
  241. info.allowedCreatures.push_back(VLC->creh->objects[creaID]);
  242. }
  243. ret.push_back(info);
  244. }
  245. return ret;
  246. }
  247. //std::vector<Component> loadComponents(const JsonNode & value)
  248. //{
  249. // std::vector<Component> ret;
  250. // return ret;
  251. // //TODO
  252. //}
  253. std::vector<Bonus> DLL_LINKAGE loadBonuses(const JsonNode & value)
  254. {
  255. std::vector<Bonus> ret;
  256. for (const JsonNode & entry : value.Vector())
  257. {
  258. auto bonus = JsonUtils::parseBonus(entry);
  259. ret.push_back(*bonus);
  260. }
  261. return ret;
  262. }
  263. }
  264. VCMI_LIB_NAMESPACE_END