2012-08-10 16:07:53 +03:00
|
|
|
/*
|
|
|
|
* CModHandler.h, part of VCMI engine
|
|
|
|
*
|
|
|
|
* Authors: listed in file AUTHORS in main folder
|
|
|
|
*
|
|
|
|
* License: GNU General Public License v2.0 or later
|
|
|
|
* Full text of license available in license.txt file, in main folder
|
|
|
|
*
|
|
|
|
*/
|
2017-07-13 10:26:03 +02:00
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include "filesystem/Filesystem.h"
|
|
|
|
|
|
|
|
#include "VCMI_Lib.h"
|
|
|
|
#include "JsonNode.h"
|
2012-08-10 16:07:53 +03:00
|
|
|
|
2022-12-13 03:55:54 +02:00
|
|
|
#ifdef __UCLIBC__
|
|
|
|
#undef major
|
|
|
|
#undef minor
|
|
|
|
#undef patch
|
|
|
|
#endif
|
|
|
|
|
2022-07-26 15:07:42 +02:00
|
|
|
VCMI_LIB_NAMESPACE_BEGIN
|
|
|
|
|
2012-08-10 16:07:53 +03:00
|
|
|
class CModHandler;
|
|
|
|
class CModIndentifier;
|
|
|
|
class CModInfo;
|
2012-11-13 14:52:23 +03:00
|
|
|
class JsonNode;
|
2013-04-21 15:49:26 +03:00
|
|
|
class IHandlerBase;
|
2012-08-10 16:07:53 +03:00
|
|
|
|
2012-12-03 19:00:17 +03:00
|
|
|
/// class that stores all object identifiers strings and maps them to numeric ID's
|
|
|
|
/// if possible, objects ID's should be in format <type>.<name>, camelCase e.g. "creature.grandElf"
|
|
|
|
class CIdentifierStorage
|
|
|
|
{
|
2014-06-15 23:25:10 +03:00
|
|
|
enum ELoadingState
|
|
|
|
{
|
|
|
|
LOADING,
|
|
|
|
FINALIZING,
|
|
|
|
FINISHED
|
|
|
|
};
|
|
|
|
|
2013-04-25 17:03:35 +03:00
|
|
|
struct ObjectCallback // entry created on ID request
|
|
|
|
{
|
|
|
|
std::string localScope; /// scope from which this ID was requested
|
|
|
|
std::string remoteScope; /// scope in which this object must be found
|
|
|
|
std::string type; /// type, e.g. creature, faction, hero, etc
|
|
|
|
std::string name; /// string ID
|
2013-06-26 14:18:27 +03:00
|
|
|
std::function<void(si32)> callback;
|
2013-12-02 14:58:02 +03:00
|
|
|
bool optional;
|
2013-04-25 17:03:35 +03:00
|
|
|
|
2016-10-22 10:00:55 +02:00
|
|
|
ObjectCallback(std::string localScope, std::string remoteScope,
|
|
|
|
std::string type, std::string name,
|
|
|
|
const std::function<void(si32)> & callback,
|
|
|
|
bool optional);
|
2013-04-25 17:03:35 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ObjectData // entry created on ID registration
|
|
|
|
{
|
|
|
|
si32 id;
|
|
|
|
std::string scope; /// scope in which this ID located
|
2014-02-02 17:31:56 +03:00
|
|
|
|
2017-08-23 14:15:33 +02:00
|
|
|
bool operator==(const ObjectData & other) const
|
|
|
|
{
|
|
|
|
return id == other.id && scope == other.scope;
|
|
|
|
}
|
2014-02-02 17:31:56 +03:00
|
|
|
|
|
|
|
template <typename Handler> void serialize(Handler &h, const int version)
|
|
|
|
{
|
2017-07-31 15:35:42 +02:00
|
|
|
h & id;
|
|
|
|
h & scope;
|
2014-02-02 17:31:56 +03:00
|
|
|
}
|
2013-04-25 17:03:35 +03:00
|
|
|
};
|
|
|
|
|
2017-08-25 08:29:34 +02:00
|
|
|
std::multimap<std::string, ObjectData> registeredObjects;
|
2013-04-25 17:03:35 +03:00
|
|
|
std::vector<ObjectCallback> scheduledRequests;
|
2012-12-03 19:00:17 +03:00
|
|
|
|
2014-06-15 23:25:10 +03:00
|
|
|
ELoadingState state;
|
|
|
|
|
2013-04-21 15:49:26 +03:00
|
|
|
/// Check if identifier can be valid (camelCase, point as separator)
|
2012-12-22 19:47:12 +03:00
|
|
|
void checkIdentifier(std::string & ID);
|
2013-04-25 17:03:35 +03:00
|
|
|
|
|
|
|
void requestIdentifier(ObjectCallback callback);
|
|
|
|
bool resolveIdentifier(const ObjectCallback & callback);
|
2013-12-31 02:09:58 +03:00
|
|
|
std::vector<ObjectData> getPossibleIdentifiers(const ObjectCallback & callback);
|
2012-12-03 19:00:17 +03:00
|
|
|
public:
|
2014-06-15 23:25:10 +03:00
|
|
|
CIdentifierStorage();
|
2016-08-30 10:45:05 +02:00
|
|
|
virtual ~CIdentifierStorage();
|
2013-12-02 14:58:02 +03:00
|
|
|
/// request identifier for specific object name.
|
|
|
|
/// Function callback will be called during ID resolution phase of loading
|
2013-06-26 14:18:27 +03:00
|
|
|
void requestIdentifier(std::string scope, std::string type, std::string name, const std::function<void(si32)> & callback);
|
2014-11-12 04:50:51 +02:00
|
|
|
///fullName = [remoteScope:]type.name
|
2015-11-16 16:38:42 +02:00
|
|
|
void requestIdentifier(std::string scope, std::string fullName, const std::function<void(si32)> & callback);
|
2013-06-26 14:18:27 +03:00
|
|
|
void requestIdentifier(std::string type, const JsonNode & name, const std::function<void(si32)> & callback);
|
|
|
|
void requestIdentifier(const JsonNode & name, const std::function<void(si32)> & callback);
|
2013-04-25 17:03:35 +03:00
|
|
|
|
2013-12-02 14:58:02 +03:00
|
|
|
/// try to request ID. If ID with such name won't be loaded, callback function will not be called
|
|
|
|
void tryRequestIdentifier(std::string scope, std::string type, std::string name, const std::function<void(si32)> & callback);
|
|
|
|
void tryRequestIdentifier(std::string type, const JsonNode & name, const std::function<void(si32)> & callback);
|
|
|
|
|
|
|
|
/// get identifier immediately. If identifier is not know and not silent call will result in error message
|
2014-05-17 17:50:11 +03:00
|
|
|
boost::optional<si32> getIdentifier(std::string scope, std::string type, std::string name, bool silent = false);
|
2013-12-02 14:58:02 +03:00
|
|
|
boost::optional<si32> getIdentifier(std::string type, const JsonNode & name, bool silent = false);
|
2013-12-31 02:09:58 +03:00
|
|
|
boost::optional<si32> getIdentifier(const JsonNode & name, bool silent = false);
|
2016-11-13 12:38:42 +02:00
|
|
|
boost::optional<si32> getIdentifier(std::string scope, std::string fullName, bool silent = false);
|
2013-12-02 14:58:02 +03:00
|
|
|
|
|
|
|
/// registers new object
|
2013-04-21 15:49:26 +03:00
|
|
|
void registerObject(std::string scope, std::string type, std::string name, si32 identifier);
|
2012-12-03 19:00:17 +03:00
|
|
|
|
|
|
|
/// called at the very end of loading to check for any missing ID's
|
2013-04-21 15:49:26 +03:00
|
|
|
void finalize();
|
2014-02-02 17:31:56 +03:00
|
|
|
|
|
|
|
template <typename Handler> void serialize(Handler &h, const int version)
|
|
|
|
{
|
2017-07-31 15:35:42 +02:00
|
|
|
h & registeredObjects;
|
|
|
|
h & state;
|
2014-02-02 17:31:56 +03:00
|
|
|
}
|
2013-04-21 15:49:26 +03:00
|
|
|
};
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
/// internal type to handle loading of one data type (e.g. artifacts, creatures)
|
|
|
|
class DLL_LINKAGE ContentTypeHandler
|
2013-04-21 15:49:26 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
public:
|
|
|
|
struct ModInfo
|
2013-04-21 15:49:26 +03:00
|
|
|
{
|
2017-07-20 06:08:49 +02:00
|
|
|
/// mod data from this mod and for this mod
|
|
|
|
JsonNode modData;
|
|
|
|
/// mod data for this mod from other mods (patches)
|
|
|
|
JsonNode patches;
|
2013-04-21 15:49:26 +03:00
|
|
|
};
|
2017-07-20 06:08:49 +02:00
|
|
|
/// handler to which all data will be loaded
|
|
|
|
IHandlerBase * handler;
|
|
|
|
std::string objectName;
|
|
|
|
|
|
|
|
/// contains all loaded H3 data
|
|
|
|
std::vector<JsonNode> originalData;
|
|
|
|
std::map<std::string, ModInfo> modData;
|
2013-04-21 15:49:26 +03:00
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
ContentTypeHandler(IHandlerBase * handler, std::string objectName);
|
|
|
|
|
|
|
|
/// local version of methods in ContentHandler
|
|
|
|
/// returns true if loading was successful
|
|
|
|
bool preloadModData(std::string modName, std::vector<std::string> fileList, bool validate);
|
|
|
|
bool loadMod(std::string modName, bool validate);
|
|
|
|
void loadCustom();
|
|
|
|
void afterLoadFinalization();
|
|
|
|
};
|
|
|
|
|
|
|
|
/// class used to load all game data into handlers. Used only during loading
|
|
|
|
class DLL_LINKAGE CContentHandler
|
|
|
|
{
|
2013-11-11 23:11:51 +03:00
|
|
|
/// preloads all data from fileList as data from modName.
|
|
|
|
bool preloadModData(std::string modName, JsonNode modConfig, bool validate);
|
|
|
|
|
|
|
|
/// actually loads data in mod
|
|
|
|
bool loadMod(std::string modName, bool validate);
|
|
|
|
|
2013-04-21 15:49:26 +03:00
|
|
|
std::map<std::string, ContentTypeHandler> handlers;
|
|
|
|
public:
|
|
|
|
CContentHandler();
|
|
|
|
|
2017-07-20 06:08:49 +02:00
|
|
|
void init();
|
|
|
|
|
2013-11-08 23:36:26 +03:00
|
|
|
/// preloads all data from fileList as data from modName.
|
2013-11-11 23:11:51 +03:00
|
|
|
void preloadData(CModInfo & mod);
|
2013-04-21 15:49:26 +03:00
|
|
|
|
|
|
|
/// actually loads data in mod
|
2013-11-11 23:11:51 +03:00
|
|
|
void load(CModInfo & mod);
|
2013-07-21 17:19:29 +03:00
|
|
|
|
2016-11-13 12:38:42 +02:00
|
|
|
void loadCustom();
|
|
|
|
|
2013-07-21 17:19:29 +03:00
|
|
|
/// all data was loaded, time for final validation / integration
|
|
|
|
void afterLoadFinalization();
|
2017-07-20 06:08:49 +02:00
|
|
|
|
|
|
|
const ContentTypeHandler & operator[] (const std::string & name) const;
|
2012-12-03 19:00:17 +03:00
|
|
|
};
|
|
|
|
|
2012-12-12 14:13:57 +03:00
|
|
|
typedef std::string TModID;
|
2012-08-10 16:07:53 +03:00
|
|
|
|
|
|
|
class DLL_LINKAGE CModInfo
|
|
|
|
{
|
|
|
|
public:
|
2013-11-11 23:11:51 +03:00
|
|
|
enum EValidationStatus
|
|
|
|
{
|
|
|
|
PENDING,
|
|
|
|
FAILED,
|
|
|
|
PASSED
|
|
|
|
};
|
2022-09-17 15:43:59 +02:00
|
|
|
|
|
|
|
struct Version
|
|
|
|
{
|
|
|
|
int major = 0;
|
|
|
|
int minor = 0;
|
|
|
|
int patch = 0;
|
|
|
|
|
|
|
|
Version() = default;
|
|
|
|
Version(int mj, int mi, int p): major(mj), minor(mi), patch(p) {}
|
|
|
|
|
|
|
|
static Version GameVersion();
|
|
|
|
static Version fromString(std::string from);
|
|
|
|
std::string toString() const;
|
|
|
|
|
|
|
|
bool compatible(const Version & other, bool checkMinor = false, bool checkPatch = false) const;
|
|
|
|
bool isNull() const;
|
|
|
|
|
|
|
|
template <typename Handler> void serialize(Handler &h, const int version)
|
|
|
|
{
|
|
|
|
h & major;
|
|
|
|
h & minor;
|
|
|
|
h & patch;
|
|
|
|
}
|
|
|
|
};
|
2013-11-11 23:11:51 +03:00
|
|
|
|
2012-12-12 14:13:57 +03:00
|
|
|
/// identifier, identical to name of folder with mod
|
|
|
|
std::string identifier;
|
|
|
|
|
|
|
|
/// human-readable strings
|
|
|
|
std::string name;
|
|
|
|
std::string description;
|
2022-09-17 15:43:59 +02:00
|
|
|
|
|
|
|
/// version of the mod
|
|
|
|
Version version;
|
|
|
|
|
2022-09-18 23:18:17 +02:00
|
|
|
/// vcmi versions compatible with the mod
|
|
|
|
|
2022-09-17 15:43:59 +02:00
|
|
|
Version vcmiCompatibleMin, vcmiCompatibleMax;
|
2012-12-12 14:13:57 +03:00
|
|
|
|
2013-01-10 21:53:49 +03:00
|
|
|
/// list of mods that should be loaded before this one
|
|
|
|
std::set <TModID> dependencies;
|
2012-12-12 14:13:57 +03:00
|
|
|
|
2013-01-10 21:53:49 +03:00
|
|
|
/// list of mods that can't be used in the same time as this one
|
|
|
|
std::set <TModID> conflicts;
|
2012-08-10 16:07:53 +03:00
|
|
|
|
2013-11-08 23:36:26 +03:00
|
|
|
/// CRC-32 checksum of the mod
|
|
|
|
ui32 checksum;
|
|
|
|
|
2013-11-09 22:10:16 +03:00
|
|
|
/// true if mod is enabled
|
|
|
|
bool enabled;
|
|
|
|
|
2013-11-11 23:11:51 +03:00
|
|
|
EValidationStatus validation;
|
|
|
|
|
|
|
|
JsonNode config;
|
|
|
|
|
2016-11-27 21:07:01 +02:00
|
|
|
CModInfo();
|
2013-11-11 23:11:51 +03:00
|
|
|
CModInfo(std::string identifier, const JsonNode & local, const JsonNode & config);
|
|
|
|
|
2014-03-15 13:57:34 +03:00
|
|
|
JsonNode saveLocalData() const;
|
2013-11-11 23:11:51 +03:00
|
|
|
void updateChecksum(ui32 newChecksum);
|
2012-08-10 16:07:53 +03:00
|
|
|
|
2014-03-15 13:57:34 +03:00
|
|
|
static std::string getModDir(std::string name);
|
|
|
|
static std::string getModFile(std::string name);
|
|
|
|
|
2013-11-11 23:11:51 +03:00
|
|
|
private:
|
|
|
|
void loadLocalData(const JsonNode & data);
|
2012-08-10 16:07:53 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
class DLL_LINKAGE CModHandler
|
|
|
|
{
|
2012-11-13 14:52:23 +03:00
|
|
|
std::map <TModID, CModInfo> allMods;
|
2012-12-12 14:13:57 +03:00
|
|
|
std::vector <TModID> activeMods;//active mods, in order in which they were loaded
|
2013-11-11 23:11:51 +03:00
|
|
|
CModInfo coreMod;
|
2012-08-10 16:07:53 +03:00
|
|
|
|
2013-11-08 23:36:26 +03:00
|
|
|
void loadConfigFromFile(std::string name);
|
2013-01-10 21:53:49 +03:00
|
|
|
|
|
|
|
bool hasCircularDependency(TModID mod, std::set <TModID> currentList = std::set <TModID>()) const;
|
|
|
|
|
2013-04-02 20:06:43 +03:00
|
|
|
//returns false if mod list is incorrect and prints error to console. Possible errors are:
|
2013-01-10 21:53:49 +03:00
|
|
|
// - missing dependency mod
|
|
|
|
// - conflicting mod in load order
|
|
|
|
// - circular dependencies
|
|
|
|
bool checkDependencies(const std::vector <TModID> & input) const;
|
|
|
|
|
2021-04-10 17:23:58 +02:00
|
|
|
/**
|
|
|
|
* 1. Set apart mods with resolved dependencies from mods which have unresolved dependencies
|
|
|
|
* 2. Sort resolved mods using topological algorithm
|
|
|
|
* 3. Log all problem mods and their unresolved dependencies
|
|
|
|
*
|
|
|
|
* @param modsToResolve list of valid mod IDs (checkDependencies returned true - TODO: Clarify it.)
|
|
|
|
* @return a vector of the topologically sorted resolved mods: child nodes (dependent mods) have greater index than parents
|
|
|
|
*/
|
|
|
|
std::vector <TModID> validateAndSortDependencies(std::vector <TModID> modsToResolve) const;
|
2014-03-15 13:57:34 +03:00
|
|
|
|
|
|
|
std::vector<std::string> getModList(std::string path);
|
2017-07-20 06:08:49 +02:00
|
|
|
void loadMods(std::string path, std::string parent, const JsonNode & modSettings, bool enableMods);
|
|
|
|
void loadOneMod(std::string modName, std::string parent, const JsonNode & modSettings, bool enableMods);
|
2012-12-03 19:00:17 +03:00
|
|
|
public:
|
2022-12-07 15:18:19 +02:00
|
|
|
|
|
|
|
/// returns true if scope is reserved for internal use and can not be used by mods
|
|
|
|
static bool isScopeReserved(const TModID & scope);
|
|
|
|
|
|
|
|
/// reserved scope name for referencing built-in (e.g. H3) objects
|
|
|
|
static const TModID & scopeBuiltin();
|
|
|
|
|
|
|
|
/// reserved scope name for accessing objects from any loaded mod
|
|
|
|
static const TModID & scopeGame();
|
|
|
|
|
|
|
|
/// reserved scope name for accessing object for map loading
|
|
|
|
static const TModID & scopeMap();
|
|
|
|
|
2022-09-23 13:20:11 +02:00
|
|
|
class DLL_LINKAGE Incompatibility: public std::exception
|
2022-09-17 15:43:59 +02:00
|
|
|
{
|
|
|
|
public:
|
2022-09-23 13:02:19 +02:00
|
|
|
using StringPair = std::pair<const std::string, const std::string>;
|
|
|
|
using ModList = std::list<StringPair>;
|
|
|
|
|
|
|
|
Incompatibility(ModList && _missingMods):
|
|
|
|
missingMods(std::move(_missingMods))
|
|
|
|
{
|
|
|
|
std::ostringstream _ss;
|
|
|
|
for(auto & m : missingMods)
|
|
|
|
_ss << m.first << ' ' << m.second << std::endl;
|
|
|
|
message = _ss.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
const char * what() const noexcept override
|
|
|
|
{
|
|
|
|
return message.c_str();
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
//list of mods required to load the game
|
|
|
|
// first: mod name
|
|
|
|
// second: mod version
|
|
|
|
const ModList missingMods;
|
|
|
|
std::string message;
|
2022-09-17 15:43:59 +02:00
|
|
|
};
|
2013-04-02 20:06:43 +03:00
|
|
|
|
2012-12-03 19:00:17 +03:00
|
|
|
CIdentifierStorage identifiers;
|
|
|
|
|
2020-10-09 23:31:23 +02:00
|
|
|
std::shared_ptr<CContentHandler> content; //(!)Do not serialize
|
2017-07-20 06:08:49 +02:00
|
|
|
|
2012-12-12 14:13:57 +03:00
|
|
|
/// receives list of available mods and trying to load mod.json from all of them
|
2013-11-09 22:10:16 +03:00
|
|
|
void initializeConfig();
|
2017-07-20 06:08:49 +02:00
|
|
|
void loadMods(bool onlyEssential = false);
|
2014-03-15 13:57:34 +03:00
|
|
|
void loadModFilesystems();
|
2012-11-13 14:52:23 +03:00
|
|
|
|
2022-03-21 00:33:04 +02:00
|
|
|
std::set<TModID> getModDependencies(TModID modId, bool & isModFound);
|
2013-04-25 17:03:35 +03:00
|
|
|
|
2014-03-15 13:57:34 +03:00
|
|
|
/// returns list of all (active) mods
|
|
|
|
std::vector<std::string> getAllMods();
|
|
|
|
std::vector<std::string> getActiveMods();
|
|
|
|
|
2012-11-13 14:52:23 +03:00
|
|
|
/// load content from all available mods
|
2013-11-09 22:10:16 +03:00
|
|
|
void load();
|
2017-07-20 06:08:49 +02:00
|
|
|
void afterLoad(bool onlyEssential);
|
2012-11-13 14:52:23 +03:00
|
|
|
|
2012-08-11 12:06:23 +03:00
|
|
|
struct DLL_LINKAGE hardcodedFeatures
|
|
|
|
{
|
2013-04-26 00:50:55 +03:00
|
|
|
JsonNode data;
|
|
|
|
|
2012-08-11 12:06:23 +03:00
|
|
|
int CREEP_SIZE; // neutral stacks won't grow beyond this number
|
|
|
|
int WEEKLY_GROWTH; //percent
|
2015-11-16 16:38:42 +02:00
|
|
|
int NEUTRAL_STACK_EXP;
|
2012-09-05 15:49:23 +03:00
|
|
|
int MAX_BUILDING_PER_TURN;
|
2012-08-11 12:06:23 +03:00
|
|
|
bool DWELLINGS_ACCUMULATE_CREATURES;
|
|
|
|
bool ALL_CREATURES_GET_DOUBLE_MONTHS;
|
2014-04-27 09:43:42 +03:00
|
|
|
int MAX_HEROES_AVAILABLE_PER_PLAYER;
|
|
|
|
int MAX_HEROES_ON_MAP_PER_PLAYER;
|
2016-01-27 10:38:35 +02:00
|
|
|
bool WINNING_HERO_WITH_NO_TROOPS_RETREATS;
|
2017-07-14 23:46:18 +02:00
|
|
|
bool BLACK_MARKET_MONTHLY_ARTIFACTS_CHANGE;
|
2019-03-17 19:27:05 +02:00
|
|
|
bool NO_RANDOM_SPECIAL_WEEKS_AND_MONTHS;
|
2022-12-31 17:25:40 +02:00
|
|
|
double ATTACK_POINT_DMG_MULTIPLIER;
|
|
|
|
double ATTACK_POINTS_DMG_MULTIPLIER_CAP;
|
|
|
|
double DEFENSE_POINT_DMG_MULTIPLIER;
|
|
|
|
double DEFENSE_POINTS_DMG_MULTIPLIER_CAP;
|
2012-08-11 12:06:23 +03:00
|
|
|
|
|
|
|
template <typename Handler> void serialize(Handler &h, const int version)
|
|
|
|
{
|
2017-07-31 15:35:42 +02:00
|
|
|
h & data;
|
|
|
|
h & CREEP_SIZE;
|
|
|
|
h & WEEKLY_GROWTH;
|
|
|
|
h & NEUTRAL_STACK_EXP;
|
|
|
|
h & MAX_BUILDING_PER_TURN;
|
|
|
|
h & DWELLINGS_ACCUMULATE_CREATURES;
|
|
|
|
h & ALL_CREATURES_GET_DOUBLE_MONTHS;
|
|
|
|
h & MAX_HEROES_AVAILABLE_PER_PLAYER;
|
|
|
|
h & MAX_HEROES_ON_MAP_PER_PLAYER;
|
2022-06-20 16:39:50 +02:00
|
|
|
h & WINNING_HERO_WITH_NO_TROOPS_RETREATS;
|
|
|
|
h & BLACK_MARKET_MONTHLY_ARTIFACTS_CHANGE;
|
|
|
|
h & NO_RANDOM_SPECIAL_WEEKS_AND_MONTHS;
|
2022-12-31 17:25:40 +02:00
|
|
|
h & ATTACK_POINT_DMG_MULTIPLIER;
|
|
|
|
h & ATTACK_POINTS_DMG_MULTIPLIER_CAP;
|
|
|
|
h & DEFENSE_POINT_DMG_MULTIPLIER;
|
|
|
|
h & DEFENSE_POINTS_DMG_MULTIPLIER_CAP;
|
2012-08-11 12:06:23 +03:00
|
|
|
}
|
|
|
|
} settings;
|
|
|
|
|
2012-08-24 12:37:52 +03:00
|
|
|
struct DLL_LINKAGE gameModules
|
|
|
|
{
|
|
|
|
bool STACK_EXP;
|
|
|
|
bool STACK_ARTIFACT;
|
|
|
|
bool COMMANDERS;
|
|
|
|
bool MITHRIL;
|
|
|
|
|
|
|
|
template <typename Handler> void serialize(Handler &h, const int version)
|
|
|
|
{
|
2017-07-31 15:35:42 +02:00
|
|
|
h & STACK_EXP;
|
|
|
|
h & STACK_ARTIFACT;
|
|
|
|
h & COMMANDERS;
|
|
|
|
h & MITHRIL;
|
2012-08-24 12:37:52 +03:00
|
|
|
}
|
|
|
|
} modules;
|
|
|
|
|
2012-08-10 16:07:53 +03:00
|
|
|
CModHandler();
|
2016-08-30 10:45:05 +02:00
|
|
|
virtual ~CModHandler();
|
2012-08-10 16:07:53 +03:00
|
|
|
|
2016-11-13 12:38:42 +02:00
|
|
|
static std::string normalizeIdentifier(const std::string & scope, const std::string & remoteScope, const std::string & identifier);
|
|
|
|
|
|
|
|
static void parseIdentifier(const std::string & fullIdentifier, std::string & scope, std::string & type, std::string & identifier);
|
|
|
|
|
|
|
|
static std::string makeFullIdentifier(const std::string & scope, const std::string & type, const std::string & identifier);
|
2015-11-16 16:38:42 +02:00
|
|
|
|
2012-08-10 16:07:53 +03:00
|
|
|
template <typename Handler> void serialize(Handler &h, const int version)
|
|
|
|
{
|
2022-09-17 15:43:59 +02:00
|
|
|
if(h.saving)
|
|
|
|
{
|
|
|
|
h & activeMods;
|
2022-09-18 23:18:17 +02:00
|
|
|
for(const auto & m : activeMods)
|
2022-09-17 15:43:59 +02:00
|
|
|
h & allMods[m].version;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2022-09-23 10:34:44 +02:00
|
|
|
loadMods();
|
2022-09-17 15:43:59 +02:00
|
|
|
std::vector<TModID> newActiveMods;
|
|
|
|
h & newActiveMods;
|
2022-09-23 13:02:19 +02:00
|
|
|
|
|
|
|
Incompatibility::ModList missingMods;
|
2022-09-24 11:03:46 +02:00
|
|
|
for(const auto & m : newActiveMods)
|
|
|
|
|
2022-09-17 15:43:59 +02:00
|
|
|
{
|
|
|
|
CModInfo::Version mver;
|
|
|
|
h & mver;
|
2022-09-23 13:02:19 +02:00
|
|
|
|
|
|
|
if(allMods.count(m) && (allMods[m].version.isNull() || mver.isNull() || allMods[m].version.compatible(mver)))
|
|
|
|
allMods[m].enabled = true;
|
|
|
|
else
|
|
|
|
missingMods.emplace_back(m, mver.toString());
|
2022-09-17 15:43:59 +02:00
|
|
|
}
|
2022-09-23 13:02:19 +02:00
|
|
|
|
|
|
|
if(!missingMods.empty())
|
|
|
|
throw Incompatibility(std::move(missingMods));
|
|
|
|
|
2022-09-17 15:43:59 +02:00
|
|
|
std::swap(activeMods, newActiveMods);
|
|
|
|
}
|
|
|
|
|
2017-07-31 15:35:42 +02:00
|
|
|
h & settings;
|
|
|
|
h & modules;
|
|
|
|
h & identifiers;
|
2012-08-10 16:07:53 +03:00
|
|
|
}
|
2012-08-10 18:16:42 +03:00
|
|
|
};
|
2022-07-26 15:07:42 +02:00
|
|
|
|
|
|
|
VCMI_LIB_NAMESPACE_END
|