|
|
@@ -10,316 +10,49 @@
|
|
|
#include "StdInc.h"
|
|
|
#include "CModHandler.h"
|
|
|
|
|
|
-#include "CModInfo.h"
|
|
|
-#include "ModScope.h"
|
|
|
#include "ContentTypeHandler.h"
|
|
|
#include "IdentifierStorage.h"
|
|
|
-#include "ModIncompatibility.h"
|
|
|
+#include "ModDescription.h"
|
|
|
+#include "ModManager.h"
|
|
|
+#include "ModScope.h"
|
|
|
|
|
|
-#include "../CCreatureHandler.h"
|
|
|
#include "../CConfigHandler.h"
|
|
|
-#include "../CStopWatch.h"
|
|
|
+#include "../CCreatureHandler.h"
|
|
|
#include "../GameSettings.h"
|
|
|
-#include "../ScriptHandler.h"
|
|
|
-#include "../constants/StringConstants.h"
|
|
|
+#include "../VCMI_Lib.h"
|
|
|
#include "../filesystem/Filesystem.h"
|
|
|
#include "../json/JsonUtils.h"
|
|
|
-#include "../spells/CSpellHandler.h"
|
|
|
#include "../texts/CGeneralTextHandler.h"
|
|
|
#include "../texts/Languages.h"
|
|
|
-#include "../VCMI_Lib.h"
|
|
|
|
|
|
VCMI_LIB_NAMESPACE_BEGIN
|
|
|
|
|
|
-static JsonNode loadModSettings(const JsonPath & path)
|
|
|
-{
|
|
|
- if (CResourceHandler::get("local")->existsResource(ResourcePath(path)))
|
|
|
- {
|
|
|
- return JsonNode(path);
|
|
|
- }
|
|
|
- // Probably new install. Create initial configuration
|
|
|
- CResourceHandler::get("local")->createResource(path.getOriginalName() + ".json");
|
|
|
- return JsonNode();
|
|
|
-}
|
|
|
-
|
|
|
CModHandler::CModHandler()
|
|
|
: content(std::make_shared<CContentHandler>())
|
|
|
- , coreMod(std::make_unique<CModInfo>())
|
|
|
+ , modManager(std::make_unique<ModManager>())
|
|
|
{
|
|
|
}
|
|
|
|
|
|
CModHandler::~CModHandler() = default;
|
|
|
|
|
|
-// currentList is passed by value to get current list of depending mods
|
|
|
-bool CModHandler::hasCircularDependency(const TModID & modID, std::set<TModID> currentList) const
|
|
|
-{
|
|
|
- const CModInfo & mod = allMods.at(modID);
|
|
|
-
|
|
|
- // Mod already present? We found a loop
|
|
|
- if (vstd::contains(currentList, modID))
|
|
|
- {
|
|
|
- logMod->error("Error: Circular dependency detected! Printing dependency list:");
|
|
|
- logMod->error("\t%s -> ", mod.getVerificationInfo().name);
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- currentList.insert(modID);
|
|
|
-
|
|
|
- // recursively check every dependency of this mod
|
|
|
- for(const TModID & dependency : mod.dependencies)
|
|
|
- {
|
|
|
- if (hasCircularDependency(dependency, currentList))
|
|
|
- {
|
|
|
- logMod->error("\t%s ->\n", mod.getVerificationInfo().name); // conflict detected, print dependency list
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-// Returned vector affects the resource loaders call order (see CFilesystemList::load).
|
|
|
-// The loaders call order matters when dependent mod overrides resources in its dependencies.
|
|
|
-std::vector <TModID> CModHandler::validateAndSortDependencies(std::vector <TModID> modsToResolve) const
|
|
|
-{
|
|
|
- // Topological sort algorithm.
|
|
|
- // TODO: Investigate possible ways to improve performance.
|
|
|
- boost::range::sort(modsToResolve); // Sort mods per name
|
|
|
- std::vector <TModID> sortedValidMods; // Vector keeps order of elements (LIFO)
|
|
|
- sortedValidMods.reserve(modsToResolve.size()); // push_back calls won't cause memory reallocation
|
|
|
- std::set <TModID> resolvedModIDs; // Use a set for validation for performance reason, but set does not keep order of elements
|
|
|
- std::set <TModID> notResolvedModIDs(modsToResolve.begin(), modsToResolve.end()); // Use a set for validation for performance reason
|
|
|
-
|
|
|
- // Mod is resolved if it has no dependencies or all its dependencies are already resolved
|
|
|
- auto isResolved = [&](const CModInfo & mod) -> bool
|
|
|
- {
|
|
|
- if(mod.dependencies.size() > resolvedModIDs.size())
|
|
|
- return false;
|
|
|
-
|
|
|
- for(const TModID & dependency : mod.dependencies)
|
|
|
- {
|
|
|
- if(!vstd::contains(resolvedModIDs, dependency))
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- for(const TModID & softDependency : mod.softDependencies)
|
|
|
- {
|
|
|
- if(vstd::contains(notResolvedModIDs, softDependency))
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- for(const TModID & conflict : mod.conflicts)
|
|
|
- {
|
|
|
- if(vstd::contains(resolvedModIDs, conflict))
|
|
|
- return false;
|
|
|
- }
|
|
|
- for(const TModID & reverseConflict : resolvedModIDs)
|
|
|
- {
|
|
|
- if (vstd::contains(allMods.at(reverseConflict).conflicts, mod.identifier))
|
|
|
- return false;
|
|
|
- }
|
|
|
- return true;
|
|
|
- };
|
|
|
-
|
|
|
- while(true)
|
|
|
- {
|
|
|
- std::set <TModID> resolvedOnCurrentTreeLevel;
|
|
|
- for(auto it = modsToResolve.begin(); it != modsToResolve.end();) // One iteration - one level of mods tree
|
|
|
- {
|
|
|
- if(isResolved(allMods.at(*it)))
|
|
|
- {
|
|
|
- resolvedOnCurrentTreeLevel.insert(*it); // Not to the resolvedModIDs, so current node children will be resolved on the next iteration
|
|
|
- sortedValidMods.push_back(*it);
|
|
|
- it = modsToResolve.erase(it);
|
|
|
- continue;
|
|
|
- }
|
|
|
- it++;
|
|
|
- }
|
|
|
- if(!resolvedOnCurrentTreeLevel.empty())
|
|
|
- {
|
|
|
- resolvedModIDs.insert(resolvedOnCurrentTreeLevel.begin(), resolvedOnCurrentTreeLevel.end());
|
|
|
- for(const auto & it : resolvedOnCurrentTreeLevel)
|
|
|
- notResolvedModIDs.erase(it);
|
|
|
- continue;
|
|
|
- }
|
|
|
- // If there are no valid mods on the current mods tree level, no more mod can be resolved, should be ended.
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- modLoadErrors = std::make_unique<MetaString>();
|
|
|
-
|
|
|
- auto addErrorMessage = [this](const std::string & textID, const std::string & brokenModID, const std::string & missingModID)
|
|
|
- {
|
|
|
- modLoadErrors->appendTextID(textID);
|
|
|
-
|
|
|
- if (allMods.count(brokenModID))
|
|
|
- modLoadErrors->replaceRawString(allMods.at(brokenModID).getVerificationInfo().name);
|
|
|
- else
|
|
|
- modLoadErrors->replaceRawString(brokenModID);
|
|
|
-
|
|
|
- if (allMods.count(missingModID))
|
|
|
- modLoadErrors->replaceRawString(allMods.at(missingModID).getVerificationInfo().name);
|
|
|
- else
|
|
|
- modLoadErrors->replaceRawString(missingModID);
|
|
|
-
|
|
|
- };
|
|
|
-
|
|
|
- // Left mods have unresolved dependencies, output all to log.
|
|
|
- for(const auto & brokenModID : modsToResolve)
|
|
|
- {
|
|
|
- const CModInfo & brokenMod = allMods.at(brokenModID);
|
|
|
- bool showErrorMessage = false;
|
|
|
- for(const TModID & dependency : brokenMod.dependencies)
|
|
|
- {
|
|
|
- if(!vstd::contains(resolvedModIDs, dependency) && brokenMod.config["modType"].String() != "Compatibility")
|
|
|
- {
|
|
|
- addErrorMessage("vcmi.server.errors.modNoDependency", brokenModID, dependency);
|
|
|
- showErrorMessage = true;
|
|
|
- }
|
|
|
- }
|
|
|
- for(const TModID & conflict : brokenMod.conflicts)
|
|
|
- {
|
|
|
- if(vstd::contains(resolvedModIDs, conflict))
|
|
|
- {
|
|
|
- addErrorMessage("vcmi.server.errors.modConflict", brokenModID, conflict);
|
|
|
- showErrorMessage = true;
|
|
|
- }
|
|
|
- }
|
|
|
- for(const TModID & reverseConflict : resolvedModIDs)
|
|
|
- {
|
|
|
- if (vstd::contains(allMods.at(reverseConflict).conflicts, brokenModID))
|
|
|
- {
|
|
|
- addErrorMessage("vcmi.server.errors.modConflict", brokenModID, reverseConflict);
|
|
|
- showErrorMessage = true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // some mods may in a (soft) dependency loop.
|
|
|
- if(!showErrorMessage && brokenMod.config["modType"].String() != "Compatibility")
|
|
|
- {
|
|
|
- modLoadErrors->appendTextID("vcmi.server.errors.modDependencyLoop");
|
|
|
- if (allMods.count(brokenModID))
|
|
|
- modLoadErrors->replaceRawString(allMods.at(brokenModID).getVerificationInfo().name);
|
|
|
- else
|
|
|
- modLoadErrors->replaceRawString(brokenModID);
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
- return sortedValidMods;
|
|
|
-}
|
|
|
-
|
|
|
-std::vector<std::string> CModHandler::getModList(const std::string & path) const
|
|
|
-{
|
|
|
- std::string modDir = boost::to_upper_copy(path + "MODS/");
|
|
|
- size_t depth = boost::range::count(modDir, '/');
|
|
|
-
|
|
|
- auto list = CResourceHandler::get("initial")->getFilteredFiles([&](const ResourcePath & id) -> bool
|
|
|
- {
|
|
|
- if (id.getType() != EResType::DIRECTORY)
|
|
|
- return false;
|
|
|
- if (!boost::algorithm::starts_with(id.getName(), modDir))
|
|
|
- return false;
|
|
|
- if (boost::range::count(id.getName(), '/') != depth )
|
|
|
- return false;
|
|
|
- return true;
|
|
|
- });
|
|
|
-
|
|
|
- //storage for found mods
|
|
|
- std::vector<std::string> foundMods;
|
|
|
- for(const auto & entry : list)
|
|
|
- {
|
|
|
- std::string name = entry.getName();
|
|
|
- name.erase(0, modDir.size()); //Remove path prefix
|
|
|
-
|
|
|
- if (!name.empty())
|
|
|
- foundMods.push_back(name);
|
|
|
- }
|
|
|
- return foundMods;
|
|
|
-}
|
|
|
-
|
|
|
-
|
|
|
-
|
|
|
-void CModHandler::loadMods(const std::string & path, const std::string & parent, const JsonNode & modSettings, const std::vector<TModID> & modsToActivate, bool enableMods)
|
|
|
-{
|
|
|
- for(const std::string & modName : getModList(path))
|
|
|
- loadOneMod(modName, parent, modSettings, modsToActivate, enableMods);
|
|
|
-}
|
|
|
-
|
|
|
-void CModHandler::loadOneMod(std::string modName, const std::string & parent, const JsonNode & modSettings, const std::vector<TModID> & modsToActivate, bool enableMods)
|
|
|
-{
|
|
|
- boost::to_lower(modName);
|
|
|
- std::string modFullName = parent.empty() ? modName : parent + '.' + modName;
|
|
|
-
|
|
|
- if ( ModScope::isScopeReserved(modFullName))
|
|
|
- {
|
|
|
- logMod->error("Can not load mod %s - this name is reserved for internal use!", modFullName);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if(CResourceHandler::get("initial")->existsResource(CModInfo::getModFile(modFullName)))
|
|
|
- {
|
|
|
- bool thisModActive = vstd::contains(modsToActivate, modFullName);
|
|
|
- CModInfo mod(modFullName, modSettings[modName], JsonNode(CModInfo::getModFile(modFullName)), thisModActive);
|
|
|
- if (!parent.empty()) // this is submod, add parent to dependencies
|
|
|
- mod.dependencies.insert(parent);
|
|
|
-
|
|
|
- allMods[modFullName] = mod;
|
|
|
- if (mod.isEnabled() && enableMods)
|
|
|
- activeMods.push_back(modFullName);
|
|
|
-
|
|
|
- loadMods(CModInfo::getModDir(modFullName) + '/', modFullName, modSettings[modName]["mods"], modsToActivate, enableMods && mod.isEnabled());
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void CModHandler::loadMods()
|
|
|
-{
|
|
|
- JsonNode modConfig;
|
|
|
-
|
|
|
- modConfig = loadModSettings(JsonPath::builtin("config/modSettings.json"));
|
|
|
- const JsonNode & modSettings = modConfig["activeMods"];
|
|
|
- const std::string & currentPresetName = modConfig["activePreset"].String();
|
|
|
- const JsonNode & currentPreset = modConfig["presets"][currentPresetName];
|
|
|
- const JsonNode & modsToActivateJson = currentPreset["mods"];
|
|
|
- std::vector<TModID> modsToActivate = modsToActivateJson.convertTo<std::vector<TModID>>();
|
|
|
-
|
|
|
- for(const auto & settings : currentPreset["settings"].Struct())
|
|
|
- {
|
|
|
- if (!vstd::contains(modsToActivate, settings.first))
|
|
|
- continue; // settings for inactive mod
|
|
|
-
|
|
|
- for (const auto & submod : settings.second.Struct())
|
|
|
- {
|
|
|
- if (submod.second.Bool())
|
|
|
- modsToActivate.push_back(settings.first + '.' + submod.first);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- loadMods("", "", modSettings, modsToActivate, true);
|
|
|
-
|
|
|
- coreMod = std::make_unique<CModInfo>(ModScope::scopeBuiltin(), modConfig[ModScope::scopeBuiltin()], JsonNode(JsonPath::builtin("config/gameConfig.json")), true);
|
|
|
-}
|
|
|
-
|
|
|
std::vector<std::string> CModHandler::getAllMods() const
|
|
|
{
|
|
|
- std::vector<std::string> modlist;
|
|
|
- modlist.reserve(allMods.size());
|
|
|
- for (auto & entry : allMods)
|
|
|
- modlist.push_back(entry.first);
|
|
|
- return modlist;
|
|
|
+ return modManager->getActiveMods();// TODO: currently identical to active
|
|
|
}
|
|
|
|
|
|
std::vector<std::string> CModHandler::getActiveMods() const
|
|
|
{
|
|
|
- return activeMods;
|
|
|
+ return modManager->getActiveMods();
|
|
|
}
|
|
|
|
|
|
std::string CModHandler::getModLoadErrors() const
|
|
|
{
|
|
|
- return modLoadErrors->toString();
|
|
|
+ return ""; // TODO: modLoadErrors->toString();
|
|
|
}
|
|
|
|
|
|
-const CModInfo & CModHandler::getModInfo(const TModID & modId) const
|
|
|
+const ModDescription & CModHandler::getModInfo(const TModID & modId) const
|
|
|
{
|
|
|
- return allMods.at(modId);
|
|
|
+ return modManager->getModDescription(modId);
|
|
|
}
|
|
|
|
|
|
static JsonNode genDefaultFS()
|
|
|
@@ -334,86 +67,95 @@ static JsonNode genDefaultFS()
|
|
|
return defaultFS;
|
|
|
}
|
|
|
|
|
|
+static std::string getModDirectory(const TModID & modName)
|
|
|
+{
|
|
|
+ std::string result = modName;
|
|
|
+ boost::to_upper(result);
|
|
|
+ boost::algorithm::replace_all(result, ".", "/MODS/");
|
|
|
+ return "MODS/" + result;
|
|
|
+}
|
|
|
+
|
|
|
static ISimpleResourceLoader * genModFilesystem(const std::string & modName, const JsonNode & conf)
|
|
|
{
|
|
|
static const JsonNode defaultFS = genDefaultFS();
|
|
|
|
|
|
- if (!conf["filesystem"].isNull())
|
|
|
- return CResourceHandler::createFileSystem(CModInfo::getModDir(modName), conf["filesystem"]);
|
|
|
+ if (!conf.isNull())
|
|
|
+ return CResourceHandler::createFileSystem(getModDirectory(modName), conf);
|
|
|
else
|
|
|
- return CResourceHandler::createFileSystem(CModInfo::getModDir(modName), defaultFS);
|
|
|
+ return CResourceHandler::createFileSystem(getModDirectory(modName), defaultFS);
|
|
|
}
|
|
|
|
|
|
-static ui32 calculateModChecksum(const std::string & modName, ISimpleResourceLoader * filesystem)
|
|
|
-{
|
|
|
- boost::crc_32_type modChecksum;
|
|
|
- // first - add current VCMI version into checksum to force re-validation on VCMI updates
|
|
|
- modChecksum.process_bytes(reinterpret_cast<const void*>(GameConstants::VCMI_VERSION.data()), GameConstants::VCMI_VERSION.size());
|
|
|
-
|
|
|
- // second - add mod.json into checksum because filesystem does not contains this file
|
|
|
- // FIXME: remove workaround for core mod
|
|
|
- if (modName != ModScope::scopeBuiltin())
|
|
|
- {
|
|
|
- auto modConfFile = CModInfo::getModFile(modName);
|
|
|
- ui32 configChecksum = CResourceHandler::get("initial")->load(modConfFile)->calculateCRC32();
|
|
|
- modChecksum.process_bytes(reinterpret_cast<const void *>(&configChecksum), sizeof(configChecksum));
|
|
|
- }
|
|
|
- // third - add all detected text files from this mod into checksum
|
|
|
- auto files = filesystem->getFilteredFiles([](const ResourcePath & resID)
|
|
|
- {
|
|
|
- return (resID.getType() == EResType::TEXT || resID.getType() == EResType::JSON) &&
|
|
|
- ( boost::starts_with(resID.getName(), "DATA") || boost::starts_with(resID.getName(), "CONFIG"));
|
|
|
- });
|
|
|
-
|
|
|
- for (const ResourcePath & file : files)
|
|
|
- {
|
|
|
- ui32 fileChecksum = filesystem->load(file)->calculateCRC32();
|
|
|
- modChecksum.process_bytes(reinterpret_cast<const void *>(&fileChecksum), sizeof(fileChecksum));
|
|
|
- }
|
|
|
- return modChecksum.checksum();
|
|
|
-}
|
|
|
+//static ui32 calculateModChecksum(const std::string & modName, ISimpleResourceLoader * filesystem)
|
|
|
+//{
|
|
|
+// boost::crc_32_type modChecksum;
|
|
|
+// // first - add current VCMI version into checksum to force re-validation on VCMI updates
|
|
|
+// modChecksum.process_bytes(reinterpret_cast<const void*>(GameConstants::VCMI_VERSION.data()), GameConstants::VCMI_VERSION.size());
|
|
|
+//
|
|
|
+// // second - add mod.json into checksum because filesystem does not contains this file
|
|
|
+// // FIXME: remove workaround for core mod
|
|
|
+// if (modName != ModScope::scopeBuiltin())
|
|
|
+// {
|
|
|
+// auto modConfFile = CModInfo::getModFile(modName);
|
|
|
+// ui32 configChecksum = CResourceHandler::get("initial")->load(modConfFile)->calculateCRC32();
|
|
|
+// modChecksum.process_bytes(reinterpret_cast<const void *>(&configChecksum), sizeof(configChecksum));
|
|
|
+// }
|
|
|
+// // third - add all detected text files from this mod into checksum
|
|
|
+// auto files = filesystem->getFilteredFiles([](const ResourcePath & resID)
|
|
|
+// {
|
|
|
+// return (resID.getType() == EResType::TEXT || resID.getType() == EResType::JSON) &&
|
|
|
+// ( boost::starts_with(resID.getName(), "DATA") || boost::starts_with(resID.getName(), "CONFIG"));
|
|
|
+// });
|
|
|
+//
|
|
|
+// for (const ResourcePath & file : files)
|
|
|
+// {
|
|
|
+// ui32 fileChecksum = filesystem->load(file)->calculateCRC32();
|
|
|
+// modChecksum.process_bytes(reinterpret_cast<const void *>(&fileChecksum), sizeof(fileChecksum));
|
|
|
+// }
|
|
|
+// return modChecksum.checksum();
|
|
|
+//}
|
|
|
|
|
|
void CModHandler::loadModFilesystems()
|
|
|
{
|
|
|
CGeneralTextHandler::detectInstallParameters();
|
|
|
|
|
|
- activeMods = validateAndSortDependencies(activeMods);
|
|
|
-
|
|
|
- coreMod->updateChecksum(calculateModChecksum(ModScope::scopeBuiltin(), CResourceHandler::get(ModScope::scopeBuiltin())));
|
|
|
+ const auto & activeMods = modManager->getActiveMods();
|
|
|
|
|
|
- std::map<std::string, ISimpleResourceLoader *> modFilesystems;
|
|
|
+ std::map<TModID, ISimpleResourceLoader *> modFilesystems;
|
|
|
|
|
|
- for(std::string & modName : activeMods)
|
|
|
- modFilesystems[modName] = genModFilesystem(modName, allMods[modName].config);
|
|
|
+ for(const TModID & modName : activeMods)
|
|
|
+ modFilesystems[modName] = genModFilesystem(modName, getModInfo(modName).getFilesystemConfig());
|
|
|
|
|
|
- for(std::string & modName : activeMods)
|
|
|
+ for(const TModID & modName : activeMods)
|
|
|
CResourceHandler::addFilesystem("data", modName, modFilesystems[modName]);
|
|
|
|
|
|
if (settings["mods"]["validation"].String() == "full")
|
|
|
+ checkModFilesystemsConflicts(modFilesystems);
|
|
|
+}
|
|
|
+
|
|
|
+void CModHandler::checkModFilesystemsConflicts(const std::map<TModID, ISimpleResourceLoader *> & modFilesystems)
|
|
|
+{
|
|
|
+ for(const auto & [leftName, leftFilesystem] : modFilesystems)
|
|
|
{
|
|
|
- for(std::string & leftModName : activeMods)
|
|
|
+ for(const auto & [rightName, rightFilesystem] : modFilesystems)
|
|
|
{
|
|
|
- for(std::string & rightModName : activeMods)
|
|
|
- {
|
|
|
- if (leftModName == rightModName)
|
|
|
- continue;
|
|
|
+ if (leftName == rightName)
|
|
|
+ continue;
|
|
|
|
|
|
- if (getModDependencies(leftModName).count(rightModName) || getModDependencies(rightModName).count(leftModName))
|
|
|
- continue;
|
|
|
+ if (getModDependencies(leftName).count(rightName) || getModDependencies(rightName).count(leftName))
|
|
|
+ continue;
|
|
|
|
|
|
- if (getModSoftDependencies(leftModName).count(rightModName) || getModSoftDependencies(rightModName).count(leftModName))
|
|
|
- continue;
|
|
|
+ if (getModSoftDependencies(leftName).count(rightName) || getModSoftDependencies(rightName).count(leftName))
|
|
|
+ continue;
|
|
|
|
|
|
- const auto & filter = [](const ResourcePath &path){return path.getType() != EResType::DIRECTORY && path.getType() != EResType::JSON;};
|
|
|
+ const auto & filter = [](const ResourcePath &path){return path.getType() != EResType::DIRECTORY && path.getType() != EResType::JSON;};
|
|
|
|
|
|
- std::unordered_set<ResourcePath> leftResources = modFilesystems[leftModName]->getFilteredFiles(filter);
|
|
|
- std::unordered_set<ResourcePath> rightResources = modFilesystems[rightModName]->getFilteredFiles(filter);
|
|
|
+ std::unordered_set<ResourcePath> leftResources = leftFilesystem->getFilteredFiles(filter);
|
|
|
+ std::unordered_set<ResourcePath> rightResources = rightFilesystem->getFilteredFiles(filter);
|
|
|
|
|
|
- for (auto const & leftFile : leftResources)
|
|
|
- {
|
|
|
- if (rightResources.count(leftFile))
|
|
|
- logMod->warn("Potential confict detected between '%s' and '%s': both mods add file '%s'", leftModName, rightModName, leftFile.getOriginalName());
|
|
|
- }
|
|
|
+ for (auto const & leftFile : leftResources)
|
|
|
+ {
|
|
|
+ if (rightResources.count(leftFile))
|
|
|
+ logMod->warn("Potential confict detected between '%s' and '%s': both mods add file '%s'", leftName, rightName, leftFile.getOriginalName());
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
@@ -423,7 +165,8 @@ TModID CModHandler::findResourceOrigin(const ResourcePath & name) const
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
- for(const auto & modID : boost::adaptors::reverse(activeMods))
|
|
|
+ auto activeMode = modManager->getActiveMods();
|
|
|
+ for(const auto & modID : boost::adaptors::reverse(activeMode))
|
|
|
{
|
|
|
if(CResourceHandler::get(modID)->existsResource(name))
|
|
|
return modID;
|
|
|
@@ -478,7 +221,7 @@ std::string CModHandler::getModLanguage(const TModID& modId) const
|
|
|
return VLC->generaltexth->getInstalledLanguage();
|
|
|
if(modId == "map")
|
|
|
return VLC->generaltexth->getPreferredLanguage();
|
|
|
- return allMods.at(modId).baseLanguage;
|
|
|
+ return getModInfo(modId).getBaseLanguage();
|
|
|
}
|
|
|
|
|
|
std::set<TModID> CModHandler::getModDependencies(const TModID & modId) const
|
|
|
@@ -489,11 +232,9 @@ std::set<TModID> CModHandler::getModDependencies(const TModID & modId) const
|
|
|
|
|
|
std::set<TModID> CModHandler::getModDependencies(const TModID & modId, bool & isModFound) const
|
|
|
{
|
|
|
- auto it = allMods.find(modId);
|
|
|
- isModFound = (it != allMods.end());
|
|
|
-
|
|
|
- if(isModFound)
|
|
|
- return it->second.dependencies;
|
|
|
+ isModFound = modManager->isModActive(modId);
|
|
|
+ if (isModFound)
|
|
|
+ return modManager->getModDescription(modId).getDependencies();
|
|
|
|
|
|
logMod->error("Mod not found: '%s'", modId);
|
|
|
return {};
|
|
|
@@ -501,54 +242,37 @@ std::set<TModID> CModHandler::getModDependencies(const TModID & modId, bool & is
|
|
|
|
|
|
std::set<TModID> CModHandler::getModSoftDependencies(const TModID & modId) const
|
|
|
{
|
|
|
- auto it = allMods.find(modId);
|
|
|
- if(it != allMods.end())
|
|
|
- return it->second.softDependencies;
|
|
|
- logMod->error("Mod not found: '%s'", modId);
|
|
|
- return {};
|
|
|
+ return modManager->getModDescription(modId).getSoftDependencies();
|
|
|
}
|
|
|
|
|
|
std::set<TModID> CModHandler::getModEnabledSoftDependencies(const TModID & modId) const
|
|
|
{
|
|
|
std::set<TModID> softDependencies = getModSoftDependencies(modId);
|
|
|
- for (auto it = softDependencies.begin(); it != softDependencies.end();)
|
|
|
- {
|
|
|
- if (allMods.find(*it) == allMods.end())
|
|
|
- it = softDependencies.erase(it);
|
|
|
- else
|
|
|
- it++;
|
|
|
- }
|
|
|
+
|
|
|
+ vstd::erase_if(softDependencies, [&](const TModID & dependency){ return !modManager->isModActive(dependency);});
|
|
|
+
|
|
|
return softDependencies;
|
|
|
}
|
|
|
|
|
|
void CModHandler::initializeConfig()
|
|
|
{
|
|
|
- VLC->settingsHandler->loadBase(JsonUtils::assembleFromFiles(coreMod->config["settings"]));
|
|
|
-
|
|
|
- for(const TModID & modName : activeMods)
|
|
|
+ for(const TModID & modName : getActiveMods())
|
|
|
{
|
|
|
- const auto & mod = allMods[modName];
|
|
|
- if (!mod.config["settings"].isNull())
|
|
|
- VLC->settingsHandler->loadBase(mod.config["settings"]);
|
|
|
+ const auto & mod = getModInfo(modName);
|
|
|
+ if (!mod.getConfig()["settings"].isNull())
|
|
|
+ VLC->settingsHandler->loadBase(mod.getConfig()["settings"]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-CModVersion CModHandler::getModVersion(TModID modName) const
|
|
|
-{
|
|
|
- if (allMods.count(modName))
|
|
|
- return allMods.at(modName).getVerificationInfo().version;
|
|
|
- return {};
|
|
|
-}
|
|
|
-
|
|
|
void CModHandler::loadTranslation(const TModID & modName)
|
|
|
{
|
|
|
- const auto & mod = allMods[modName];
|
|
|
+ const auto & mod = getModInfo(modName);
|
|
|
|
|
|
std::string preferredLanguage = VLC->generaltexth->getPreferredLanguage();
|
|
|
- std::string modBaseLanguage = allMods[modName].baseLanguage;
|
|
|
+ std::string modBaseLanguage = getModInfo(modName).getBaseLanguage();
|
|
|
|
|
|
- JsonNode baseTranslation = JsonUtils::assembleFromFiles(mod.config["translations"]);
|
|
|
- JsonNode extraTranslation = JsonUtils::assembleFromFiles(mod.config[preferredLanguage]["translations"]);
|
|
|
+ JsonNode baseTranslation = JsonUtils::assembleFromFiles(mod.getConfig()["translations"]);
|
|
|
+ JsonNode extraTranslation = JsonUtils::assembleFromFiles(mod.getConfig()[preferredLanguage]["translations"]);
|
|
|
|
|
|
VLC->generaltexth->loadTranslationOverrides(modName, modBaseLanguage, baseTranslation);
|
|
|
VLC->generaltexth->loadTranslationOverrides(modName, preferredLanguage, extraTranslation);
|
|
|
@@ -556,29 +280,22 @@ void CModHandler::loadTranslation(const TModID & modName)
|
|
|
|
|
|
void CModHandler::load()
|
|
|
{
|
|
|
- CStopWatch totalTime;
|
|
|
- CStopWatch timer;
|
|
|
-
|
|
|
- logMod->info("\tInitializing content handler: %d ms", timer.getDiff());
|
|
|
+ logMod->info("\tInitializing content handler");
|
|
|
|
|
|
content->init();
|
|
|
|
|
|
- for(const TModID & modName : activeMods)
|
|
|
- {
|
|
|
- logMod->trace("Generating checksum for %s", modName);
|
|
|
- allMods[modName].updateChecksum(calculateModChecksum(modName, CResourceHandler::get(modName)));
|
|
|
- }
|
|
|
+// for(const TModID & modName : getActiveMods())
|
|
|
+// {
|
|
|
+// logMod->trace("Generating checksum for %s", modName);
|
|
|
+// allMods[modName].updateChecksum(calculateModChecksum(modName, CResourceHandler::get(modName)));
|
|
|
+// }
|
|
|
|
|
|
- // first - load virtual builtin mod that contains all data
|
|
|
- // TODO? move all data into real mods? RoE, AB, SoD, WoG
|
|
|
- content->preloadData(*coreMod);
|
|
|
- for(const TModID & modName : activeMods)
|
|
|
- content->preloadData(allMods[modName]);
|
|
|
- logMod->info("\tParsing mod data: %d ms", timer.getDiff());
|
|
|
+ for(const TModID & modName : getActiveMods())
|
|
|
+ content->preloadData(getModInfo(modName));
|
|
|
+ logMod->info("\tParsing mod data");
|
|
|
|
|
|
- content->load(*coreMod);
|
|
|
- for(const TModID & modName : activeMods)
|
|
|
- content->load(allMods[modName]);
|
|
|
+ for(const TModID & modName : getActiveMods())
|
|
|
+ content->load(getModInfo(modName));
|
|
|
|
|
|
#if SCRIPTING_ENABLED
|
|
|
VLC->scriptHandler->performRegistration(VLC);//todo: this should be done before any other handlers load
|
|
|
@@ -586,36 +303,36 @@ void CModHandler::load()
|
|
|
|
|
|
content->loadCustom();
|
|
|
|
|
|
- for(const TModID & modName : activeMods)
|
|
|
+ for(const TModID & modName : getActiveMods())
|
|
|
loadTranslation(modName);
|
|
|
|
|
|
- logMod->info("\tLoading mod data: %d ms", timer.getDiff());
|
|
|
+ logMod->info("\tLoading mod data");
|
|
|
VLC->creh->loadCrExpMod();
|
|
|
VLC->identifiersHandler->finalize();
|
|
|
- logMod->info("\tResolving identifiers: %d ms", timer.getDiff());
|
|
|
+ logMod->info("\tResolving identifiers");
|
|
|
|
|
|
content->afterLoadFinalization();
|
|
|
- logMod->info("\tHandlers post-load finalization: %d ms ", timer.getDiff());
|
|
|
- logMod->info("\tAll game content loaded in %d ms", totalTime.getDiff());
|
|
|
+ logMod->info("\tHandlers post-load finalization");
|
|
|
+ logMod->info("\tAll game content loaded");
|
|
|
}
|
|
|
|
|
|
void CModHandler::afterLoad(bool onlyEssential)
|
|
|
{
|
|
|
- JsonNode modSettings;
|
|
|
- for (auto & modEntry : allMods)
|
|
|
- {
|
|
|
- std::string pointer = "/" + boost::algorithm::replace_all_copy(modEntry.first, ".", "/mods/");
|
|
|
-
|
|
|
- modSettings["activeMods"].resolvePointer(pointer) = modEntry.second.saveLocalData();
|
|
|
- }
|
|
|
- modSettings[ModScope::scopeBuiltin()] = coreMod->saveLocalData();
|
|
|
- modSettings[ModScope::scopeBuiltin()]["name"].String() = "Original game files";
|
|
|
-
|
|
|
- if(!onlyEssential)
|
|
|
- {
|
|
|
- std::fstream file(CResourceHandler::get()->getResourceName(ResourcePath("config/modSettings.json"))->c_str(), std::ofstream::out | std::ofstream::trunc);
|
|
|
- file << modSettings.toString();
|
|
|
- }
|
|
|
+ //JsonNode modSettings;
|
|
|
+ //for (auto & modEntry : getActiveMods())
|
|
|
+ //{
|
|
|
+ // std::string pointer = "/" + boost::algorithm::replace_all_copy(modEntry.first, ".", "/mods/");
|
|
|
+
|
|
|
+ // modSettings["activeMods"].resolvePointer(pointer) = modEntry.second.saveLocalData();
|
|
|
+ //}
|
|
|
+ //modSettings[ModScope::scopeBuiltin()] = coreMod->saveLocalData();
|
|
|
+ //modSettings[ModScope::scopeBuiltin()]["name"].String() = "Original game files";
|
|
|
+
|
|
|
+ //if(!onlyEssential)
|
|
|
+ //{
|
|
|
+ // std::fstream file(CResourceHandler::get()->getResourceName(ResourcePath("config/modSettings.json"))->c_str(), std::ofstream::out | std::ofstream::trunc);
|
|
|
+ // file << modSettings.toString();
|
|
|
+ //}
|
|
|
}
|
|
|
|
|
|
VCMI_LIB_NAMESPACE_END
|
Ivan Savenko