games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-24 22:14:36 +02:00
Code Issues Releases Activity

Use ResourcePath for referencing texts and json's

Browse Source
This commit is contained in:
Ivan Savenko 2023-09-02 00:26:14 +03:00
parent 823ffa7a07
commit 6f0108e462
51 changed files with 124 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
client/CMusicHandler.cpp
View File

@ -75,7 +75,7 @@ void CSoundHandler::onVolumeChange(const JsonNode &volumeNode)
CSoundHandler::CSoundHandler(): CSoundHandler::CSoundHandler():
listener(settings.listen["general"]["sound"]), listener(settings.listen["general"]["sound"]),
ambientConfig(JsonNode(ResourcePath("config/ambientSounds.json"))) ambientConfig(JsonPath::builtin("config/ambientSounds.json"))
{ {
listener(std::bind(&CSoundHandler::onVolumeChange, this, _1)); listener(std::bind(&CSoundHandler::onVolumeChange, this, _1));

2
client/adventureMap/AdventureMapWidget.cpp
View File

@ -56,7 +56,7 @@ AdventureMapWidget::AdventureMapWidget( std::shared_ptr<AdventureMapShortcuts> s
for (const auto & entry : shortcuts->getShortcuts()) for (const auto & entry : shortcuts->getShortcuts())
addShortcut(entry.shortcut, entry.callback); addShortcut(entry.shortcut, entry.callback);
const JsonNode config(ResourcePath("config/widgets/adventureMap.json")); const JsonNode config(JsonPath::builtin("config/widgets/adventureMap.json"));
for(const auto & entry : config["options"]["imagesPlayerColored"].Vector()) for(const auto & entry : config["options"]["imagesPlayerColored"].Vector())
{ {

2
client/adventureMap/TurnTimerWidget.cpp
View File

@ -47,7 +47,7 @@ TurnTimerWidget::TurnTimerWidget():
recActions &= ~DEACTIVATE; recActions &= ~DEACTIVATE;
const JsonNode config(ResourcePath("config/widgets/turnTimer.json")); const JsonNode config(JsonPath::builtin("config/widgets/turnTimer.json"));
build(config); build(config);

2
client/battle/BattleEffectsController.cpp
View File

@ -132,7 +132,7 @@ void BattleEffectsController::collectRenderableObjects(BattleRenderer & renderer
void BattleEffectsController::loadColorMuxers() void BattleEffectsController::loadColorMuxers()
{ {
const JsonNode config(ResourcePath("config/battleEffects.json")); const JsonNode config(JsonPath::builtin("config/battleEffects.json"));
for(auto & muxer : config["colorMuxers"].Struct()) for(auto & muxer : config["colorMuxers"].Struct())
{ {

2
client/battle/BattleWindow.cpp
View File

@ -51,7 +51,7 @@ BattleWindow::BattleWindow(BattleInterface & owner):
REGISTER_BUILDER("battleConsole", &BattleWindow::buildBattleConsole); REGISTER_BUILDER("battleConsole", &BattleWindow::buildBattleConsole);
const JsonNode config(ResourcePath("config/widgets/BattleWindow2.json")); const JsonNode config(JsonPath::builtin("config/widgets/BattleWindow2.json"));
addShortcut(EShortcut::GLOBAL_OPTIONS, std::bind(&BattleWindow::bOptionsf, this)); addShortcut(EShortcut::GLOBAL_OPTIONS, std::bind(&BattleWindow::bOptionsf, this));
addShortcut(EShortcut::BATTLE_SURRENDER, std::bind(&BattleWindow::bSurrenderf, this)); addShortcut(EShortcut::BATTLE_SURRENDER, std::bind(&BattleWindow::bSurrenderf, this));

2
client/gui/InterfaceObjectConfigurable.cpp
View File

@ -110,7 +110,7 @@ void InterfaceObjectConfigurable::build(const JsonNode &config)
{ {
if (!config["library"].isNull()) if (!config["library"].isNull())
{ {
const JsonNode library(ResourcePath(config["library"].String())); const JsonNode library(JsonPath::fromJson(config["library"]));
loadCustomBuilders(library); loadCustomBuilders(library);
} }

2
client/lobby/OptionsTab.cpp
View File

@ -137,7 +137,7 @@ OptionsTab::OptionsTab() : humanPlayers(0)
} }
}); });
const JsonNode config(ResourcePath("config/widgets/optionsTab.json")); const JsonNode config(JsonPath::builtin("config/widgets/optionsTab.json"));
build(config); build(config);
//set timers combo box callbacks //set timers combo box callbacks

4
client/lobby/RandomMapTab.cpp
View File

@ -118,7 +118,7 @@ RandomMapTab::RandomMapTab():
}); });
} }
const JsonNode config(ResourcePath("config/widgets/randomMapTab.json")); const JsonNode config(JsonPath::builtin("config/widgets/randomMapTab.json"));
build(config); build(config);
//set combo box callbacks //set combo box callbacks
@ -388,7 +388,7 @@ std::vector<int> RandomMapTab::getPossibleMapSizes()
TeamAlignmentsWidget::TeamAlignmentsWidget(RandomMapTab & randomMapTab): TeamAlignmentsWidget::TeamAlignmentsWidget(RandomMapTab & randomMapTab):
InterfaceObjectConfigurable() InterfaceObjectConfigurable()
{ {
const JsonNode config(ResourcePath("config/widgets/randomMapTeamsWidget.json")); const JsonNode config(JsonPath::builtin("config/widgets/randomMapTeamsWidget.json"));
variables = config["variables"]; variables = config["variables"];
int humanPlayers = randomMapTab.obtainMapGenOptions().getPlayerCount(); int humanPlayers = randomMapTab.obtainMapGenOptions().getPlayerCount();

3
client/mainmenu/CMainMenu.cpp
View File

@ -262,7 +262,8 @@ CMenuEntry::CMenuEntry(CMenuScreen * parent, const JsonNode & config)
} }
CMainMenuConfig::CMainMenuConfig() CMainMenuConfig::CMainMenuConfig()
: campaignSets(JsonNode(ResourcePath("config/campaignSets.json"))), config(JsonNode(ResourcePath("config/mainmenu.json"))) : campaignSets(JsonPath::builtin("config/campaignSets.json"))
, config(JsonPath::builtin("config/mainmenu.json"))
{ {
} }

6
client/render/Graphics.cpp
View File

@ -105,7 +105,7 @@ void Graphics::initializeBattleGraphics()
if(!CResourceHandler::get(mod)->existsResource(ResourcePath("config/battles_graphics.json"))) if(!CResourceHandler::get(mod)->existsResource(ResourcePath("config/battles_graphics.json")))
continue; continue;
const JsonNode config(mod, ResourcePath("config/battles_graphics.json")); const JsonNode config(mod, JsonPath::builtin("config/battles_graphics.json"));
//initialization of AC->def name mapping //initialization of AC->def name mapping
if(!config["ac_mapping"].isNull()) if(!config["ac_mapping"].isNull())
@ -204,7 +204,7 @@ void Graphics::blueToPlayersAdv(SDL_Surface * sur, PlayerColor player)
void Graphics::loadFonts() void Graphics::loadFonts()
{ {
const JsonNode config(ResourcePath("config/fonts.json")); const JsonNode config(JsonPath::builtin("config/fonts.json"));
const JsonVector & bmpConf = config["bitmap"].Vector(); const JsonVector & bmpConf = config["bitmap"].Vector();
const JsonNode & ttfConf = config["trueType"]; const JsonNode & ttfConf = config["trueType"];
@ -228,7 +228,7 @@ void Graphics::loadFonts()
void Graphics::loadErmuToPicture() void Graphics::loadErmuToPicture()
{ {
//loading ERMU to picture //loading ERMU to picture
const JsonNode config(ResourcePath("config/ERMU_to_picture.json")); const JsonNode config(JsonPath::builtin("config/ERMU_to_picture.json"));
int etp_idx = 0; int etp_idx = 0;
for(const JsonNode &etp : config["ERMU_to_picture"].Vector()) { for(const JsonNode &etp : config["ERMU_to_picture"].Vector()) {
int idx = 0; int idx = 0;

2
client/windows/settings/AdventureOptionsTab.cpp
View File

@ -44,7 +44,7 @@ AdventureOptionsTab::AdventureOptionsTab()
addConditional("desktop", true); addConditional("desktop", true);
#endif #endif
const JsonNode config(ResourcePath("config/widgets/settings/adventureOptionsTab.json")); const JsonNode config(JsonPath::builtin("config/widgets/settings/adventureOptionsTab.json"));
addCallback("playerHeroSpeedChanged", [this](int value) addCallback("playerHeroSpeedChanged", [this](int value)
{ {
auto targetLabel = widget<CLabel>("heroSpeedValueLabel"); auto targetLabel = widget<CLabel>("heroSpeedValueLabel");

2
client/windows/settings/BattleOptionsTab.cpp
View File

@ -23,7 +23,7 @@ BattleOptionsTab::BattleOptionsTab(BattleInterface * owner)
OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE; OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE;
setRedrawParent(true); setRedrawParent(true);
const JsonNode config(ResourcePath("config/widgets/settings/battleOptionsTab.json")); const JsonNode config(JsonPath::builtin("config/widgets/settings/battleOptionsTab.json"));
addCallback("viewGridChanged", [this, owner](bool value) addCallback("viewGridChanged", [this, owner](bool value)
{ {
viewGridChangedCallback(value, owner); viewGridChangedCallback(value, owner);

2
client/windows/settings/GeneralOptionsTab.cpp
View File

@ -105,7 +105,7 @@ GeneralOptionsTab::GeneralOptionsTab()
addConditional("desktop", true); addConditional("desktop", true);
#endif #endif
const JsonNode config(ResourcePath("config/widgets/settings/generalOptionsTab.json")); const JsonNode config(JsonPath::builtin("config/widgets/settings/generalOptionsTab.json"));
addCallback("spellbookAnimationChanged", [](bool value) addCallback("spellbookAnimationChanged", [](bool value)
{ {
setBoolSetting("video", "spellbookAnimation", value); setBoolSetting("video", "spellbookAnimation", value);

2
client/windows/settings/OtherOptionsTab.cpp
View File

@ -26,7 +26,7 @@ OtherOptionsTab::OtherOptionsTab() : InterfaceObjectConfigurable()
{ {
OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE; OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE;
const JsonNode config(ResourcePath("config/widgets/settings/otherOptionsTab.json")); const JsonNode config(JsonPath::builtin("config/widgets/settings/otherOptionsTab.json"));
addCallback("availableCreaturesAsDwellingLabelChanged", [](bool value) addCallback("availableCreaturesAsDwellingLabelChanged", [](bool value)
{ {
return setBoolSetting("gameTweaks", "availableCreaturesAsDwellingLabel", value); return setBoolSetting("gameTweaks", "availableCreaturesAsDwellingLabel", value);

2
client/windows/settings/SettingsMainWindow.cpp
View File

@ -35,7 +35,7 @@ SettingsMainWindow::SettingsMainWindow(BattleInterface * parentBattleUi) : Inter
{ {
OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE; OBJ_CONSTRUCTION_CAPTURING_ALL_NO_DISPOSE;
const JsonNode config(ResourcePath("config/widgets/settings/settingsMainContainer.json")); const JsonNode config(JsonPath::builtin("config/widgets/settings/settingsMainContainer.json"));
addCallback("activateSettingsTab", [this](int tabId) { openTab(tabId); }); addCallback("activateSettingsTab", [this](int tabId) { openTab(tabId); });
addCallback("loadGame", [this](int) { loadGameButtonCallback(); }); addCallback("loadGame", [this](int) { loadGameButtonCallback(); });
addCallback("saveGame", [this](int) { saveGameButtonCallback(); }); addCallback("saveGame", [this](int) { saveGameButtonCallback(); });

2
launcher/modManager/cmodmanager.cpp
View File

@ -84,7 +84,7 @@ void CModManager::loadMods()
for(auto modname : installedMods) for(auto modname : installedMods)
{ {
ResourcePath resID(CModInfo::getModFile(modname)); auto resID = CModInfo::getModFile(modname);
if(CResourceHandler::get()->existsResource(resID)) if(CResourceHandler::get()->existsResource(resID))
{ {
boost::filesystem::path name = *CResourceHandler::get()->getResourceName(resID); boost::filesystem::path name = *CResourceHandler::get()->getResourceName(resID);

4
lib/CArtHandler.cpp
View File

@ -332,8 +332,8 @@ std::vector<JsonNode> CArtHandler::loadLegacyData()
static std::map<char, std::string> classes = static std::map<char, std::string> classes =
{{'S',"SPECIAL"}, {'T',"TREASURE"},{'N',"MINOR"},{'J',"MAJOR"},{'R',"RELIC"},}; {{'S',"SPECIAL"}, {'T',"TREASURE"},{'N',"MINOR"},{'J',"MAJOR"},{'R',"RELIC"},};
CLegacyConfigParser parser("DATA/ARTRAITS.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/ARTRAITS.TXT"));
CLegacyConfigParser events("DATA/ARTEVENT.TXT"); CLegacyConfigParser events(TextPath::builtin("DATA/ARTEVENT.TXT"));
parser.endLine(); // header parser.endLine(); // header
parser.endLine(); parser.endLine();

2
lib/CBonusTypeHandler.cpp
View File

@ -196,7 +196,7 @@ ImagePath CBonusTypeHandler::bonusToGraphics(const std::shared_ptr<Bonus> & bonu
void CBonusTypeHandler::load() void CBonusTypeHandler::load()
{ {
const JsonNode gameConf(ResourcePath("config/gameConfig.json")); const JsonNode gameConf(JsonPath::builtin("config/gameConfig.json"));
const JsonNode config(JsonUtils::assembleFromFiles(gameConf["bonuses"].convertTo<std::vector<std::string>>())); const JsonNode config(JsonUtils::assembleFromFiles(gameConf["bonuses"].convertTo<std::vector<std::string>>()));
load(config); load(config);
} }

6
lib/CConfigHandler.cpp
View File

@ -55,12 +55,12 @@ SettingsStorage::SettingsStorage():
void SettingsStorage::init() void SettingsStorage::init()
{ {
std::string confName = "config/settings.json"; JsonPath confName = JsonPath::builtin("config/settings.json");
JsonUtils::assembleFromFiles(confName).swap(config); JsonUtils::assembleFromFiles(confName.getOriginalName()).swap(config);
// Probably new install. Create config file to save settings to // Probably new install. Create config file to save settings to
if (!CResourceHandler::get("local")->existsResource(ResourcePath(confName))) if (!CResourceHandler::get("local")->existsResource(confName))
CResourceHandler::get("local")->createResource(confName); CResourceHandler::get("local")->createResource(confName);
JsonUtils::maximize(config, "vcmi:settings"); JsonUtils::maximize(config, "vcmi:settings");

10
lib/CCreatureHandler.cpp
View File

@ -415,7 +415,7 @@ const CCreature * CCreatureHandler::getCreature(const std::string & scope, const
void CCreatureHandler::loadCommanders() void CCreatureHandler::loadCommanders()
{ {
ResourcePath configResource("config/commanders.json"); auto configResource = JsonPath::builtin("config/commanders.json");
std::string modSource = VLC->modh->findResourceOrigin(configResource); std::string modSource = VLC->modh->findResourceOrigin(configResource);
JsonNode data(configResource); JsonNode data(configResource);
@ -507,7 +507,7 @@ std::vector<JsonNode> CCreatureHandler::loadLegacyData()
std::vector<JsonNode> h3Data; std::vector<JsonNode> h3Data;
h3Data.reserve(dataSize); h3Data.reserve(dataSize);
CLegacyConfigParser parser("DATA/CRTRAITS.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/CRTRAITS.TXT"));
parser.endLine(); // header parser.endLine(); // header
@ -698,7 +698,7 @@ void CCreatureHandler::loadCrExpMod()
} }
} }
CLegacyConfigParser expBonParser("DATA/CREXPMOD.TXT"); CLegacyConfigParser expBonParser(TextPath::builtin("DATA/CREXPMOD.TXT"));
expBonParser.endLine(); //header expBonParser.endLine(); //header
@ -745,7 +745,7 @@ void CCreatureHandler::loadCrExpBon(CBonusSystemNode & globalEffects)
globalEffects.addNewBonus(b); globalEffects.addNewBonus(b);
}; };
CLegacyConfigParser parser("DATA/CREXPBON.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/CREXPBON.TXT"));
Bonus b; //prototype with some default properties Bonus b; //prototype with some default properties
b.source = BonusSource::STACK_EXPERIENCE; b.source = BonusSource::STACK_EXPERIENCE;
@ -804,7 +804,7 @@ void CCreatureHandler::loadCrExpBon(CBonusSystemNode & globalEffects)
void CCreatureHandler::loadAnimationInfo(std::vector<JsonNode> &h3Data) const void CCreatureHandler::loadAnimationInfo(std::vector<JsonNode> &h3Data) const
{ {
CLegacyConfigParser parser("DATA/CRANIM.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/CRANIM.TXT"));
parser.endLine(); // header parser.endLine(); // header
parser.endLine(); parser.endLine();

17
lib/CGeneralTextHandler.cpp
View File

@ -119,9 +119,8 @@ protected:
} }
}; };
CLegacyConfigParser::CLegacyConfigParser(std::string URI) CLegacyConfigParser::CLegacyConfigParser(const TextPath & resource)
{ {
ResourcePath resource(URI, EResType::TEXT);
auto input = CResourceHandler::get()->load(resource); auto input = CResourceHandler::get()->load(resource);
std::string modName = VLC->modh->findResourceOrigin(resource); std::string modName = VLC->modh->findResourceOrigin(resource);
std::string language = VLC->modh->getModLanguage(modName); std::string language = VLC->modh->getModLanguage(modName);
@ -250,7 +249,7 @@ bool CLegacyConfigParser::endLine()
void CGeneralTextHandler::readToVector(const std::string & sourceID, const std::string & sourceName) void CGeneralTextHandler::readToVector(const std::string & sourceID, const std::string & sourceName)
{ {
CLegacyConfigParser parser(sourceName); CLegacyConfigParser parser(TextPath::builtin(sourceName));
size_t index = 0; size_t index = 0;
do do
{ {
@ -434,7 +433,7 @@ CGeneralTextHandler::CGeneralTextHandler():
readToVector("vcmi.quickExchange", QE_MOD_COMMANDS); readToVector("vcmi.quickExchange", QE_MOD_COMMANDS);
{ {
CLegacyConfigParser parser("DATA/RANDTVRN.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/RANDTVRN.TXT"));
parser.endLine(); parser.endLine();
size_t index = 0; size_t index = 0;
do do
@ -449,7 +448,7 @@ CGeneralTextHandler::CGeneralTextHandler():
while (parser.endLine()); while (parser.endLine());
} }
{ {
CLegacyConfigParser parser("DATA/GENRLTXT.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/GENRLTXT.TXT"));
parser.endLine(); parser.endLine();
size_t index = 0; size_t index = 0;
do do
@ -460,7 +459,7 @@ CGeneralTextHandler::CGeneralTextHandler():
while (parser.endLine()); while (parser.endLine());
} }
{ {
CLegacyConfigParser parser("DATA/HELP.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/HELP.TXT"));
size_t index = 0; size_t index = 0;
do do
{ {
@ -473,7 +472,7 @@ CGeneralTextHandler::CGeneralTextHandler():
while (parser.endLine()); while (parser.endLine());
} }
{ {
CLegacyConfigParser parser("DATA/PLCOLORS.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/PLCOLORS.TXT"));
size_t index = 0; size_t index = 0;
do do
{ {
@ -487,7 +486,7 @@ CGeneralTextHandler::CGeneralTextHandler():
while (parser.endLine()); while (parser.endLine());
} }
{ {
CLegacyConfigParser parser("DATA/SEERHUT.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/SEERHUT.TXT"));
//skip header //skip header
parser.endLine(); parser.endLine();
@ -531,7 +530,7 @@ CGeneralTextHandler::CGeneralTextHandler():
} }
} }
{ {
CLegacyConfigParser parser("DATA/CAMPTEXT.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/CAMPTEXT.TXT"));
//skip header //skip header
parser.endLine(); parser.endLine();

4
lib/CGeneralTextHandler.h
View File

@ -9,6 +9,8 @@
*/ */
#pragma once #pragma once
#include "filesystem/ResourcePath.h"
VCMI_LIB_NAMESPACE_BEGIN VCMI_LIB_NAMESPACE_BEGIN
class CInputStream; class CInputStream;
@ -56,7 +58,7 @@ public:
/// end current line /// end current line
bool endLine(); bool endLine();
explicit CLegacyConfigParser(std::string URI); explicit CLegacyConfigParser(const TextPath & URI);
}; };
class CGeneralTextHandler; class CGeneralTextHandler;

8
lib/CHeroHandler.cpp
View File

@ -320,7 +320,7 @@ std::vector<JsonNode> CHeroClassHandler::loadLegacyData()
std::vector<JsonNode> h3Data; std::vector<JsonNode> h3Data;
h3Data.reserve(dataSize); h3Data.reserve(dataSize);
CLegacyConfigParser parser("DATA/HCTRAITS.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/HCTRAITS.TXT"));
parser.endLine(); // header parser.endLine(); // header
parser.endLine(); parser.endLine();
@ -681,9 +681,9 @@ std::vector<JsonNode> CHeroHandler::loadLegacyData()
std::vector<JsonNode> h3Data; std::vector<JsonNode> h3Data;
h3Data.reserve(dataSize); h3Data.reserve(dataSize);
CLegacyConfigParser specParser("DATA/HEROSPEC.TXT"); CLegacyConfigParser specParser(TextPath::builtin("DATA/HEROSPEC.TXT"));
CLegacyConfigParser bioParser("DATA/HEROBIOS.TXT"); CLegacyConfigParser bioParser(TextPath::builtin("DATA/HEROBIOS.TXT"));
CLegacyConfigParser parser("DATA/HOTRAITS.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/HOTRAITS.TXT"));
parser.endLine(); //ignore header parser.endLine(); //ignore header
parser.endLine(); parser.endLine();

2
lib/CSkillHandler.cpp
View File

@ -146,7 +146,7 @@ void CSkill::serializeJson(JsonSerializeFormat & handler)
///CSkillHandler ///CSkillHandler
std::vector<JsonNode> CSkillHandler::loadLegacyData() std::vector<JsonNode> CSkillHandler::loadLegacyData()
{ {
CLegacyConfigParser parser("DATA/SSTRAITS.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/SSTRAITS.TXT"));
//skip header //skip header
parser.endLine(); parser.endLine();

16
lib/CTownHandler.cpp
View File

@ -330,7 +330,7 @@ std::vector<JsonNode> CTownHandler::loadLegacyData()
return dest[town]["town"]["buildings"][EBuildingType::names[building]]; return dest[town]["town"]["buildings"][EBuildingType::names[building]];
}; };
CLegacyConfigParser parser("DATA/BUILDING.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/BUILDING.TXT"));
parser.endLine(); // header parser.endLine(); // header
parser.endLine(); parser.endLine();
@ -382,7 +382,7 @@ std::vector<JsonNode> CTownHandler::loadLegacyData()
} }
} }
{ {
CLegacyConfigParser parser("DATA/BLDGNEUT.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/BLDGNEUT.TXT"));
for(int building=0; building<15; building++) for(int building=0; building<15; building++)
{ {
@ -420,7 +420,7 @@ std::vector<JsonNode> CTownHandler::loadLegacyData()
} }
} }
{ {
CLegacyConfigParser parser("DATA/BLDGSPEC.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/BLDGSPEC.TXT"));
for(int town=0; town<dataSize; town++) for(int town=0; town<dataSize; town++)
{ {
@ -440,7 +440,7 @@ std::vector<JsonNode> CTownHandler::loadLegacyData()
} }
} }
{ {
CLegacyConfigParser parser("DATA/DWELLING.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/DWELLING.TXT"));
for(int town=0; town<dataSize; town++) for(int town=0; town<dataSize; town++)
{ {
@ -453,8 +453,8 @@ std::vector<JsonNode> CTownHandler::loadLegacyData()
} }
} }
{ {
CLegacyConfigParser typeParser("DATA/TOWNTYPE.TXT"); CLegacyConfigParser typeParser(TextPath::builtin("DATA/TOWNTYPE.TXT"));
CLegacyConfigParser nameParser("DATA/TOWNNAME.TXT"); CLegacyConfigParser nameParser(TextPath::builtin("DATA/TOWNNAME.TXT"));
size_t townID=0; size_t townID=0;
do do
{ {
@ -1148,9 +1148,7 @@ void CTownHandler::loadObject(std::string scope, std::string name, const JsonNod
void CTownHandler::loadRandomFaction() void CTownHandler::loadRandomFaction()
{ {
static const ResourcePath randomFactionPath("config/factions/random.json"); JsonNode randomFactionJson(JsonPath::builtin("config/factions/random.json"));
JsonNode randomFactionJson(randomFactionPath);
randomFactionJson.setMeta(ModScope::scopeBuiltin(), true); randomFactionJson.setMeta(ModScope::scopeBuiltin(), true);
loadBuildings(randomTown, randomFactionJson["random"]["town"]["buildings"]); loadBuildings(randomTown, randomFactionJson["random"]["town"]["buildings"]);
} }

27
lib/JsonNode.cpp
View File

@ -80,7 +80,7 @@ JsonNode::JsonNode(const char *data, size_t datasize):
*this = parser.parse("<unknown>"); *this = parser.parse("<unknown>");
} }
JsonNode::JsonNode(ResourcePath && fileURI): JsonNode::JsonNode(const JsonPath & fileURI):
type(JsonType::DATA_NULL) type(JsonType::DATA_NULL)
{ {
auto file = CResourceHandler::get()->load(fileURI)->readAll(); auto file = CResourceHandler::get()->load(fileURI)->readAll();
@ -89,16 +89,7 @@ JsonNode::JsonNode(ResourcePath && fileURI):
*this = parser.parse(fileURI.getName()); *this = parser.parse(fileURI.getName());
} }
JsonNode::JsonNode(const ResourcePath & fileURI): JsonNode::JsonNode(const std::string & idx, const JsonPath & fileURI):
type(JsonType::DATA_NULL)
{
auto file = CResourceHandler::get()->load(fileURI)->readAll();
JsonParser parser(reinterpret_cast<char*>(file.first.get()), file.second);
*this = parser.parse(fileURI.getName());
}
JsonNode::JsonNode(const std::string & idx, const ResourcePath & fileURI):
type(JsonType::DATA_NULL) type(JsonType::DATA_NULL)
{ {
auto file = CResourceHandler::get(idx)->load(fileURI)->readAll(); auto file = CResourceHandler::get(idx)->load(fileURI)->readAll();
@ -107,7 +98,7 @@ type(JsonType::DATA_NULL)
*this = parser.parse(fileURI.getName()); *this = parser.parse(fileURI.getName());
} }
JsonNode::JsonNode(ResourcePath && fileURI, bool &isValidSyntax): JsonNode::JsonNode(const JsonPath & fileURI, bool &isValidSyntax):
type(JsonType::DATA_NULL) type(JsonType::DATA_NULL)
{ {
auto file = CResourceHandler::get()->load(fileURI)->readAll(); auto file = CResourceHandler::get()->load(fileURI)->readAll();
@ -1253,11 +1244,11 @@ const JsonNode & getSchemaByName(const std::string & name)
if (vstd::contains(loadedSchemas, name)) if (vstd::contains(loadedSchemas, name))
return loadedSchemas[name]; return loadedSchemas[name];
std::string filename = "config/schemas/" + name; auto filename = JsonPath::builtin("config/schemas/" + name);
if (CResourceHandler::get()->existsResource(ResourcePath(filename))) if (CResourceHandler::get()->existsResource(filename))
{ {
loadedSchemas[name] = JsonNode(ResourcePath(filename)); loadedSchemas[name] = JsonNode(filename);
return loadedSchemas[name]; return loadedSchemas[name];
} }
@ -1444,10 +1435,10 @@ JsonNode JsonUtils::assembleFromFiles(const std::vector<std::string> & files, bo
isValid = true; isValid = true;
JsonNode result; JsonNode result;
for(const std::string & file : files) for(const auto & file : files)
{ {
bool isValidFile = false; bool isValidFile = false;
JsonNode section(ResourcePath(file, EResType::TEXT), isValidFile); JsonNode section(JsonPath::builtinTODO(file), isValidFile);
merge(result, section); merge(result, section);
isValid |= isValidFile; isValid |= isValidFile;
} }
@ -1457,7 +1448,7 @@ JsonNode JsonUtils::assembleFromFiles(const std::vector<std::string> & files, bo
JsonNode JsonUtils::assembleFromFiles(const std::string & filename) JsonNode JsonUtils::assembleFromFiles(const std::string & filename)
{ {
JsonNode result; JsonNode result;
ResourcePath resID(filename, EResType::TEXT); JsonPath resID(filename);
for(auto & loader : CResourceHandler::get()->getResourcesWithName(resID)) for(auto & loader : CResourceHandler::get()->getResourcesWithName(resID))
{ {

9
lib/JsonNode.h
View File

@ -9,6 +9,7 @@
*/ */
#pragma once #pragma once
#include "GameConstants.h" #include "GameConstants.h"
#include "filesystem/ResourcePath.h"
VCMI_LIB_NAMESPACE_BEGIN VCMI_LIB_NAMESPACE_BEGIN
@ -18,7 +19,6 @@ using JsonVector = std::vector<JsonNode>;
struct Bonus; struct Bonus;
class CSelector; class CSelector;
class ResourcePath;
class CAddInfo; class CAddInfo;
class ILimiter; class ILimiter;
@ -61,10 +61,9 @@ public:
//Create tree from Json-formatted input //Create tree from Json-formatted input
explicit JsonNode(const char * data, size_t datasize); explicit JsonNode(const char * data, size_t datasize);
//Create tree from JSON file //Create tree from JSON file
explicit JsonNode(ResourcePath && fileURI); explicit JsonNode(const JsonPath & fileURI);
explicit JsonNode(const ResourcePath & fileURI); explicit JsonNode(const std::string & modName, const JsonPath & fileURI);
explicit JsonNode(const std::string& idx, const ResourcePath & fileURI); explicit JsonNode(const JsonPath & fileURI, bool & isValidSyntax);
explicit JsonNode(ResourcePath && fileURI, bool & isValidSyntax);
//Copy c-tor //Copy c-tor
JsonNode(const JsonNode &copy); JsonNode(const JsonNode &copy);

2
lib/TerrainHandler.cpp
View File

@ -127,7 +127,7 @@ std::vector<JsonNode> TerrainTypeHandler::loadLegacyData()
objects.resize(dataSize); objects.resize(dataSize);
CLegacyConfigParser terrainParser("DATA/TERRNAME.TXT"); CLegacyConfigParser terrainParser(TextPath::builtin("DATA/TERRNAME.TXT"));
std::vector<JsonNode> result; std::vector<JsonNode> result;
do do

2
lib/battle/BattleInfo.cpp
View File

@ -348,7 +348,7 @@ BattleInfo * BattleInfo::setupBattle(const int3 & tile, TerrainId terrain, const
std::vector<std::vector<int>> creBankFormations[2]; std::vector<std::vector<int>> creBankFormations[2];
std::vector<int> commanderField; std::vector<int> commanderField;
std::vector<int> commanderBank; std::vector<int> commanderBank;
const JsonNode config(ResourcePath("config/battleStartpos.json")); const JsonNode config(JsonPath::builtin("config/battleStartpos.json"));
const JsonVector &positions = config["battle_positions"].Vector(); const JsonVector &positions = config["battle_positions"].Vector();
CGH::readBattlePositions(positions[0]["levels"], looseFormations[0]); CGH::readBattlePositions(positions[0]["levels"], looseFormations[0]);

4
lib/campaign/CampaignHandler.cpp
View File

@ -592,7 +592,7 @@ std::vector< std::vector<ui8> > CampaignHandler::getFile(std::unique_ptr<CInputS
std::string CampaignHandler::prologVideoName(ui8 index) std::string CampaignHandler::prologVideoName(ui8 index)
{ {
JsonNode config(ResourcePath(std::string("CONFIG/campaignMedia"), EResType::TEXT)); JsonNode config(JsonPath::builtin("CONFIG/campaignMedia"));
auto vids = config["videos"].Vector(); auto vids = config["videos"].Vector();
if(index < vids.size()) if(index < vids.size())
return vids[index].String(); return vids[index].String();
@ -607,7 +607,7 @@ std::string CampaignHandler::prologMusicName(ui8 index)
std::string CampaignHandler::prologVoiceName(ui8 index) std::string CampaignHandler::prologVoiceName(ui8 index)
{ {
JsonNode config(ResourcePath(std::string("CONFIG/campaignMedia"), EResType::TEXT)); JsonNode config(JsonPath::builtin("CONFIG/campaignMedia"));
auto audio = config["voice"].Vector(); auto audio = config["voice"].Vector();
if(index < audio.size()) if(index < audio.size())
return audio[index].String(); return audio[index].String();

2
lib/campaign/CampaignState.cpp
View File

@ -58,7 +58,7 @@ CampaignRegions CampaignRegions::getLegacy(int campId)
static std::vector<CampaignRegions> campDescriptions; static std::vector<CampaignRegions> campDescriptions;
if(campDescriptions.empty()) //read once if(campDescriptions.empty()) //read once
{ {
const JsonNode config(ResourcePath("config/campaign_regions.json")); const JsonNode config(JsonPath::builtin("config/campaign_regions.json"));
for(const JsonNode & campaign : config["campaign_regions"].Vector()) for(const JsonNode & campaign : config["campaign_regions"].Vector())
campDescriptions.push_back(CampaignRegions::fromJson(campaign)); campDescriptions.push_back(CampaignRegions::fromJson(campaign));
} }

4
lib/filesystem/AdapterLoaders.cpp
View File

@ -128,9 +128,9 @@ std::unordered_set<ResourcePath> CFilesystemList::getFilteredFiles(std::function
return ret; return ret;
} }
bool CFilesystemList::createResource(std::string filename, bool update) bool CFilesystemList::createResource(const ResourcePath & filename, bool update)
{ {
logGlobal->trace("Creating %s", filename); logGlobal->trace("Creating %s", filename.getOriginalName());
for (auto & loader : boost::adaptors::reverse(loaders)) for (auto & loader : boost::adaptors::reverse(loaders))
{ {
if (writeableLoaders.count(loader.get()) != 0 // writeable, if (writeableLoaders.count(loader.get()) != 0 // writeable,

2
lib/filesystem/AdapterLoaders.h
View File

@ -75,7 +75,7 @@ public:
std::set<boost::filesystem::path> getResourceNames(const ResourcePath & resourceName) const override; std::set<boost::filesystem::path> getResourceNames(const ResourcePath & resourceName) const override;
void updateFilteredFiles(std::function<bool(const std::string &)> filter) const override; void updateFilteredFiles(std::function<bool(const std::string &)> filter) const override;
std::unordered_set<ResourcePath> getFilteredFiles(std::function<bool(const ResourcePath &)> filter) const override; std::unordered_set<ResourcePath> getFilteredFiles(std::function<bool(const ResourcePath &)> filter) const override;
bool createResource(std::string filename, bool update = false) override; bool createResource(const ResourcePath & filename, bool update = false) override;
std::vector<const ISimpleResourceLoader *> getResourcesWithName(const ResourcePath & resourceName) const override; std::vector<const ISimpleResourceLoader *> getResourcesWithName(const ResourcePath & resourceName) const override;
/** /**

4
lib/filesystem/CFilesystemLoader.cpp
View File

@ -68,9 +68,9 @@ std::unordered_set<ResourcePath> CFilesystemLoader::getFilteredFiles(std::functi
return foundID; return foundID;
} }
bool CFilesystemLoader::createResource(std::string filename, bool update) bool CFilesystemLoader::createResource(const ResourcePath & resID, bool update)
{ {
ResourcePath resID(filename); std::string filename = resID.getOriginalName();
if (fileList.find(resID) != fileList.end()) if (fileList.find(resID) != fileList.end())
return true; return true;

2
lib/filesystem/CFilesystemLoader.h
View File

@ -37,7 +37,7 @@ public:
std::unique_ptr<CInputStream> load(const ResourcePath & resourceName) const override; std::unique_ptr<CInputStream> load(const ResourcePath & resourceName) const override;
bool existsResource(const ResourcePath & resourceName) const override; bool existsResource(const ResourcePath & resourceName) const override;
std::string getMountPoint() const override; std::string getMountPoint() const override;
bool createResource(std::string filename, bool update = false) override; bool createResource(const ResourcePath & filename, bool update = false) override;
std::optional<boost::filesystem::path> getResourceName(const ResourcePath & resourceName) const override; std::optional<boost::filesystem::path> getResourceName(const ResourcePath & resourceName) const override;
void updateFilteredFiles(std::function<bool(const std::string &)> filter) const override; void updateFilteredFiles(std::function<bool(const std::string &)> filter) const override;
std::unordered_set<ResourcePath> getFilteredFiles(std::function<bool(const ResourcePath &)> filter) const override; std::unordered_set<ResourcePath> getFilteredFiles(std::function<bool(const ResourcePath &)> filter) const override;

2
lib/filesystem/ISimpleResourceLoader.h
View File

@ -90,7 +90,7 @@ public:
* *
* @return true if new file was created, false on error or if file already exists * @return true if new file was created, false on error or if file already exists
*/ */
virtual bool createResource(std::string filename, bool update = false) virtual bool createResource(const ResourcePath & filename, bool update = false)
{ {
return false; return false;
} }

6
lib/filesystem/ResourcePath.h
View File

@ -19,7 +19,8 @@ class JsonSerializeFormat;
* *
* Supported file extensions: * Supported file extensions:
* *
* Text: .txt .json * Text: .txt
* Json: .json
* Animation: .def * Animation: .def
* Mask: .msk .msg * Mask: .msk .msg
* Campaign: .h3c * Campaign: .h3c
@ -36,6 +37,7 @@ class JsonSerializeFormat;
enum class EResType enum class EResType
{ {
TEXT, TEXT,
JSON,
ANIMATION, ANIMATION,
MASK, MASK,
CAMPAIGN, CAMPAIGN,
@ -167,6 +169,8 @@ public:
using AnimationPath = ResourcePathTempl<EResType::ANIMATION>; using AnimationPath = ResourcePathTempl<EResType::ANIMATION>;
using ImagePath = ResourcePathTempl<EResType::IMAGE>; using ImagePath = ResourcePathTempl<EResType::IMAGE>;
using TextPath = ResourcePathTempl<EResType::TEXT>;
using JsonPath = ResourcePathTempl<EResType::JSON>;
namespace EResTypeHelper namespace EResTypeHelper
{ {

2
lib/gameState/CGameState.cpp
View File

@ -804,7 +804,7 @@ void CGameState::removeHeroPlaceholders()
void CGameState::initStartingResources() void CGameState::initStartingResources()
{ {
logGlobal->debug("\tSetting up resources"); logGlobal->debug("\tSetting up resources");
const JsonNode config(ResourcePath("config/startres.json")); const JsonNode config(JsonPath::builtin("config/startres.json"));
const JsonVector &vector = config["difficulty"].Vector(); const JsonVector &vector = config["difficulty"].Vector();
const JsonNode &level = vector[scenarioOps->difficulty]; const JsonNode &level = vector[scenarioOps->difficulty];

8
lib/mapObjectConstructors/CObjectClassesHandler.cpp
View File

@ -112,7 +112,7 @@ std::vector<JsonNode> CObjectClassesHandler::loadLegacyData()
{ {
size_t dataSize = VLC->settings()->getInteger(EGameSettings::TEXTS_OBJECT); size_t dataSize = VLC->settings()->getInteger(EGameSettings::TEXTS_OBJECT);
CLegacyConfigParser parser("Data/Objects.txt"); CLegacyConfigParser parser(TextPath::builtin("Data/Objects.txt"));
auto totalNumber = static_cast<size_t>(parser.readNumber()); // first line contains number of objects to read and nothing else auto totalNumber = static_cast<size_t>(parser.readNumber()); // first line contains number of objects to read and nothing else
parser.endLine(); parser.endLine();
@ -132,7 +132,7 @@ std::vector<JsonNode> CObjectClassesHandler::loadLegacyData()
std::vector<JsonNode> ret(dataSize);// create storage for 256 objects std::vector<JsonNode> ret(dataSize);// create storage for 256 objects
assert(dataSize == 256); assert(dataSize == 256);
CLegacyConfigParser namesParser("Data/ObjNames.txt"); CLegacyConfigParser namesParser(TextPath::builtin("Data/ObjNames.txt"));
for (size_t i=0; i<256; i++) for (size_t i=0; i<256; i++)
{ {
ret[i]["name"].String() = namesParser.readString(); ret[i]["name"].String() = namesParser.readString();
@ -142,7 +142,7 @@ std::vector<JsonNode> CObjectClassesHandler::loadLegacyData()
JsonNode cregen1; JsonNode cregen1;
JsonNode cregen4; JsonNode cregen4;
CLegacyConfigParser cregen1Parser("data/crgen1"); CLegacyConfigParser cregen1Parser(TextPath::builtin("data/crgen1"));
do do
{ {
JsonNode subObject; JsonNode subObject;
@ -151,7 +151,7 @@ std::vector<JsonNode> CObjectClassesHandler::loadLegacyData()
} }
while(cregen1Parser.endLine()); while(cregen1Parser.endLine());
CLegacyConfigParser cregen4Parser("data/crgen4"); CLegacyConfigParser cregen4Parser(TextPath::builtin("data/crgen4"));
do do
{ {
JsonNode subObject; JsonNode subObject;

2
lib/mapObjects/CObjectHandler.cpp
View File

@ -19,7 +19,7 @@ VCMI_LIB_NAMESPACE_BEGIN
CObjectHandler::CObjectHandler() CObjectHandler::CObjectHandler()
{ {
logGlobal->trace("\t\tReading resources prices "); logGlobal->trace("\t\tReading resources prices ");
const JsonNode config2(ResourcePath("config/resources.json")); const JsonNode config2(JsonPath::builtin("config/resources.json"));
for(const JsonNode &price : config2["resources_prices"].Vector()) for(const JsonNode &price : config2["resources_prices"].Vector())
{ {
resVals.push_back(static_cast<ui32>(price.Float())); resVals.push_back(static_cast<ui32>(price.Float()));

4
lib/mapping/CMapService.cpp
View File

@ -154,9 +154,9 @@ std::unique_ptr<IMapLoader> CMapService::getMapLoader(std::unique_ptr<CInputStre
} }
} }
static JsonNode loadPatches(std::string path) static JsonNode loadPatches(const std::string & path)
{ {
JsonNode node = JsonUtils::assembleFromFiles(std::move(path)); JsonNode node = JsonUtils::assembleFromFiles(path);
for (auto & entry : node.Struct()) for (auto & entry : node.Struct())
JsonUtils::validate(entry.second, "vcmi:mapHeader", "patch for " + entry.first); JsonUtils::validate(entry.second, "vcmi:mapHeader", "patch for " + entry.first);

2
lib/mapping/MapEditUtils.cpp
View File

@ -174,7 +174,7 @@ void TerrainViewPattern::WeightedRule::setNative()
CTerrainViewPatternConfig::CTerrainViewPatternConfig() CTerrainViewPatternConfig::CTerrainViewPatternConfig()
{ {
const JsonNode config(ResourcePath("config/terrainViewPatterns.json")); const JsonNode config(JsonPath::builtin("config/terrainViewPatterns.json"));
static const std::string patternTypes[] = { "terrainView", "terrainType" }; static const std::string patternTypes[] = { "terrainView", "terrainType" };
for (int i = 0; i < std::size(patternTypes); ++i) for (int i = 0; i < std::size(patternTypes); ++i)
{ {

14
lib/modding/CModHandler.cpp
View File

@ -28,11 +28,11 @@
VCMI_LIB_NAMESPACE_BEGIN VCMI_LIB_NAMESPACE_BEGIN
static JsonNode loadModSettings(const std::string & path) static JsonNode loadModSettings(const JsonPath & path)
{ {
if (CResourceHandler::get("local")->existsResource(ResourcePath(path))) if (CResourceHandler::get("local")->existsResource(ResourcePath(path)))
{ {
return JsonNode(ResourcePath(path, EResType::TEXT)); return JsonNode(path);
} }
// Probably new install. Create initial configuration // Probably new install. Create initial configuration
CResourceHandler::get("local")->createResource(path); CResourceHandler::get("local")->createResource(path);
@ -200,9 +200,9 @@ void CModHandler::loadOneMod(std::string modName, const std::string & parent, co
return; return;
} }
if(CResourceHandler::get("initial")->existsResource(ResourcePath(CModInfo::getModFile(modFullName)))) if(CResourceHandler::get("initial")->existsResource(CModInfo::getModFile(modFullName)))
{ {
CModInfo mod(modFullName, modSettings[modName], JsonNode(ResourcePath(CModInfo::getModFile(modFullName)))); CModInfo mod(modFullName, modSettings[modName], JsonNode(CModInfo::getModFile(modFullName)));
if (!parent.empty()) // this is submod, add parent to dependencies if (!parent.empty()) // this is submod, add parent to dependencies
mod.dependencies.insert(parent); mod.dependencies.insert(parent);
@ -224,11 +224,11 @@ void CModHandler::loadMods(bool onlyEssential)
} }
else else
{ {
modConfig = loadModSettings("config/modSettings.json"); modConfig = loadModSettings(JsonPath::builtin("config/modSettings.json"));
loadMods("", "", modConfig["activeMods"], true); loadMods("", "", modConfig["activeMods"], true);
} }
coreMod = std::make_unique<CModInfo>(ModScope::scopeBuiltin(), modConfig[ModScope::scopeBuiltin()], JsonNode(ResourcePath("config/gameConfig.json"))); coreMod = std::make_unique<CModInfo>(ModScope::scopeBuiltin(), modConfig[ModScope::scopeBuiltin()], JsonNode(JsonPath::builtin("config/gameConfig.json")));
coreMod->name = "Original game files"; coreMod->name = "Original game files";
} }
@ -283,7 +283,7 @@ static ui32 calculateModChecksum(const std::string & modName, ISimpleResourceLoa
// FIXME: remove workaround for core mod // FIXME: remove workaround for core mod
if (modName != ModScope::scopeBuiltin()) if (modName != ModScope::scopeBuiltin())
{ {
ResourcePath modConfFile(CModInfo::getModFile(modName), EResType::TEXT); auto modConfFile = CModInfo::getModFile(modName);
ui32 configChecksum = CResourceHandler::get("initial")->load(modConfFile)->calculateCRC32(); ui32 configChecksum = CResourceHandler::get("initial")->load(modConfFile)->calculateCRC32();
modChecksum.process_bytes(reinterpret_cast<const void *>(&configChecksum), sizeof(configChecksum)); modChecksum.process_bytes(reinterpret_cast<const void *>(&configChecksum), sizeof(configChecksum));
} }

6
lib/modding/CModInfo.cpp
View File

@ -75,9 +75,9 @@ std::string CModInfo::getModDir(const std::string & name)
return "MODS/" + boost::algorithm::replace_all_copy(name, ".", "/MODS/"); return "MODS/" + boost::algorithm::replace_all_copy(name, ".", "/MODS/");
} }
std::string CModInfo::getModFile(const std::string & name) JsonPath CModInfo::getModFile(const std::string & name)
{ {
return getModDir(name) + "/mod.json"; return JsonPath::builtinTODO(getModDir(name) + "/mod.json");
} }
void CModInfo::updateChecksum(ui32 newChecksum) void CModInfo::updateChecksum(ui32 newChecksum)
@ -152,7 +152,7 @@ bool CModInfo::checkModGameplayAffecting() const
"obstacles" "obstacles"
}; };
ResourcePath modFileResource(CModInfo::getModFile(identifier)); JsonPath modFileResource(CModInfo::getModFile(identifier));
if(CResourceHandler::get("initial")->existsResource(modFileResource)) if(CResourceHandler::get("initial")->existsResource(modFileResource))
{ {

2
lib/modding/CModInfo.h
View File

@ -69,7 +69,7 @@ public:
void setEnabled(bool on); void setEnabled(bool on);
static std::string getModDir(const std::string & name); static std::string getModDir(const std::string & name);
static std::string getModFile(const std::string & name); static JsonPath getModFile(const std::string & name);
/// return true if this mod can affect gameplay, e.g. adds or modifies any game objects /// return true if this mod can affect gameplay, e.g. adds or modifies any game objects
bool checkModGameplayAffecting() const; bool checkModGameplayAffecting() const;

3
lib/rmg/CMapGenerator.cpp
View File

@ -51,8 +51,7 @@ int CMapGenerator::getRandomSeed() const
void CMapGenerator::loadConfig() void CMapGenerator::loadConfig()
{ {
static const ResourcePath path("config/randomMap.json"); JsonNode randomMapJson(JsonPath::builtin("config/randomMap.json"));
JsonNode randomMapJson(path);
config.shipyardGuard = randomMapJson["waterZone"]["shipyard"]["value"].Integer(); config.shipyardGuard = randomMapJson["waterZone"]["shipyard"]["value"].Integer();
for(auto & treasure : randomMapJson["waterZone"]["treasure"].Vector()) for(auto & treasure : randomMapJson["waterZone"]["treasure"].Vector())

2
lib/spells/CSpellHandler.cpp
View File

@ -561,7 +561,7 @@ std::vector<JsonNode> CSpellHandler::loadLegacyData()
using namespace SpellConfig; using namespace SpellConfig;
std::vector<JsonNode> legacyData; std::vector<JsonNode> legacyData;
CLegacyConfigParser parser("DATA/SPTRAITS.TXT"); CLegacyConfigParser parser(TextPath::builtin("DATA/SPTRAITS.TXT"));
auto readSchool = [&](JsonMap & schools, const std::string & name) auto readSchool = [&](JsonMap & schools, const std::string & name)
{ {

5
server/CGameHandler.cpp
View File

@ -1717,12 +1717,13 @@ void CGameHandler::save(const std::string & filename)
logGlobal->info("Saving to %s", filename); logGlobal->info("Saving to %s", filename);
const auto stem = FileInfo::GetPathStem(filename); const auto stem = FileInfo::GetPathStem(filename);
const auto savefname = stem.to_string() + ".vsgm1"; const auto savefname = stem.to_string() + ".vsgm1";
CResourceHandler::get("local")->createResource(savefname); ResourcePath savePath(stem.to_string(), EResType::SAVEGAME);
CResourceHandler::get("local")->createResource(savePath);
try try
{ {
{ {
CSaveFile save(*CResourceHandler::get("local")->getResourceName(ResourcePath(stem.to_string(), EResType::SAVEGAME))); CSaveFile save(*CResourceHandler::get("local")->getResourceName(savePath));
saveCommonState(save); saveCommonState(save);
logGlobal->info("Saving server state"); logGlobal->info("Saving server state");
save << *this; save << *this;

2
test/map/CMapEditManagerTest.cpp
View File

@ -120,7 +120,7 @@ TEST(MapManager, DrawTerrain_View)
// Validate edit manager // Validate edit manager
auto editManager = map->getEditManager(); auto editManager = map->getEditManager();
CRandomGenerator gen; CRandomGenerator gen;
const JsonNode viewNode(ResourcePath("test/terrainViewMappings", EResType::TEXT)); const JsonNode viewNode(JsonPath::builtin("test/terrainViewMappings"));
const auto & mappingsNode = viewNode["mappings"].Vector(); const auto & mappingsNode = viewNode["mappings"].Vector();
for (const auto & node : mappingsNode) for (const auto & node : mappingsNode)
{ {

20
test/map/CMapFormatTest.cpp
View File

@ -153,14 +153,14 @@ TEST(MapFormat, Objects)
{ {
static const std::string MAP_DATA_PATH = "test/ObjectPropertyTest/"; static const std::string MAP_DATA_PATH = "test/ObjectPropertyTest/";
const JsonNode initialHeader(ResourcePath(MAP_DATA_PATH + CMapFormatJson::HEADER_FILE_NAME)); const JsonNode initialHeader(JsonPath::builtin(MAP_DATA_PATH + CMapFormatJson::HEADER_FILE_NAME));
const JsonNode expectedHeader(ResourcePath(MAP_DATA_PATH + CMapFormatJson::HEADER_FILE_NAME));//same as initial for now const JsonNode expectedHeader(JsonPath::builtin(MAP_DATA_PATH + CMapFormatJson::HEADER_FILE_NAME));//same as initial for now
const JsonNode initialObjects(ResourcePath(MAP_DATA_PATH + CMapFormatJson::OBJECTS_FILE_NAME)); const JsonNode initialObjects(JsonPath::builtin(MAP_DATA_PATH + CMapFormatJson::OBJECTS_FILE_NAME));
const JsonNode expectedObjects(ResourcePath(MAP_DATA_PATH + "objects.ex.json")); const JsonNode expectedObjects(JsonPath::builtin(MAP_DATA_PATH + "objects.ex.json"));
const JsonNode expectedSurface(ResourcePath(MAP_DATA_PATH + "surface_terrain.json")); const JsonNode expectedSurface(JsonPath::builtin(MAP_DATA_PATH + "surface_terrain.json"));
const JsonNode expectedUnderground(ResourcePath(MAP_DATA_PATH + "underground_terrain.json")); const JsonNode expectedUnderground(JsonPath::builtin(MAP_DATA_PATH + "underground_terrain.json"));
std::unique_ptr<CMap> originalMap = loadOriginal(initialHeader, initialObjects, expectedSurface, expectedUnderground); std::unique_ptr<CMap> originalMap = loadOriginal(initialHeader, initialObjects, expectedSurface, expectedUnderground);
@ -192,11 +192,11 @@ TEST(MapFormat, Terrain)
{ {
static const std::string MAP_DATA_PATH = "test/TerrainTest/"; static const std::string MAP_DATA_PATH = "test/TerrainTest/";
const JsonNode expectedHeader(ResourcePath(MAP_DATA_PATH + CMapFormatJson::HEADER_FILE_NAME)); const JsonNode expectedHeader(JsonPath::builtin(MAP_DATA_PATH + CMapFormatJson::HEADER_FILE_NAME));
const JsonNode expectedObjects(ResourcePath(MAP_DATA_PATH + CMapFormatJson::OBJECTS_FILE_NAME)); const JsonNode expectedObjects(JsonPath::builtin(MAP_DATA_PATH + CMapFormatJson::OBJECTS_FILE_NAME));
const JsonNode expectedSurface(ResourcePath(MAP_DATA_PATH + "surface_terrain.json")); const JsonNode expectedSurface(JsonPath::builtin(MAP_DATA_PATH + "surface_terrain.json"));
const JsonNode expectedUnderground(ResourcePath(MAP_DATA_PATH + "underground_terrain.json")); const JsonNode expectedUnderground(JsonPath::builtin(MAP_DATA_PATH + "underground_terrain.json"));
std::unique_ptr<CMap> originalMap = loadOriginal(expectedHeader, expectedObjects, expectedSurface, expectedUnderground); std::unique_ptr<CMap> originalMap = loadOriginal(expectedHeader, expectedObjects, expectedSurface, expectedUnderground);

8
test/mock/mock_MapService.cpp
View File

@ -23,15 +23,15 @@ MapServiceMock::MapServiceMock(const std::string & path, MapListener * mapListen
CZipSaver saver(io, "_"); CZipSaver saver(io, "_");
const JsonNode header(ResourcePath(path+CMapFormatJson::HEADER_FILE_NAME)); const JsonNode header(JsonPath::builtin(path+CMapFormatJson::HEADER_FILE_NAME));
const JsonNode objects(ResourcePath(path+CMapFormatJson::OBJECTS_FILE_NAME)); const JsonNode objects(JsonPath::builtin(path+CMapFormatJson::OBJECTS_FILE_NAME));
const JsonNode surface(ResourcePath(path+"surface_terrain.json")); const JsonNode surface(JsonPath::builtin(path+"surface_terrain.json"));
addToArchive(saver, header, CMapFormatJson::HEADER_FILE_NAME); addToArchive(saver, header, CMapFormatJson::HEADER_FILE_NAME);
addToArchive(saver, objects, CMapFormatJson::OBJECTS_FILE_NAME); addToArchive(saver, objects, CMapFormatJson::OBJECTS_FILE_NAME);
addToArchive(saver, surface, "surface_terrain.json"); addToArchive(saver, surface, "surface_terrain.json");
ResourcePath undergroundPath(path+"underground_terrain.json"); auto undergroundPath = JsonPath::builtin(path+"underground_terrain.json");
if(CResourceHandler::get()->existsResource(undergroundPath)) if(CResourceHandler::get()->existsResource(undergroundPath))
{ {