CObjectClassesHandler.cpp 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521
  1. /*
  2. * CObjectClassesHandler.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 "CObjectClassesHandler.h"
  12. #include "../filesystem/Filesystem.h"
  13. #include "../filesystem/CBinaryReader.h"
  14. #include "../json/JsonUtils.h"
  15. #include "../VCMI_Lib.h"
  16. #include "../GameConstants.h"
  17. #include "../constants/StringConstants.h"
  18. #include "../CGeneralTextHandler.h"
  19. #include "../GameSettings.h"
  20. #include "../CSoundBase.h"
  21. #include "../mapObjectConstructors/CBankInstanceConstructor.h"
  22. #include "../mapObjectConstructors/CRewardableConstructor.h"
  23. #include "../mapObjectConstructors/CommonConstructors.h"
  24. #include "../mapObjectConstructors/DwellingInstanceConstructor.h"
  25. #include "../mapObjectConstructors/HillFortInstanceConstructor.h"
  26. #include "../mapObjectConstructors/ShipyardInstanceConstructor.h"
  27. #include "../mapObjects/CGCreature.h"
  28. #include "../mapObjects/CGPandoraBox.h"
  29. #include "../mapObjects/CQuest.h"
  30. #include "../mapObjects/ObjectTemplate.h"
  31. #include "../mapObjects/CGMarket.h"
  32. #include "../mapObjects/MiscObjects.h"
  33. #include "../mapObjects/CGHeroInstance.h"
  34. #include "../mapObjects/CGTownInstance.h"
  35. #include "../modding/IdentifierStorage.h"
  36. #include "../modding/CModHandler.h"
  37. #include "../modding/ModScope.h"
  38. VCMI_LIB_NAMESPACE_BEGIN
  39. CObjectClassesHandler::CObjectClassesHandler()
  40. {
  41. #define SET_HANDLER_CLASS(STRING, CLASSNAME) handlerConstructors[STRING] = std::make_shared<CLASSNAME>
  42. #define SET_HANDLER(STRING, TYPENAME) handlerConstructors[STRING] = std::make_shared<CDefaultObjectTypeHandler<TYPENAME>>
  43. // list of all known handlers, hardcoded for now since the only way to add new objects is via C++ code
  44. //Note: should be in sync with registerTypesMapObjectTypes function
  45. SET_HANDLER_CLASS("configurable", CRewardableConstructor);
  46. SET_HANDLER_CLASS("dwelling", DwellingInstanceConstructor);
  47. SET_HANDLER_CLASS("hero", CHeroInstanceConstructor);
  48. SET_HANDLER_CLASS("town", CTownInstanceConstructor);
  49. SET_HANDLER_CLASS("bank", CBankInstanceConstructor);
  50. SET_HANDLER_CLASS("boat", BoatInstanceConstructor);
  51. SET_HANDLER_CLASS("market", MarketInstanceConstructor);
  52. SET_HANDLER_CLASS("hillFort", HillFortInstanceConstructor);
  53. SET_HANDLER_CLASS("shipyard", ShipyardInstanceConstructor);
  54. SET_HANDLER_CLASS("monster", CreatureInstanceConstructor);
  55. SET_HANDLER_CLASS("resource", ResourceInstanceConstructor);
  56. SET_HANDLER_CLASS("static", CObstacleConstructor);
  57. SET_HANDLER_CLASS("", CObstacleConstructor);
  58. SET_HANDLER("randomArtifact", CGArtifact);
  59. SET_HANDLER("randomHero", CGHeroInstance);
  60. SET_HANDLER("randomResource", CGResource);
  61. SET_HANDLER("randomTown", CGTownInstance);
  62. SET_HANDLER("randomMonster", CGCreature);
  63. SET_HANDLER("randomDwelling", CGDwelling);
  64. SET_HANDLER("generic", CGObjectInstance);
  65. SET_HANDLER("artifact", CGArtifact);
  66. SET_HANDLER("borderGate", CGBorderGate);
  67. SET_HANDLER("borderGuard", CGBorderGuard);
  68. SET_HANDLER("denOfThieves", CGDenOfthieves);
  69. SET_HANDLER("event", CGEvent);
  70. SET_HANDLER("garrison", CGGarrison);
  71. SET_HANDLER("heroPlaceholder", CGHeroPlaceholder);
  72. SET_HANDLER("keymaster", CGKeymasterTent);
  73. SET_HANDLER("lighthouse", CGLighthouse);
  74. SET_HANDLER("magi", CGMagi);
  75. SET_HANDLER("mine", CGMine);
  76. SET_HANDLER("obelisk", CGObelisk);
  77. SET_HANDLER("pandora", CGPandoraBox);
  78. SET_HANDLER("prison", CGHeroInstance);
  79. SET_HANDLER("questGuard", CGQuestGuard);
  80. SET_HANDLER("seerHut", CGSeerHut);
  81. SET_HANDLER("sign", CGSignBottle);
  82. SET_HANDLER("siren", CGSirens);
  83. SET_HANDLER("monolith", CGMonolith);
  84. SET_HANDLER("subterraneanGate", CGSubterraneanGate);
  85. SET_HANDLER("whirlpool", CGWhirlpool);
  86. SET_HANDLER("terrain", CGTerrainPatch);
  87. #undef SET_HANDLER_CLASS
  88. #undef SET_HANDLER
  89. }
  90. CObjectClassesHandler::~CObjectClassesHandler() = default;
  91. std::vector<JsonNode> CObjectClassesHandler::loadLegacyData()
  92. {
  93. size_t dataSize = VLC->settings()->getInteger(EGameSettings::TEXTS_OBJECT);
  94. CLegacyConfigParser parser(TextPath::builtin("Data/Objects.txt"));
  95. auto totalNumber = static_cast<size_t>(parser.readNumber()); // first line contains number of objects to read and nothing else
  96. parser.endLine();
  97. for (size_t i = 0; i < totalNumber; i++)
  98. {
  99. auto tmpl = std::make_shared<ObjectTemplate>();
  100. tmpl->readTxt(parser);
  101. parser.endLine();
  102. std::pair key(tmpl->id, tmpl->subid);
  103. legacyTemplates.insert(std::make_pair(key, tmpl));
  104. }
  105. objects.resize(256);
  106. std::vector<JsonNode> ret(dataSize);// create storage for 256 objects
  107. assert(dataSize == 256);
  108. CLegacyConfigParser namesParser(TextPath::builtin("Data/ObjNames.txt"));
  109. for (size_t i=0; i<256; i++)
  110. {
  111. ret[i]["name"].String() = namesParser.readString();
  112. namesParser.endLine();
  113. }
  114. JsonNode cregen1;
  115. JsonNode cregen4;
  116. CLegacyConfigParser cregen1Parser(TextPath::builtin("data/crgen1"));
  117. do
  118. {
  119. JsonNode subObject;
  120. subObject["name"].String() = cregen1Parser.readString();
  121. cregen1.Vector().push_back(subObject);
  122. }
  123. while(cregen1Parser.endLine());
  124. CLegacyConfigParser cregen4Parser(TextPath::builtin("data/crgen4"));
  125. do
  126. {
  127. JsonNode subObject;
  128. subObject["name"].String() = cregen4Parser.readString();
  129. cregen4.Vector().push_back(subObject);
  130. }
  131. while(cregen4Parser.endLine());
  132. ret[Obj::CREATURE_GENERATOR1]["subObjects"] = cregen1;
  133. ret[Obj::CREATURE_GENERATOR4]["subObjects"] = cregen4;
  134. ret[Obj::REFUGEE_CAMP]["subObjects"].Vector().push_back(ret[Obj::REFUGEE_CAMP]);
  135. ret[Obj::WAR_MACHINE_FACTORY]["subObjects"].Vector().push_back(ret[Obj::WAR_MACHINE_FACTORY]);
  136. return ret;
  137. }
  138. void CObjectClassesHandler::loadSubObject(const std::string & scope, const std::string & identifier, const JsonNode & entry, ObjectClass * obj)
  139. {
  140. auto object = loadSubObjectFromJson(scope, identifier, entry, obj, obj->objects.size());
  141. assert(object);
  142. obj->objects.push_back(object);
  143. registerObject(scope, obj->getJsonKey(), object->getSubTypeName(), object->subtype);
  144. for(const auto & compatID : entry["compatibilityIdentifiers"].Vector())
  145. registerObject(scope, obj->getJsonKey(), compatID.String(), object->subtype);
  146. }
  147. void CObjectClassesHandler::loadSubObject(const std::string & scope, const std::string & identifier, const JsonNode & entry, ObjectClass * obj, size_t index)
  148. {
  149. auto object = loadSubObjectFromJson(scope, identifier, entry, obj, index);
  150. assert(object);
  151. if (obj->objects.at(index) != nullptr)
  152. throw std::runtime_error("Attempt to load already loaded object:" + identifier);
  153. obj->objects.at(index) = object;
  154. registerObject(scope, obj->getJsonKey(), object->getSubTypeName(), object->subtype);
  155. for(const auto & compatID : entry["compatibilityIdentifiers"].Vector())
  156. registerObject(scope, obj->getJsonKey(), compatID.String(), object->subtype);
  157. }
  158. TObjectTypeHandler CObjectClassesHandler::loadSubObjectFromJson(const std::string & scope, const std::string & identifier, const JsonNode & entry, ObjectClass * obj, size_t index)
  159. {
  160. assert(identifier.find(':') == std::string::npos);
  161. assert(!scope.empty());
  162. std::string handler = obj->handlerName;
  163. if(!handlerConstructors.count(handler))
  164. {
  165. logMod->error("Handler with name %s was not found!", handler);
  166. // workaround for potential crash - if handler does not exists, continue with generic handler that is used for objects without any custom logc
  167. handler = "generic";
  168. assert(handlerConstructors.count(handler) != 0);
  169. }
  170. auto createdObject = handlerConstructors.at(handler)();
  171. createdObject->modScope = scope;
  172. createdObject->typeName = obj->identifier;
  173. createdObject->subTypeName = identifier;
  174. createdObject->type = obj->id;
  175. createdObject->subtype = index;
  176. createdObject->init(entry);
  177. auto range = legacyTemplates.equal_range(std::make_pair(obj->id, index));
  178. for (auto & templ : boost::make_iterator_range(range.first, range.second))
  179. {
  180. createdObject->addTemplate(templ.second);
  181. }
  182. legacyTemplates.erase(range.first, range.second);
  183. logGlobal->debug("Loaded object %s(%d)::%s(%d)", obj->getJsonKey(), obj->id, identifier, index);
  184. return createdObject;
  185. }
  186. ObjectClass::ObjectClass() = default;
  187. ObjectClass::~ObjectClass() = default;
  188. std::string ObjectClass::getJsonKey() const
  189. {
  190. return modScope + ':' + identifier;
  191. }
  192. std::string ObjectClass::getNameTextID() const
  193. {
  194. return TextIdentifier("object", modScope, identifier, "name").get();
  195. }
  196. std::string ObjectClass::getNameTranslated() const
  197. {
  198. return VLC->generaltexth->translate(getNameTextID());
  199. }
  200. std::unique_ptr<ObjectClass> CObjectClassesHandler::loadFromJson(const std::string & scope, const JsonNode & json, const std::string & name, size_t index)
  201. {
  202. auto obj = std::make_unique<ObjectClass>();
  203. obj->modScope = scope;
  204. obj->identifier = name;
  205. obj->handlerName = json["handler"].String();
  206. obj->base = json["base"];
  207. obj->id = index;
  208. VLC->generaltexth->registerString(scope, obj->getNameTextID(), json["name"].String());
  209. obj->objects.resize(json["lastReservedIndex"].Float() + 1);
  210. for (auto subData : json["types"].Struct())
  211. {
  212. if (!subData.second["index"].isNull())
  213. {
  214. const std::string & subMeta = subData.second["index"].getModScope();
  215. if ( subMeta == "core")
  216. {
  217. size_t subIndex = subData.second["index"].Integer();
  218. loadSubObject(subData.second.getModScope(), subData.first, subData.second, obj.get(), subIndex);
  219. }
  220. else
  221. {
  222. logMod->error("Object %s:%s.%s - attempt to load object with preset index! This option is reserved for built-in mod", subMeta, name, subData.first );
  223. loadSubObject(subData.second.getModScope(), subData.first, subData.second, obj.get());
  224. }
  225. }
  226. else
  227. loadSubObject(subData.second.getModScope(), subData.first, subData.second, obj.get());
  228. }
  229. if (obj->id == MapObjectID::MONOLITH_TWO_WAY)
  230. generateExtraMonolithsForRMG(obj.get());
  231. return obj;
  232. }
  233. void CObjectClassesHandler::loadObject(std::string scope, std::string name, const JsonNode & data)
  234. {
  235. objects.push_back(loadFromJson(scope, data, name, objects.size()));
  236. VLC->identifiersHandler->registerObject(scope, "object", name, objects.back()->id);
  237. }
  238. void CObjectClassesHandler::loadObject(std::string scope, std::string name, const JsonNode & data, size_t index)
  239. {
  240. assert(objects.at(index) == nullptr); // ensure that this id was not loaded before
  241. objects.at(index) = loadFromJson(scope, data, name, index);
  242. VLC->identifiersHandler->registerObject(scope, "object", name, objects.at(index)->id);
  243. }
  244. void CObjectClassesHandler::loadSubObject(const std::string & identifier, JsonNode config, MapObjectID ID, MapObjectSubID subID)
  245. {
  246. config.setType(JsonNode::JsonType::DATA_STRUCT); // ensure that input is not NULL
  247. assert(objects.at(ID.getNum()));
  248. if ( subID.getNum() >= objects.at(ID.getNum())->objects.size())
  249. objects.at(ID.getNum())->objects.resize(subID.getNum()+1);
  250. JsonUtils::inherit(config, objects.at(ID.getNum())->base);
  251. loadSubObject(config.getModScope(), identifier, config, objects.at(ID.getNum()).get(), subID.getNum());
  252. }
  253. void CObjectClassesHandler::removeSubObject(MapObjectID ID, MapObjectSubID subID)
  254. {
  255. assert(objects.at(ID.getNum()));
  256. objects.at(ID.getNum())->objects.at(subID.getNum()) = nullptr;
  257. }
  258. TObjectTypeHandler CObjectClassesHandler::getHandlerFor(MapObjectID type, MapObjectSubID subtype) const
  259. {
  260. try
  261. {
  262. if (objects.at(type.getNum()) == nullptr)
  263. return objects.front()->objects.front();
  264. auto subID = subtype.getNum();
  265. if (type == Obj::PRISON)
  266. subID = 0;
  267. auto result = objects.at(type.getNum())->objects.at(subID);
  268. if (result != nullptr)
  269. return result;
  270. }
  271. catch (std::out_of_range & e)
  272. {
  273. // Leave catch block silently
  274. }
  275. std::string errorString = "Failed to find object of type " + std::to_string(type.getNum()) + "::" + std::to_string(subtype.getNum());
  276. logGlobal->error(errorString);
  277. throw std::runtime_error(errorString);
  278. }
  279. TObjectTypeHandler CObjectClassesHandler::getHandlerFor(const std::string & scope, const std::string & type, const std::string & subtype) const
  280. {
  281. std::optional<si32> id = VLC->identifiers()->getIdentifier(scope, "object", type);
  282. if(id)
  283. {
  284. const auto & object = objects.at(id.value());
  285. std::optional<si32> subID = VLC->identifiers()->getIdentifier(scope, object->getJsonKey(), subtype);
  286. if (subID)
  287. return object->objects.at(subID.value());
  288. }
  289. std::string errorString = "Failed to find object of type " + type + "::" + subtype;
  290. logGlobal->error(errorString);
  291. throw std::runtime_error(errorString);
  292. }
  293. TObjectTypeHandler CObjectClassesHandler::getHandlerFor(CompoundMapObjectID compoundIdentifier) const
  294. {
  295. return getHandlerFor(compoundIdentifier.primaryID, compoundIdentifier.secondaryID);
  296. }
  297. std::set<MapObjectID> CObjectClassesHandler::knownObjects() const
  298. {
  299. std::set<MapObjectID> ret;
  300. for(auto & entry : objects)
  301. if (entry)
  302. ret.insert(entry->id);
  303. return ret;
  304. }
  305. std::set<MapObjectSubID> CObjectClassesHandler::knownSubObjects(MapObjectID primaryID) const
  306. {
  307. std::set<MapObjectSubID> ret;
  308. if (!objects.at(primaryID.getNum()))
  309. {
  310. logGlobal->error("Failed to find object %d", primaryID);
  311. return ret;
  312. }
  313. for(const auto & entry : objects.at(primaryID.getNum())->objects)
  314. if (entry)
  315. ret.insert(entry->subtype);
  316. return ret;
  317. }
  318. void CObjectClassesHandler::beforeValidate(JsonNode & object)
  319. {
  320. for (auto & entry : object["types"].Struct())
  321. {
  322. if (object.Struct().count("subObjects"))
  323. {
  324. const auto & vector = object["subObjects"].Vector();
  325. if (entry.second.Struct().count("index"))
  326. {
  327. size_t index = entry.second["index"].Integer();
  328. if (index < vector.size())
  329. JsonUtils::inherit(entry.second, vector[index]);
  330. }
  331. }
  332. JsonUtils::inherit(entry.second, object["base"]);
  333. for (auto & templ : entry.second["templates"].Struct())
  334. JsonUtils::inherit(templ.second, entry.second["base"]);
  335. }
  336. object.Struct().erase("subObjects");
  337. }
  338. void CObjectClassesHandler::afterLoadFinalization()
  339. {
  340. for(auto & entry : objects)
  341. {
  342. if (!entry)
  343. continue;
  344. for(const auto & obj : entry->objects)
  345. {
  346. if (!obj)
  347. continue;
  348. obj->afterLoadFinalization();
  349. if(obj->getTemplates().empty())
  350. logGlobal->warn("No templates found for %s:%s", entry->getJsonKey(), obj->getJsonKey());
  351. }
  352. }
  353. }
  354. void CObjectClassesHandler::generateExtraMonolithsForRMG(ObjectClass * container)
  355. {
  356. //duplicate existing two-way portals to make reserve for RMG
  357. auto& portalVec = container->objects;
  358. //FIXME: Monoliths in this vector can be already not useful for every terrain
  359. const size_t portalCount = portalVec.size();
  360. //Invalid portals will be skipped and portalVec size stays unchanged
  361. for (size_t i = portalCount; portalVec.size() < 100; ++i)
  362. {
  363. auto index = static_cast<si32>(i % portalCount);
  364. auto portal = portalVec[index];
  365. auto templates = portal->getTemplates();
  366. if (templates.empty() || !templates[0]->canBePlacedAtAnyTerrain())
  367. {
  368. continue; //Do not clone HoTA water-only portals or any others we can't use
  369. }
  370. //deep copy of noncopyable object :?
  371. auto newPortal = std::make_shared<CDefaultObjectTypeHandler<CGMonolith>>();
  372. newPortal->rmgInfo = portal->getRMGInfo();
  373. newPortal->templates = portal->getTemplates();
  374. newPortal->sounds = portal->getSounds();
  375. newPortal->aiValue = portal->getAiValue();
  376. newPortal->battlefield = portal->battlefield; //getter is not initialized at this point
  377. newPortal->modScope = portal->modScope; //private
  378. newPortal->typeName = portal->getTypeName();
  379. newPortal->subTypeName = std::string("monolith") + std::to_string(portalVec.size());
  380. newPortal->type = portal->getIndex();
  381. // Inconsintent original indexing: monolith1 has index 0
  382. newPortal->subtype = portalVec.size() - 1; //indexes must be unique, they are returned as a set
  383. newPortal->blockVisit = portal->blockVisit;
  384. newPortal->removable = portal->removable;
  385. portalVec.push_back(newPortal);
  386. registerObject(newPortal->modScope, container->getJsonKey(), newPortal->subTypeName, newPortal->subtype);
  387. }
  388. }
  389. std::string CObjectClassesHandler::getObjectName(MapObjectID type, MapObjectSubID subtype) const
  390. {
  391. const auto handler = getHandlerFor(type, subtype);
  392. if (handler && handler->hasNameTextID())
  393. return handler->getNameTranslated();
  394. if (objects.at(type.getNum()))
  395. return objects.at(type.getNum())->getNameTranslated();
  396. return objects.front()->getNameTranslated();
  397. }
  398. SObjectSounds CObjectClassesHandler::getObjectSounds(MapObjectID type, MapObjectSubID subtype) const
  399. {
  400. // TODO: these objects may have subID's that does not have associated handler:
  401. // Prison: uses hero type as subID
  402. // Hero: uses hero type as subID, but registers hero classes as subtypes
  403. // Spell scroll: uses spell ID as subID
  404. if(type == Obj::PRISON || type == Obj::HERO || type == Obj::SPELL_SCROLL)
  405. subtype = 0;
  406. if(objects.at(type.getNum()))
  407. return getHandlerFor(type, subtype)->getSounds();
  408. else
  409. return objects.front()->objects.front()->getSounds();
  410. }
  411. std::string CObjectClassesHandler::getObjectHandlerName(MapObjectID type) const
  412. {
  413. if (objects.at(type.getNum()))
  414. return objects.at(type.getNum())->handlerName;
  415. else
  416. return objects.front()->handlerName;
  417. }
  418. std::string CObjectClassesHandler::getJsonKey(MapObjectID type) const
  419. {
  420. if (objects.at(type.getNum()) != nullptr)
  421. return objects.at(type.getNum())->getJsonKey();
  422. logGlobal->warn("Unknown object of type %d!", type);
  423. return objects.front()->getJsonKey();
  424. }
  425. VCMI_LIB_NAMESPACE_END