aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/CMakeLists.txt1
-rw-r--r--src/emerge.cpp40
-rw-r--r--src/emerge.h15
-rw-r--r--src/map.cpp100
-rw-r--r--src/map.h10
-rw-r--r--src/map_settings_manager.cpp194
-rw-r--r--src/map_settings_manager.h79
-rw-r--r--src/mapgen.cpp68
-rw-r--r--src/mapgen.h20
-rw-r--r--src/mapgen_flat.cpp28
-rw-r--r--src/mapgen_flat.h4
-rw-r--r--src/mapgen_fractal.cpp34
-rw-r--r--src/mapgen_fractal.h4
-rw-r--r--src/mapgen_singlenode.h2
-rw-r--r--src/mapgen_v5.cpp20
-rw-r--r--src/mapgen_v5.h4
-rw-r--r--src/mapgen_v6.cpp33
-rw-r--r--src/mapgen_v6.h4
-rw-r--r--src/mapgen_v7.cpp30
-rw-r--r--src/mapgen_v7.h4
-rw-r--r--src/mapgen_valleys.cpp41
-rw-r--r--src/mapgen_valleys.h4
-rw-r--r--src/script/lua_api/l_mapgen.cpp154
-rw-r--r--src/script/lua_api/l_mapgen.h12
-rw-r--r--src/script/lua_api/l_vmanip.cpp2
-rw-r--r--src/server.cpp15
-rw-r--r--src/subgame.cpp4
-rw-r--r--src/unittest/CMakeLists.txt1
-rw-r--r--src/unittest/test_map_settings_manager.cpp255
29 files changed, 868 insertions, 314 deletions
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index bffc1f7eb..bcd7a5984 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -414,6 +414,7 @@ set(common_SRCS
light.cpp
log.cpp
map.cpp
+ map_settings_manager.cpp
mapblock.cpp
mapgen.cpp
mapgen_flat.cpp
diff --git a/src/emerge.cpp b/src/emerge.cpp
index 48de6cb1a..daf42f5e2 100644
--- a/src/emerge.cpp
+++ b/src/emerge.cpp
@@ -156,37 +156,19 @@ EmergeManager::~EmergeManager()
}
-void EmergeManager::loadMapgenParams()
-{
- params.load(*g_settings);
-}
-
-
-void EmergeManager::initMapgens()
+bool EmergeManager::initMapgens(MapgenParams *params)
{
if (m_mapgens.size())
- return;
-
- MapgenType mgtype = Mapgen::getMapgenType(params.mg_name);
- if (mgtype == MAPGEN_INVALID) {
- const char *default_mapgen_name = Mapgen::getMapgenName(MAPGEN_DEFAULT);
- errorstream << "EmergeManager: mapgen " << params.mg_name <<
- " not registered; falling back to " <<
- default_mapgen_name << std::endl;
-
- params.mg_name = default_mapgen_name;
- mgtype = MAPGEN_DEFAULT;
- }
+ return false;
- if (!params.sparams) {
- params.sparams = Mapgen::createMapgenParams(mgtype);
- params.sparams->readParams(g_settings);
- }
+ this->mgparams = params;
for (u32 i = 0; i != m_threads.size(); i++) {
- Mapgen *mg = Mapgen::createMapgen(mgtype, i, &params, this);
+ Mapgen *mg = Mapgen::createMapgen(params->mgtype, i, params, this);
m_mapgens.push_back(mg);
}
+
+ return true;
}
@@ -288,12 +270,14 @@ bool EmergeManager::enqueueBlockEmergeEx(
// Mapgen-related helper functions
//
+
+// TODO(hmmmm): Move this to ServerMap
v3s16 EmergeManager::getContainingChunk(v3s16 blockpos)
{
- return getContainingChunk(blockpos, params.chunksize);
+ return getContainingChunk(blockpos, mgparams->chunksize);
}
-
+// TODO(hmmmm): Move this to ServerMap
v3s16 EmergeManager::getContainingChunk(v3s16 blockpos, s16 chunksize)
{
s16 coff = -chunksize / 2;
@@ -327,7 +311,7 @@ int EmergeManager::getGroundLevelAtPoint(v2s16 p)
return m_mapgens[0]->getGroundLevelAtPoint(p);
}
-
+// TODO(hmmmm): Move this to ServerMap
bool EmergeManager::isBlockUnderground(v3s16 blockpos)
{
#if 0
@@ -338,7 +322,7 @@ bool EmergeManager::isBlockUnderground(v3s16 blockpos)
#endif
// Use a simple heuristic; the above method is wildly inaccurate anyway.
- return blockpos.Y * (MAP_BLOCKSIZE + 1) <= params.water_level;
+ return blockpos.Y * (MAP_BLOCKSIZE + 1) <= mgparams->water_level;
}
bool EmergeManager::pushBlockEmergeData(
diff --git a/src/emerge.h b/src/emerge.h
index 303a35529..cf0677145 100644
--- a/src/emerge.h
+++ b/src/emerge.h
@@ -97,8 +97,16 @@ public:
u32 gen_notify_on;
std::set<u32> gen_notify_on_deco_ids;
- // Map generation parameters
- MapgenParams params;
+ // Parameters passed to mapgens owned by ServerMap
+ // TODO(hmmmm): Remove this after mapgen helper methods using them
+ // are moved to ServerMap
+ MapgenParams *mgparams;
+
+ // Hackish workaround:
+ // For now, EmergeManager must hold onto a ptr to the Map's setting manager
+ // since the Map can only be accessed through the Environment, and the
+ // Environment is not created until after script initialization.
+ MapSettingsManager *map_settings_mgr;
// Managers of various map generation-related components
BiomeManager *biomemgr;
@@ -110,8 +118,7 @@ public:
EmergeManager(IGameDef *gamedef);
~EmergeManager();
- void loadMapgenParams();
- void initMapgens();
+ bool initMapgens(MapgenParams *mgparams);
void startThreads();
void stopThreads();
diff --git a/src/map.cpp b/src/map.cpp
index a1f2086ce..38f0fa37c 100644
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -2130,11 +2130,15 @@ void Map::removeNodeTimer(v3s16 p)
*/
ServerMap::ServerMap(std::string savedir, IGameDef *gamedef, EmergeManager *emerge):
Map(dout_server, gamedef),
+ settings_mgr(g_settings, savedir + DIR_DELIM + "map_meta.txt"),
m_emerge(emerge),
m_map_metadata_changed(true)
{
verbosestream<<FUNCTION_NAME<<std::endl;
+ // Tell the EmergeManager about our MapSettingsManager
+ emerge->map_settings_mgr = &settings_mgr;
+
/*
Try to load map; if not found, create a new one.
*/
@@ -2170,26 +2174,15 @@ ServerMap::ServerMap(std::string savedir, IGameDef *gamedef, EmergeManager *emer
}
else
{
- try{
- // Load map metadata (seed, chunksize)
- loadMapMeta();
- }
- catch(SettingNotFoundException &e){
- infostream<<"ServerMap: Some metadata not found."
- <<" Using default settings."<<std::endl;
- }
- catch(FileNotGoodException &e){
- warningstream<<"Could not load map metadata"
- //<<" Disabling chunk-based generator."
- <<std::endl;
- //m_chunksize = 0;
- }
- infostream<<"ServerMap: Successfully loaded map "
- <<"metadata from "<<savedir
- <<", assuming valid save directory."
- <<" seed="<< m_emerge->params.seed <<"."
- <<std::endl;
+ if (settings_mgr.loadMapMeta()) {
+ infostream << "ServerMap: Metadata loaded from "
+ << savedir << std::endl;
+ } else {
+ infostream << "ServerMap: Metadata could not be loaded "
+ "from " << savedir << ", assuming valid save "
+ "directory." << std::endl;
+ }
m_map_saving_enabled = true;
// Map loaded, not creating new one
@@ -2259,19 +2252,26 @@ ServerMap::~ServerMap()
#endif
}
+MapgenParams *ServerMap::getMapgenParams()
+{
+ // getMapgenParams() should only ever be called after Server is initialized
+ assert(settings_mgr.mapgen_params != NULL);
+ return settings_mgr.mapgen_params;
+}
+
u64 ServerMap::getSeed()
{
- return m_emerge->params.seed;
+ return getMapgenParams()->seed;
}
s16 ServerMap::getWaterLevel()
{
- return m_emerge->params.water_level;
+ return getMapgenParams()->water_level;
}
bool ServerMap::initBlockMake(v3s16 blockpos, BlockMakeData *data)
{
- s16 csize = m_emerge->params.chunksize;
+ s16 csize = getMapgenParams()->chunksize;
v3s16 bpmin = EmergeManager::getContainingChunk(blockpos, csize);
v3s16 bpmax = bpmin + v3s16(1, 1, 1) * (csize - 1);
@@ -2287,7 +2287,7 @@ bool ServerMap::initBlockMake(v3s16 blockpos, BlockMakeData *data)
blockpos_over_limit(full_bpmax))
return false;
- data->seed = m_emerge->params.seed;
+ data->seed = getSeed();
data->blockpos_min = bpmin;
data->blockpos_max = bpmax;
data->blockpos_requested = blockpos;
@@ -2905,8 +2905,9 @@ void ServerMap::save(ModifiedState save_level)
infostream<<"ServerMap: Saving whole map, this can take time."
<<std::endl;
- if(m_map_metadata_changed || save_level == MOD_STATE_CLEAN) {
- saveMapMeta();
+ if (m_map_metadata_changed || save_level == MOD_STATE_CLEAN) {
+ if (settings_mgr.saveMapMeta())
+ m_map_metadata_changed = false;
}
// Profile modified reasons
@@ -3005,55 +3006,6 @@ void ServerMap::listAllLoadedBlocks(std::vector<v3s16> &dst)
}
}
-void ServerMap::saveMapMeta()
-{
- DSTACK(FUNCTION_NAME);
-
- createDirs(m_savedir);
-
- std::string fullpath = m_savedir + DIR_DELIM + "map_meta.txt";
- std::ostringstream oss(std::ios_base::binary);
- Settings conf;
-
- m_emerge->params.save(conf);
- conf.writeLines(oss);
-
- oss << "[end_of_params]\n";
-
- if(!fs::safeWriteToFile(fullpath, oss.str())) {
- errorstream << "ServerMap::saveMapMeta(): "
- << "could not write " << fullpath << std::endl;
- throw FileNotGoodException("Cannot save chunk metadata");
- }
-
- m_map_metadata_changed = false;
-}
-
-void ServerMap::loadMapMeta()
-{
- DSTACK(FUNCTION_NAME);
-
- Settings conf;
- std::string fullpath = m_savedir + DIR_DELIM + "map_meta.txt";
-
- std::ifstream is(fullpath.c_str(), std::ios_base::binary);
- if (!is.good()) {
- errorstream << "ServerMap::loadMapMeta(): "
- "could not open " << fullpath << std::endl;
- throw FileNotGoodException("Cannot open map metadata");
- }
-
- if (!conf.parseConfigLines(is, "[end_of_params]")) {
- throw SerializationError("ServerMap::loadMapMeta(): "
- "[end_of_params] not found!");
- }
-
- m_emerge->params.load(conf);
-
- verbosestream << "ServerMap::loadMapMeta(): seed="
- << m_emerge->params.seed << std::endl;
-}
-
void ServerMap::saveSectorMeta(ServerMapSector *sector)
{
DSTACK(FUNCTION_NAME);
diff --git a/src/map.h b/src/map.h
index 23da56471..13775fde1 100644
--- a/src/map.h
+++ b/src/map.h
@@ -33,6 +33,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "modifiedstate.h"
#include "util/container.h"
#include "nodetimer.h"
+#include "map_settings_manager.h"
class Settings;
class Database;
@@ -46,8 +47,6 @@ class IRollbackManager;
class EmergeManager;
class ServerEnvironment;
struct BlockMakeData;
-struct MapgenParams;
-
/*
MapEditEvent
@@ -463,9 +462,8 @@ public:
void save(ModifiedState save_level);
void listAllLoadableBlocks(std::vector<v3s16> &dst);
void listAllLoadedBlocks(std::vector<v3s16> &dst);
- // Saves map seed and possibly other stuff
- void saveMapMeta();
- void loadMapMeta();
+
+ MapgenParams *getMapgenParams();
/*void saveChunkMeta();
void loadChunkMeta();*/
@@ -506,6 +504,8 @@ public:
u64 getSeed();
s16 getWaterLevel();
+ MapSettingsManager settings_mgr;
+
private:
// Emerge manager
EmergeManager *m_emerge;
diff --git a/src/map_settings_manager.cpp b/src/map_settings_manager.cpp
new file mode 100644
index 000000000..53d17125c
--- /dev/null
+++ b/src/map_settings_manager.cpp
@@ -0,0 +1,194 @@
+/*
+Minetest
+Copyright (C) 2010-2013 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "debug.h"
+#include "filesys.h"
+#include "log.h"
+#include "mapgen.h"
+#include "settings.h"
+
+#include "map_settings_manager.h"
+
+MapSettingsManager::MapSettingsManager(
+ Settings *user_settings, const std::string &map_meta_path)
+{
+ m_map_meta_path = map_meta_path;
+ m_user_settings = user_settings;
+ m_map_settings = new Settings;
+ mapgen_params = NULL;
+
+ assert(m_user_settings != NULL);
+}
+
+
+MapSettingsManager::~MapSettingsManager()
+{
+ delete m_map_settings;
+ delete mapgen_params;
+}
+
+
+bool MapSettingsManager::getMapSetting(
+ const std::string &name, std::string *value_out)
+{
+ if (m_map_settings->getNoEx(name, *value_out))
+ return true;
+
+ // Compatibility kludge
+ if (m_user_settings == g_settings && name == "seed")
+ return m_user_settings->getNoEx("fixed_map_seed", *value_out);
+
+ return m_user_settings->getNoEx(name, *value_out);
+}
+
+
+bool MapSettingsManager::getMapSettingNoiseParams(
+ const std::string &name, NoiseParams *value_out)
+{
+ return m_map_settings->getNoiseParams(name, *value_out) ||
+ m_user_settings->getNoiseParams(name, *value_out);
+}
+
+
+bool MapSettingsManager::setMapSetting(
+ const std::string &name, const std::string &value, bool override_meta)
+{
+ if (mapgen_params)
+ return false;
+
+ if (override_meta)
+ m_map_settings->set(name, value);
+ else
+ m_map_settings->setDefault(name, value);
+
+ return true;
+}
+
+
+bool MapSettingsManager::setMapSettingNoiseParams(
+ const std::string &name, const NoiseParams *value, bool override_meta)
+{
+ if (mapgen_params)
+ return false;
+
+ m_map_settings->setNoiseParams(name, *value, !override_meta);
+ return true;
+}
+
+
+bool MapSettingsManager::loadMapMeta()
+{
+ std::ifstream is(m_map_meta_path.c_str(), std::ios_base::binary);
+
+ if (!is.good()) {
+ errorstream << "loadMapMeta: could not open "
+ << m_map_meta_path << std::endl;
+ return false;
+ }
+
+ if (!m_map_settings->parseConfigLines(is, "[end_of_params]")) {
+ errorstream << "loadMapMeta: [end_of_params] not found!" << std::endl;
+ return false;
+ }
+
+ return true;
+}
+
+
+bool MapSettingsManager::saveMapMeta()
+{
+ // If mapgen params haven't been created yet; abort
+ if (!mapgen_params)
+ return false;
+
+ if (!fs::CreateAllDirs(fs::RemoveLastPathComponent(m_map_meta_path))) {
+ errorstream << "saveMapMeta: could not create dirs to "
+ << m_map_meta_path;
+ return false;
+ }
+
+ std::ostringstream oss(std::ios_base::binary);
+ Settings conf;
+
+ mapgen_params->MapgenParams::writeParams(&conf);
+ mapgen_params->writeParams(&conf);
+ conf.writeLines(oss);
+
+ // NOTE: If there are ever types of map settings other than
+ // those relating to map generation, save them here
+
+ oss << "[end_of_params]\n";
+
+ if (!fs::safeWriteToFile(m_map_meta_path, oss.str())) {
+ errorstream << "saveMapMeta: could not write "
+ << m_map_meta_path << std::endl;
+ return false;
+ }
+
+ return true;
+}
+
+
+MapgenParams *MapSettingsManager::makeMapgenParams()
+{
+ if (mapgen_params)
+ return mapgen_params;
+
+ assert(m_user_settings != NULL);
+ assert(m_map_settings != NULL);
+
+ // At this point, we have (in order of precedence):
+ // 1). m_mapgen_settings->m_settings containing map_meta.txt settings or
+ // explicit overrides from scripts
+ // 2). m_mapgen_settings->m_defaults containing script-set mgparams without
+ // overrides
+ // 3). g_settings->m_settings containing all user-specified config file
+ // settings
+ // 4). g_settings->m_defaults containing any low-priority settings from
+ // scripts, e.g. mods using Lua as an enhanced config file)
+
+ // Now, get the mapgen type so we can create the appropriate MapgenParams
+ std::string mg_name;
+ MapgenType mgtype = getMapSetting("mg_name", &mg_name) ?
+ Mapgen::getMapgenType(mg_name) : MAPGEN_DEFAULT;
+ if (mgtype == MAPGEN_INVALID) {
+ errorstream << "EmergeManager: mapgen '" << mg_name <<
+ "' not valid; falling back to " <<
+ Mapgen::getMapgenName(MAPGEN_DEFAULT) << std::endl;
+ mgtype = MAPGEN_DEFAULT;
+ }
+
+ // Create our MapgenParams
+ MapgenParams *params = Mapgen::createMapgenParams(mgtype);
+ if (params == NULL)
+ return NULL;
+
+ params->mgtype = mgtype;
+
+ // Load the rest of the mapgen params from our active settings
+ params->MapgenParams::readParams(m_user_settings);
+ params->MapgenParams::readParams(m_map_settings);
+ params->readParams(m_user_settings);
+ params->readParams(m_map_settings);
+
+ // Hold onto our params
+ mapgen_params = params;
+
+ return params;
+}
diff --git a/src/map_settings_manager.h b/src/map_settings_manager.h
new file mode 100644
index 000000000..9f766f1f0
--- /dev/null
+++ b/src/map_settings_manager.h
@@ -0,0 +1,79 @@
+/*
+Minetest
+Copyright (C) 2010-2013 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifndef MAP_SETTINGS_MANAGER_HEADER
+#define MAP_SETTINGS_MANAGER_HEADER
+
+#include <string>
+
+class Settings;
+struct NoiseParams;
+struct MapgenParams;
+
+/*
+ MapSettingsManager is a centralized object for management (creating,
+ loading, storing, saving, etc.) of config settings related to the Map.
+
+ It has two phases: the initial r/w "gather and modify settings" state, and
+ the final r/o "read and save settings" state.
+
+ The typical use case is, in order, as follows:
+ - Create a MapSettingsManager object
+ - Try to load map metadata into it from the metadata file
+ - Manually view and modify the current configuration as desired through a
+ Settings-like interface
+ - When all modifications are finished, create a 'Parameters' object
+ containing the finalized, active parameters. This could be passed along
+ to whichever Map-related objects that may require it.
+ - Save these active settings to the metadata file when requested
+*/
+class MapSettingsManager {
+public:
+ // Finalized map generation parameters
+ MapgenParams *mapgen_params;
+
+ MapSettingsManager(Settings *user_settings,
+ const std::string &map_meta_path);
+ ~MapSettingsManager();
+
+ bool getMapSetting(const std::string &name, std::string *value_out);
+
+ bool getMapSettingNoiseParams(
+ const std::string &name, NoiseParams *value_out);
+
+ // Note: Map config becomes read-only after makeMapgenParams() gets called
+ // (i.e. mapgen_params is non-NULL). Attempts to set map config after
+ // params have been finalized will result in failure.
+ bool setMapSetting(const std::string &name,
+ const std::string &value, bool override_meta = false);
+
+ bool setMapSettingNoiseParams(const std::string &name,
+ const NoiseParams *value, bool override_meta = false);
+
+ bool loadMapMeta();
+ bool saveMapMeta();
+ MapgenParams *makeMapgenParams();
+
+private:
+ std::string m_map_meta_path;
+ Settings *m_map_settings;
+ Settings *m_user_settings;
+};
+
+#endif
diff --git a/src/mapgen.cpp b/src/mapgen.cpp
index e45233b33..b6fda91ac 100644
--- a/src/mapgen.cpp
+++ b/src/mapgen.cpp
@@ -176,26 +176,26 @@ Mapgen *Mapgen::createMapgen(MapgenType mgtype, int mgid,
{
switch (mgtype) {
case MAPGEN_FLAT:
- return new MapgenFlat(mgid, params, emerge);
+ return new MapgenFlat(mgid, (MapgenFlatParams *)params, emerge);
case MAPGEN_FRACTAL:
- return new MapgenFractal(mgid, params, emerge);
+ return new MapgenFractal(mgid, (MapgenFractalParams *)params, emerge);
case MAPGEN_SINGLENODE:
- return new MapgenSinglenode(mgid, params, emerge);
+ return new MapgenSinglenode(mgid, (MapgenSinglenodeParams *)params, emerge);
case MAPGEN_V5:
- return new MapgenV5(mgid, params, emerge);
+ return new MapgenV5(mgid, (MapgenV5Params *)params, emerge);
case MAPGEN_V6:
- return new MapgenV6(mgid, params, emerge);
+ return new MapgenV6(mgid, (MapgenV6Params *)params, emerge);
case MAPGEN_V7:
- return new MapgenV7(mgid, params, emerge);
+ return new MapgenV7(mgid, (MapgenV7Params *)params, emerge);
case MAPGEN_VALLEYS:
- return new MapgenValleys(mgid, params, emerge);
+ return new MapgenValleys(mgid, (MapgenValleysParams *)params, emerge);
default:
return NULL;
}
}
-MapgenSpecificParams *Mapgen::createMapgenParams(MapgenType mgtype)
+MapgenParams *Mapgen::createMapgenParams(MapgenType mgtype)
{
switch (mgtype) {
case MAPGEN_FLAT:
@@ -970,52 +970,46 @@ void GenerateNotifier::getEvents(
MapgenParams::~MapgenParams()
{
delete bparams;
- delete sparams;
}
-void MapgenParams::load(const Settings &settings)
+void MapgenParams::readParams(const Settings *settings)
{
std::string seed_str;
- const char *seed_name = (&settings == g_settings) ? "fixed_map_seed" : "seed";
+ const char *seed_name = (settings == g_settings) ? "fixed_map_seed" : "seed";
- if (settings.getNoEx(seed_name, seed_str) && !seed_str.empty())
- seed = read_seed(seed_str.c_str());
- else
- myrand_bytes(&seed, sizeof(seed));
+ if (settings->getNoEx(seed_name, seed_str)) {
+ if (!seed_str.empty())
+ seed = read_seed(seed_str.c_str());
+ else
+ myrand_bytes(&seed, sizeof(seed));
+ }
+
+ std::string mg_name;
+ if (settings->getNoEx("mg_name", mg_name))
+ this->mgtype = Mapgen::getMapgenType(mg_name);
- settings.getNoEx("mg_name", mg_name);
- settings.getS16NoEx("water_level", water_level);
- settings.getS16NoEx("chunksize", chunksize);
- settings.getFlagStrNoEx("mg_flags", flags, flagdesc_mapgen);
+ settings->getS16NoEx("water_level", water_level);
+ settings->getS16NoEx("chunksize", chunksize);
+ settings->getFlagStrNoEx("mg_flags", flags, flagdesc_mapgen);
delete bparams;
bparams = BiomeManager::createBiomeParams(BIOMEGEN_ORIGINAL);
if (bparams) {
- bparams->readParams(&settings);
+ bparams->readParams(settings);
bparams->seed = seed;
}
-
- delete sparams;
- MapgenType mgtype = Mapgen::getMapgenType(mg_name);
- if (mgtype != MAPGEN_INVALID) {
- sparams = Mapgen::createMapgenParams(mgtype);
- sparams->readParams(&settings);
- }
}
-void MapgenParams::save(Settings &settings) const
+void MapgenParams::writeParams(Settings *settings) const
{
- settings.set("mg_name", mg_name);
- settings.setU64("seed", seed);
- settings.setS16("water_level", water_level);
- settings.setS16("chunksize", chunksize);
- settings.setFlagStr("mg_flags", flags, flagdesc_mapgen, U32_MAX);
+ settings->set("mg_name", Mapgen::getMapgenName(mgtype));
+ settings->setU64("seed", seed);
+ settings->setS16("water_level", water_level);
+ settings->setS16("chunksize", chunksize);
+ settings->setFlagStr("mg_flags", flags, flagdesc_mapgen, U32_MAX);
if (bparams)
- bparams->writeParams(&settings);
-
- if (sparams)
- sparams->writeParams(&settings);
+ bparams->writeParams(settings);
}
diff --git a/src/mapgen.h b/src/mapgen.h
index 618a2f6b8..5fcf2a365 100644
--- a/src/mapgen.h
+++ b/src/mapgen.h
@@ -119,37 +119,29 @@ enum MapgenType {
MAPGEN_INVALID,
};
-struct MapgenSpecificParams {
- virtual void readParams(const Settings *settings) = 0;
- virtual void writeParams(Settings *settings) const = 0;
- virtual ~MapgenSpecificParams() {}
-};
-
struct MapgenParams {
- std::string mg_name;
+ MapgenType mgtype;
s16 chunksize;
u64 seed;
s16 water_level;
u32 flags;
BiomeParams *bparams;
- MapgenSpecificParams *sparams;
MapgenParams() :
- mg_name(MAPGEN_DEFAULT_NAME),
+ mgtype(MAPGEN_DEFAULT),
chunksize(5),
seed(0),
water_level(1),
flags(MG_CAVES | MG_LIGHT | MG_DECORATIONS),
- bparams(NULL),
- sparams(NULL)
+ bparams(NULL)
{
}
virtual ~MapgenParams();
- void load(const Settings &settings);
- void save(Settings &settings) const;
+ virtual void readParams(const Settings *settings);
+ virtual void writeParams(Settings *settings) const;
};
@@ -217,7 +209,7 @@ public:
static const char *getMapgenName(MapgenType mgtype);
static Mapgen *createMapgen(MapgenType mgtype, int mgid,
MapgenParams *params, EmergeManager *emerge);
- static MapgenSpecificParams *createMapgenParams(MapgenType mgtype);
+ static MapgenParams *createMapgenParams(MapgenType mgtype);
static void getMapgenNames(std::vector<const char *> *mgnames, bool include_hidden);
private:
diff --git a/src/mapgen_flat.cpp b/src/mapgen_flat.cpp
index 956af999a..2c1715e61 100644
--- a/src/mapgen_flat.cpp
+++ b/src/mapgen_flat.cpp
@@ -49,26 +49,24 @@ FlagDesc flagdesc_mapgen_flat[] = {
///////////////////////////////////////////////////////////////////////////////////////
-MapgenFlat::MapgenFlat(int mapgenid, MapgenParams *params, EmergeManager *emerge)
+MapgenFlat::MapgenFlat(int mapgenid, MapgenFlatParams *params, EmergeManager *emerge)
: MapgenBasic(mapgenid, params, emerge)
{
- MapgenFlatParams *sp = (MapgenFlatParams *)params->sparams;
-
- this->spflags = sp->spflags;
- this->ground_level = sp->ground_level;
- this->large_cave_depth = sp->large_cave_depth;
- this->cave_width = sp->cave_width;
- this->lake_threshold = sp->lake_threshold;
- this->lake_steepness = sp->lake_steepness;
- this->hill_threshold = sp->hill_threshold;
- this->hill_steepness = sp->hill_steepness;
+ this->spflags = params->spflags;
+ this->ground_level = params->ground_level;
+ this->large_cave_depth = params->large_cave_depth;
+ this->cave_width = params->cave_width;
+ this->lake_threshold = params->lake_threshold;
+ this->lake_steepness = params->lake_steepness;
+ this->hill_threshold = params->hill_threshold;
+ this->hill_steepness = params->hill_steepness;
//// 2D noise
- noise_terrain = new Noise(&sp->np_terrain, seed, csize.X, csize.Z);
- noise_filler_depth = new Noise(&sp->np_filler_depth, seed, csize.X, csize.Z);
+ noise_terrain = new Noise(&params->np_terrain, seed, csize.X, csize.Z);
+ noise_filler_depth = new Noise(&params->np_filler_depth, seed, csize.X, csize.Z);
- MapgenBasic::np_cave1 = sp->np_cave1;
- MapgenBasic::np_cave2 = sp->np_cave2;
+ MapgenBasic::np_cave1 = params->np_cave1;
+ MapgenBasic::np_cave2 = params->np_cave2;
}
diff --git a/src/mapgen_flat.h b/src/mapgen_flat.h
index 39b6dc302..8b3de2bcf 100644
--- a/src/mapgen_flat.h
+++ b/src/mapgen_flat.h
@@ -32,7 +32,7 @@ class BiomeManager;
extern FlagDesc flagdesc_mapgen_flat[];
-struct MapgenFlatParams : public MapgenSpecificParams {
+struct MapgenFlatParams : public MapgenParams {
u32 spflags;
s16 ground_level;
s16 large_cave_depth;
@@ -55,7 +55,7 @@ struct MapgenFlatParams : public MapgenSpecificParams {
class MapgenFlat : public MapgenBasic {
public:
- MapgenFlat(int mapgenid, MapgenParams *params, EmergeManager *emerge);
+ MapgenFlat(int mapgenid, MapgenFlatParams *params, EmergeManager *emerge);
~MapgenFlat();
virtual MapgenType getType() const { return MAPGEN_FLAT; }
diff --git a/src/mapgen_fractal.cpp b/src/mapgen_fractal.cpp
index 9e4c210dc..0951a0afa 100644
--- a/src/mapgen_fractal.cpp
+++ b/src/mapgen_fractal.cpp
@@ -47,29 +47,27 @@ FlagDesc flagdesc_mapgen_fractal[] = {
///////////////////////////////////////////////////////////////////////////////////////
-MapgenFractal::MapgenFractal(int mapgenid, MapgenParams *params, EmergeManager *emerge)
+MapgenFractal::MapgenFractal(int mapgenid, MapgenFractalParams *params, EmergeManager *emerge)
: MapgenBasic(mapgenid, params, emerge)
{
- MapgenFractalParams *sp = (MapgenFractalParams *)params->sparams;
-
- this->spflags = sp->spflags;
- this->cave_width = sp->cave_width;
- this->fractal = sp->fractal;
- this->iterations = sp->iterations;
- this->scale = sp->scale;
- this->offset = sp->offset;
- this->slice_w = sp->slice_w;
- this->julia_x = sp->julia_x;
- this->julia_y = sp->julia_y;
- this->julia_z = sp->julia_z;
- this->julia_w = sp->julia_w;
+ this->spflags = params->spflags;
+ this->cave_width = params->cave_width;
+ this->fractal = params->fractal;
+ this->iterations = params->iterations;
+ this->scale = params->scale;
+ this->offset = params->offset;
+ this->slice_w = params->slice_w;
+ this->julia_x = params->julia_x;
+ this->julia_y = params->julia_y;
+ this->julia_z = params->julia_z;
+ this->julia_w = params->julia_w;
//// 2D terrain noise
- noise_seabed = new Noise(&sp->np_seabed, seed, csize.X, csize.Z);
- noise_filler_depth = new Noise(&sp->np_filler_depth, seed, csize.X, csize.Z);
+ noise_seabed = new Noise(&params->np_seabed, seed, csize.X, csize.Z);
+ noise_filler_depth = new Noise(&params->np_filler_depth, seed, csize.X, csize.Z);
- MapgenBasic::np_cave1 = sp->np_cave1;
- MapgenBasic::np_cave2 = sp->np_cave2;
+ MapgenBasic::np_cave1 = params->np_cave1;
+ MapgenBasic::np_cave2 = params->np_cave2;
this->formula = fractal / 2 + fractal % 2;
this->julia = fractal % 2 == 0;
diff --git a/src/mapgen_fractal.h b/src/mapgen_fractal.h
index cbd5567c4..3331848bc 100644
--- a/src/mapgen_fractal.h
+++ b/src/mapgen_fractal.h
@@ -33,7 +33,7 @@ class BiomeManager;
extern FlagDesc flagdesc_mapgen_fractal[];
-struct MapgenFractalParams : public MapgenSpecificParams {
+struct MapgenFractalParams : public MapgenParams {
u32 spflags;
float cave_width;
u16 fractal;
@@ -59,7 +59,7 @@ struct MapgenFractalParams : public MapgenSpecificParams {
class MapgenFractal : public MapgenBasic {
public:
- MapgenFractal(int mapgenid, MapgenParams *params, EmergeManager *emerge);
+ MapgenFractal(int mapgenid, MapgenFractalParams *params, EmergeManager *emerge);
~MapgenFractal();
virtual MapgenType getType() const { return MAPGEN_FRACTAL; }
diff --git a/src/mapgen_singlenode.h b/src/mapgen_singlenode.h
index 58672a0ed..07520134d 100644
--- a/src/mapgen_singlenode.h
+++ b/src/mapgen_singlenode.h
@@ -22,7 +22,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "mapgen.h"
-struct MapgenSinglenodeParams : public MapgenSpecificParams {
+struct MapgenSinglenodeParams : public MapgenParams {
MapgenSinglenodeParams() {}
~MapgenSinglenodeParams() {}
diff --git a/src/mapgen_v5.cpp b/src/mapgen_v5.cpp
index 74d5e1ee3..9f189e253 100644
--- a/src/mapgen_v5.cpp
+++ b/src/mapgen_v5.cpp
@@ -45,25 +45,23 @@ FlagDesc flagdesc_mapgen_v5[] = {
};
-MapgenV5::MapgenV5(int mapgenid, MapgenParams *params, EmergeManager *emerge)
+MapgenV5::MapgenV5(int mapgenid, MapgenV5Params *params, EmergeManager *emerge)
: MapgenBasic(mapgenid, params, emerge)
{
- MapgenV5Params *sp = (MapgenV5Params *)params->sparams;
-
- this->spflags = sp->spflags;
- this->cave_width = sp->cave_width;
+ this->spflags = params->spflags;
+ this->cave_width = params->cave_width;
// Terrain noise
- noise_filler_depth = new Noise(&sp->np_filler_depth, seed, csize.X, csize.Z);
- noise_factor = new Noise(&sp->np_factor, seed, csize.X, csize.Z);
- noise_height = new Noise(&sp->np_height, seed, csize.X, csize.Z);
+ noise_filler_depth = new Noise(&params->np_filler_depth, seed, csize.X, csize.Z);
+ noise_factor = new Noise(&params->np_factor, seed, csize.X, csize.Z);
+ noise_height = new Noise(&params->np_height, seed, csize.X, csize.Z);
// 3D terrain noise
// 1-up 1-down overgeneration
- noise_ground = new Noise(&sp->np_ground, seed, csize.X, csize.Y + 2, csize.Z);
+ noise_ground = new Noise(&params->np_ground, seed, csize.X, csize.Y + 2, csize.Z);
- MapgenBasic::np_cave1 = sp->np_cave1;
- MapgenBasic::np_cave2 = sp->np_cave2;
+ MapgenBasic::np_cave1 = params->np_cave1;
+ MapgenBasic::np_cave2 = params->np_cave2;
}
diff --git a/src/mapgen_v5.h b/src/mapgen_v5.h
index 5f6b10383..ddb090a9c 100644
--- a/src/mapgen_v5.h
+++ b/src/mapgen_v5.h
@@ -30,7 +30,7 @@ class BiomeManager;
extern FlagDesc flagdesc_mapgen_v5[];
-struct MapgenV5Params : public MapgenSpecificParams {
+struct MapgenV5Params : public MapgenParams {
u32 spflags;
float cave_width;
NoiseParams np_filler_depth;
@@ -50,7 +50,7 @@ struct MapgenV5Params : public MapgenSpecificParams {
class MapgenV5 : public MapgenBasic {
public:
- MapgenV5(int mapgenid, MapgenParams *params, EmergeManager *emerge);
+ MapgenV5(int mapgenid, MapgenV5Params *params, EmergeManager *emerge);
~MapgenV5();
virtual MapgenType getType() const { return MAPGEN_V5; }
diff --git a/src/mapgen_v6.cpp b/src/mapgen_v6.cpp
index caa64827e..e4444963f 100644
--- a/src/mapgen_v6.cpp
+++ b/src/mapgen_v6.cpp
@@ -53,7 +53,7 @@ FlagDesc flagdesc_mapgen_v6[] = {
/////////////////////////////////////////////////////////////////////////////
-MapgenV6::MapgenV6(int mapgenid, MapgenParams *params, EmergeManager *emerge)
+MapgenV6::MapgenV6(int mapgenid, MapgenV6Params *params, EmergeManager *emerge)
: Mapgen(mapgenid, params, emerge)
{
this->m_emerge = emerge;
@@ -61,26 +61,25 @@ MapgenV6::MapgenV6(int mapgenid, MapgenParams *params, EmergeManager *emerge)
this->heightmap = new s16[csize.X * csize.Z];
- MapgenV6Params *sp = (MapgenV6Params *)params->sparams;
- this->spflags = sp->spflags;
- this->freq_desert = sp->freq_desert;
- this->freq_beach = sp->freq_beach;
+ this->spflags = params->spflags;
+ this->freq_desert = params->freq_desert;
+ this->freq_beach = params->freq_beach;
- np_cave = &sp->np_cave;
- np_humidity = &sp->np_humidity;
- np_trees = &sp->np_trees;
- np_apple_trees = &sp->np_apple_trees;
+ np_cave = &params->np_cave;
+ np_humidity = &params->np_humidity;
+ np_trees = &params->np_trees;
+ np_apple_trees = &params->np_apple_trees;
//// Create noise objects
- noise_terrain_base = new Noise(&sp->np_terrain_base, seed, csize.X, csize.Y);
- noise_terrain_higher = new Noise(&sp->np_terrain_higher, seed, csize.X, csize.Y);
- noise_steepness = new Noise(&sp->np_steepness, seed, csize.X, csize.Y);
- noise_height_select = new Noise(&sp->np_height_select, seed, csize.X, csize.Y);
- noise_mud = new Noise(&sp->np_mud, seed, csize.X, csize.Y);
- noise_beach = new Noise(&sp->np_beach, seed, csize.X, csize.Y);
- noise_biome = new Noise(&sp->np_biome, seed,
+ noise_terrain_base = new Noise(&params->np_terrain_base, seed, csize.X, csize.Y);
+ noise_terrain_higher = new Noise(&params->np_terrain_higher, seed, csize.X, csize.Y);
+ noise_steepness = new Noise(&params->np_steepness, seed, csize.X, csize.Y);
+ noise_height_select = new Noise(&params->np_height_select, seed, csize.X, csize.Y);
+ noise_mud = new Noise(&params->np_mud, seed, csize.X, csize.Y);
+ noise_beach = new Noise(&params->np_beach, seed, csize.X, csize.Y);
+ noise_biome = new Noise(&params->np_biome, seed,
csize.X + 2 * MAP_BLOCKSIZE, csize.Y + 2 * MAP_BLOCKSIZE);
- noise_humidity = new Noise(&sp->np_humidity, seed,
+ noise_humidity = new Noise(&params->np_humidity, seed,
csize.X + 2 * MAP_BLOCKSIZE, csize.Y + 2 * MAP_BLOCKSIZE);
//// Resolve nodes to be used
diff --git a/src/mapgen_v6.h b/src/mapgen_v6.h
index 20b0bf92e..f018ffaca 100644
--- a/src/mapgen_v6.h
+++ b/src/mapgen_v6.h
@@ -53,7 +53,7 @@ enum BiomeV6Type
};
-struct MapgenV6Params : public MapgenSpecificParams {
+struct MapgenV6Params : public MapgenParams {
u32 spflags;
float freq_desert;
float freq_beach;
@@ -124,7 +124,7 @@ public:
content_t c_mossycobble;
content_t c_stair_cobble;
- MapgenV6(int mapgenid, MapgenParams *params, EmergeManager *emerge);
+ MapgenV6(int mapgenid, MapgenV6Params *params, EmergeManager *emerge);
~MapgenV6();
virtual MapgenType getType() const { return MAPGEN_V6; }
diff --git a/src/mapgen_v7.cpp b/src/mapgen_v7.cpp
index c24b3e8d1..d14fdb97a 100644
--- a/src/mapgen_v7.cpp
+++ b/src/mapgen_v7.cpp
@@ -50,30 +50,28 @@ FlagDesc flagdesc_mapgen_v7[] = {
///////////////////////////////////////////////////////////////////////////////
-MapgenV7::MapgenV7(int mapgenid, MapgenParams *params, EmergeManager *emerge)
+MapgenV7::MapgenV7(int mapgenid, MapgenV7Params *params, EmergeManager *emerge)
: MapgenBasic(mapgenid, params, emerge)
{
- MapgenV7Params *sp = (MapgenV7Params *)params->sparams;
-
- this->spflags = sp->spflags;
- this->cave_width = sp->cave_width;
+ this->spflags = params->spflags;
+ this->cave_width = params->cave_width;
//// Terrain noise
- noise_terrain_base = new Noise(&sp->np_terrain_base, seed, csize.X, csize.Z);
- noise_terrain_alt = new Noise(&sp->np_terrain_alt, seed, csize.X, csize.Z);
- noise_terrain_persist = new Noise(&sp->np_terrain_persist, seed, csize.X, csize.Z);
- noise_height_select = new Noise(&sp->np_height_select, seed, csize.X, csize.Z);
- noise_filler_depth = new Noise(&sp->np_filler_depth, seed, csize.X, csize.Z);
- noise_mount_height = new Noise(&sp->np_mount_height, seed, csize.X, csize.Z);
- noise_ridge_uwater = new Noise(&sp->np_ridge_uwater, seed, csize.X, csize.Z);
+ noise_terrain_base = new Noise(&params->np_terrain_base, seed, csize.X, csize.Z);
+ noise_terrain_alt = new Noise(&params->np_terrain_alt, seed, csize.X, csize.Z);
+ noise_terrain_persist = new Noise(&params->np_terrain_persist, seed, csize.X, csize.Z);
+ noise_height_select = new Noise(&params->np_height_select, seed, csize.X, csize.Z);
+ noise_filler_depth = new Noise(&params->np_filler_depth, seed, csize.X, csize.Z);
+ noise_mount_height = new Noise(&params->np_mount_height, seed, csize.X, csize.Z);
+ noise_ridge_uwater = new Noise(&params->np_ridge_uwater, seed, csize.X, csize.Z);
//// 3d terrain noise
// 1-up 1-down overgeneration
- noise_mountain = new Noise(&sp->np_mountain, seed, csize.X, csize.Y + 2, csize.Z);
- noise_ridge = new Noise(&sp->np_ridge, seed, csize.X, csize.Y + 2, csize.Z);
+ noise_mountain = new Noise(&params->np_mountain, seed, csize.X, csize.Y + 2, csize.Z);
+ noise_ridge = new Noise(&params->np_ridge, seed, csize.X, csize.Y + 2, csize.Z);
- MapgenBasic::np_cave1 = sp->np_cave1;
- MapgenBasic::np_cave2 = sp->np_cave2;
+ MapgenBasic::np_cave1 = params->np_cave1;
+ MapgenBasic::np_cave2 = params->np_cave2;
}
diff --git a/src/mapgen_v7.h b/src/mapgen_v7.h
index c75f18a93..3a6bc0801 100644
--- a/src/mapgen_v7.h
+++ b/src/mapgen_v7.h
@@ -32,7 +32,7 @@ class BiomeManager;
extern FlagDesc flagdesc_mapgen_v7[];
-struct MapgenV7Params : public MapgenSpecificParams {
+struct MapgenV7Params : public MapgenParams {
u32 spflags;
float cave_width;
NoiseParams np_terrain_base;
@@ -56,7 +56,7 @@ struct MapgenV7Params : public MapgenSpecificParams {
class MapgenV7 : public MapgenBasic {
public:
- MapgenV7(int mapgenid, MapgenParams *params, EmergeManager *emerge);
+ MapgenV7(int mapgenid, MapgenV7Params *params, EmergeManager *emerge);
~MapgenV7();
virtual MapgenType getType() const { return MAPGEN_V7; }
diff --git a/src/mapgen_valleys.cpp b/src/mapgen_valleys.cpp
index 02a8fbfe0..a61f1b329 100644
--- a/src/mapgen_valleys.cpp
+++ b/src/mapgen_valleys.cpp
@@ -64,7 +64,7 @@ static FlagDesc flagdesc_mapgen_valleys[] = {
///////////////////////////////////////////////////////////////////////////////
-MapgenValleys::MapgenValleys(int mapgenid, MapgenParams *params, EmergeManager *emerge)
+MapgenValleys::MapgenValleys(int mapgenid, MapgenValleysParams *params, EmergeManager *emerge)
: MapgenBasic(mapgenid, params, emerge)
{
// NOTE: MapgenValleys has a hard dependency on BiomeGenOriginal
@@ -73,34 +73,33 @@ MapgenValleys::MapgenValleys(int mapgenid, MapgenParams *params, EmergeManager *
this->map_gen_limit = MYMIN(MAX_MAP_GENERATION_LIMIT,
g_settings->getU16("map_generation_limit"));
- MapgenValleysParams *sp = (MapgenValleysParams *)params->sparams;
BiomeParamsOriginal *bp = (BiomeParamsOriginal *)params->bparams;
- this->spflags = sp->spflags;
- this->altitude_chill = sp->altitude_chill;
- this->large_cave_depth = sp->large_cave_depth;
- this->lava_features_lim = rangelim(sp->lava_features, 0, 10);
- this->massive_cave_depth = sp->massive_cave_depth;
- this->river_depth_bed = sp->river_depth + 1.f;
- this->river_size_factor = sp->river_size / 100.f;
- this->water_features_lim = rangelim(sp->water_features, 0, 10);
- this->cave_width = sp->cave_width;
+ this->spflags = params->spflags;
+ this->altitude_chill = params->altitude_chill;
+ this->large_cave_depth = params->large_cave_depth;
+ this->lava_features_lim = rangelim(params->lava_features, 0, 10);
+ this->massive_cave_depth = params->massive_cave_depth;
+ this->river_depth_bed = params->river_depth + 1.f;
+ this->river_size_factor = params->river_size / 100.f;
+ this->water_features_lim = rangelim(params->water_features, 0, 10);
+ this->cave_width = params->cave_width;
//// 2D Terrain noise
- noise_filler_depth = new Noise(&sp->np_filler_depth, seed, csize.X, csize.Z);
- noise_inter_valley_slope = new Noise(&sp->np_inter_valley_slope, seed, csize.X, csize.Z);
- noise_rivers = new Noise(&sp->np_rivers, seed, csize.X, csize.Z);
- noise_terrain_height = new Noise(&sp->np_terrain_height, seed, csize.X, csize.Z);
- noise_valley_depth = new Noise(&sp->np_valley_depth, seed, csize.X, csize.Z);
- noise_valley_profile = new Noise(&sp->np_valley_profile, seed, csize.X, csize.Z);
+ noise_filler_depth = new Noise(&params->np_filler_depth, seed, csize.X, csize.Z);
+ noise_inter_valley_slope = new Noise(&params->np_inter_valley_slope, seed, csize.X, csize.Z);
+ noise_rivers = new Noise(&params->np_rivers, seed, csize.X, csize.Z);
+ noise_terrain_height = new Noise(&params->np_terrain_height, seed, csize.X, csize.Z);
+ noise_valley_depth = new Noise(&params->np_valley_depth, seed, csize.X, csize.Z);
+ noise_valley_profile = new Noise(&params->np_valley_profile, seed, csize.X, csize.Z);
//// 3D Terrain noise
// 1-up 1-down overgeneration
- noise_inter_valley_fill = new Noise(&sp->np_inter_valley_fill, seed, csize.X, csize.Y + 2, csize.Z);
+ noise_inter_valley_fill = new Noise(&params->np_inter_valley_fill, seed, csize.X, csize.Y + 2, csize.Z);
// 1-down overgeneraion
- noise_cave1 = new Noise(&sp->np_cave1, seed, csize.X, csize.Y + 1, csize.Z);
- noise_cave2 = new Noise(&sp->np_cave2, seed, csize.X, csize.Y + 1, csize.Z);
- noise_massive_caves = new Noise(&sp->np_massive_caves, seed, csize.X, csize.Y + 1, csize.Z);
+ noise_cave1 = new Noise(&params->np_cave1, seed, csize.X, csize.Y + 1, csize.Z);
+ noise_cave2 = new Noise(&params->np_cave2, seed, csize.X, csize.Y + 1, csize.Z);
+ noise_massive_caves = new Noise(&params->np_massive_caves, seed, csize.X, csize.Y + 1, csize.Z);
this->humid_rivers = (spflags & MGVALLEYS_HUMID_RIVERS);
this->use_altitude_chill = (spflags & MGVALLEYS_ALT_CHILL);
diff --git a/src/mapgen_valleys.h b/src/mapgen_valleys.h
index 00f6aff07..6dd7ebc47 100644
--- a/src/mapgen_valleys.h
+++ b/src/mapgen_valleys.h
@@ -46,7 +46,7 @@ class BiomeGenOriginal;
//extern Profiler *mapgen_profiler;
-struct MapgenValleysParams : public MapgenSpecificParams {
+struct MapgenValleysParams : public MapgenParams {
u32 spflags;
s16 large_cave_depth;
s16 massive_cave_depth;
@@ -88,7 +88,7 @@ struct TerrainNoise {
class MapgenValleys : public MapgenBasic {
public:
- MapgenValleys(int mapgenid, MapgenParams *params, EmergeManager *emerge);
+ MapgenValleys(int mapgenid, MapgenValleysParams *params, EmergeManager *emerge);
~MapgenValleys();
virtual MapgenType getType() const { return MAPGEN_VALLEYS; }
diff --git a/src/script/lua_api/l_mapgen.cpp b/src/script/lua_api/l_mapgen.cpp
index dc188f8a4..9f14838ce 100644
--- a/src/script/lua_api/l_mapgen.cpp
+++ b/src/script/lua_api/l_mapgen.cpp
@@ -600,24 +600,37 @@ int ModApiMapgen::l_get_mapgen_params(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
- MapgenParams *params = &getServer(L)->getEmergeManager()->params;
+ log_deprecated(L, "get_mapgen_params is deprecated; "
+ "use get_mapgen_setting instead");
+
+ std::string value;
+
+ MapSettingsManager *settingsmgr =
+ getServer(L)->getEmergeManager()->map_settings_mgr;
lua_newtable(L);
- lua_pushstring(L, params->mg_name.c_str());
+ settingsmgr->getMapSetting("mg_name", &value);
+ lua_pushstring(L, value.c_str());
lua_setfield(L, -2, "mgname");
- lua_pushinteger(L, params->seed);
+ settingsmgr->getMapSetting("seed", &value);
+ std::istringstream ss(value);
+ u64 seed;
+ ss >> seed;
+ lua_pushinteger(L, seed);
lua_setfield(L, -2, "seed");
- lua_pushinteger(L, params->water_level);
+ settingsmgr->getMapSetting("water_level", &value);
+ lua_pushinteger(L, stoi(value, -32768, 32767));
lua_setfield(L, -2, "water_level");
- lua_pushinteger(L, params->chunksize);
+ settingsmgr->getMapSetting("chunksize", &value);
+ lua_pushinteger(L, stoi(value, -32768, 32767));
lua_setfield(L, -2, "chunksize");
- std::string flagstr = writeFlagString(params->flags, flagdesc_mapgen, U32_MAX);
- lua_pushstring(L, flagstr.c_str());
+ settingsmgr->getMapSetting("mg_flags", &value);
+ lua_pushstring(L, value.c_str());
lua_setfield(L, -2, "flags");
return 1;
@@ -630,44 +643,120 @@ int ModApiMapgen::l_set_mapgen_params(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
+ log_deprecated(L, "set_mapgen_params is deprecated; "
+ "use set_mapgen_setting instead");
+
if (!lua_istable(L, 1))
return 0;
- EmergeManager *emerge = getServer(L)->getEmergeManager();
- if (emerge->isRunning())
- throw LuaError("Cannot set parameters while mapgen is running");
-
- MapgenParams *params = &emerge->params;
- u32 flags = 0, flagmask = 0;
+ MapSettingsManager *settingsmgr =
+ getServer(L)->getEmergeManager()->map_settings_mgr;
lua_getfield(L, 1, "mgname");
- if (lua_isstring(L, -1)) {
- params->mg_name = lua_tostring(L, -1);
- delete params->sparams;
- params->sparams = NULL;
- }
+ if (lua_isstring(L, -1))
+ settingsmgr->setMapSetting("mg_name", lua_tostring(L, -1), true);
lua_getfield(L, 1, "seed");
if (lua_isnumber(L, -1))
- params->seed = lua_tointeger(L, -1);
+ settingsmgr->setMapSetting("seed", lua_tostring(L, -1), true);
lua_getfield(L, 1, "water_level");
if (lua_isnumber(L, -1))
- params->water_level = lua_tointeger(L, -1);
+ settingsmgr->setMapSetting("water_level", lua_tostring(L, -1), true);
lua_getfield(L, 1, "chunksize");
if (lua_isnumber(L, -1))
- params->chunksize = lua_tointeger(L, -1);
+ settingsmgr->setMapSetting("chunksize", lua_tostring(L, -1), true);
warn_if_field_exists(L, 1, "flagmask",
"Deprecated: flags field now includes unset flags.");
- lua_getfield(L, 1, "flagmask");
+
+ lua_getfield(L, 1, "flags");
if (lua_isstring(L, -1))
- params->flags &= ~readFlagString(lua_tostring(L, -1), flagdesc_mapgen, NULL);
+ settingsmgr->setMapSetting("mg_flags", lua_tostring(L, -1), true);
+
+ return 0;
+}
+
+// get_mapgen_setting(name)
+int ModApiMapgen::l_get_mapgen_setting(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
- if (getflagsfield(L, 1, "flags", flagdesc_mapgen, &flags, &flagmask)) {
- params->flags &= ~flagmask;
- params->flags |= flags;
+ std::string value;
+ MapSettingsManager *settingsmgr =
+ getServer(L)->getEmergeManager()->map_settings_mgr;
+
+ const char *name = luaL_checkstring(L, 1);
+ if (!settingsmgr->getMapSetting(name, &value))
+ return 0;
+
+ lua_pushstring(L, value.c_str());
+ return 1;
+}
+
+// get_mapgen_setting_noiseparams(name)
+int ModApiMapgen::l_get_mapgen_setting_noiseparams(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+
+ NoiseParams np;
+ MapSettingsManager *settingsmgr =
+ getServer(L)->getEmergeManager()->map_settings_mgr;
+
+ const char *name = luaL_checkstring(L, 1);
+ if (!settingsmgr->getMapSettingNoiseParams(name, &np))
+ return 0;
+
+ push_noiseparams(L, &np);
+ return 1;
+}
+
+// set_mapgen_setting(name, value, override_meta)
+// set mapgen config values
+int ModApiMapgen::l_set_mapgen_setting(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+
+ MapSettingsManager *settingsmgr =
+ getServer(L)->getEmergeManager()->map_settings_mgr;
+
+ const char *name = luaL_checkstring(L, 1);
+ const char *value = luaL_checkstring(L, 2);
+ bool override_meta = lua_isboolean(L, 3) ? lua_toboolean(L, 3) : false;
+
+ if (!settingsmgr->setMapSetting(name, value, override_meta)) {
+ errorstream << "set_mapgen_setting: cannot set '"
+ << name << "' after initialization" << std::endl;
+ }
+
+ return 0;
+}
+
+
+// set_mapgen_setting_noiseparams(name, noiseparams, set_default)
+// set mapgen config values for noise parameters
+int ModApiMapgen::l_set_mapgen_setting_noiseparams(lua_State *L)
+{
+ NO_MAP_LOCK_REQUIRED;
+
+ MapSettingsManager *settingsmgr =
+ getServer(L)->getEmergeManager()->map_settings_mgr;
+
+ const char *name = luaL_checkstring(L, 1);
+
+ NoiseParams np;
+ if (!read_noiseparams(L, 2, &np)) {
+ errorstream << "set_mapgen_setting_noiseparams: cannot set '" << name
+ << "'; invalid noiseparams table" << std::endl;
+ return 0;
+ }
+
+ bool override_meta = lua_isboolean(L, 3) ? lua_toboolean(L, 3) : false;
+
+ if (!settingsmgr->setMapSettingNoiseParams(name, &np, override_meta)) {
+ errorstream << "set_mapgen_setting_noiseparams: cannot set '"
+ << name << "' after initialization" << std::endl;
}
return 0;
@@ -683,8 +772,11 @@ int ModApiMapgen::l_set_noiseparams(lua_State *L)
const char *name = luaL_checkstring(L, 1);
NoiseParams np;
- if (!read_noiseparams(L, 2, &np))
+ if (!read_noiseparams(L, 2, &np)) {
+ errorstream << "set_noiseparams: cannot set '" << name
+ << "'; invalid noiseparams table" << std::endl;
return 0;
+ }
bool set_default = lua_isboolean(L, 3) ? lua_toboolean(L, 3) : true;
@@ -1143,7 +1235,7 @@ int ModApiMapgen::l_generate_ores(lua_State *L)
EmergeManager *emerge = getServer(L)->getEmergeManager();
Mapgen mg;
- mg.seed = emerge->params.seed;
+ mg.seed = emerge->mgparams->seed;
mg.vm = LuaVoxelManip::checkobject(L, 1)->vm;
mg.ndef = getServer(L)->getNodeDefManager();
@@ -1169,7 +1261,7 @@ int ModApiMapgen::l_generate_decorations(lua_State *L)
EmergeManager *emerge = getServer(L)->getEmergeManager();
Mapgen mg;
- mg.seed = emerge->params.seed;
+ mg.seed = emerge->mgparams->seed;
mg.vm = LuaVoxelManip::checkobject(L, 1)->vm;
mg.ndef = getServer(L)->getNodeDefManager();
@@ -1393,6 +1485,10 @@ void ModApiMapgen::Initialize(lua_State *L, int top)
API_FCT(get_mapgen_params);
API_FCT(set_mapgen_params);
+ API_FCT(get_mapgen_setting);
+ API_FCT(set_mapgen_setting);
+ API_FCT(get_mapgen_setting_noiseparams);
+ API_FCT(set_mapgen_setting_noiseparams);
API_FCT(set_noiseparams);
API_FCT(get_noiseparams);
API_FCT(set_gen_notify);
diff --git a/src/script/lua_api/l_mapgen.h b/src/script/lua_api/l_mapgen.h
index 9751c0db6..bb94575c7 100644
--- a/src/script/lua_api/l_mapgen.h
+++ b/src/script/lua_api/l_mapgen.h
@@ -40,6 +40,18 @@ private:
// set mapgen parameters
static int l_set_mapgen_params(lua_State *L);
+ // get_mapgen_setting(name)
+ static int l_get_mapgen_setting(lua_State *L);
+
+ // set_mapgen_setting(name, value, override_meta)
+ static int l_set_mapgen_setting(lua_State *L);
+
+ // get_mapgen_setting_noiseparams(name)
+ static int l_get_mapgen_setting_noiseparams(lua_State *L);
+
+ // set_mapgen_setting_noiseparams(name, value, override_meta)
+ static int l_set_mapgen_setting_noiseparams(lua_State *L);
+
// set_noiseparam_defaults(name, noiseparams, set_default)
static int l_set_noiseparams(lua_State *L);
diff --git a/src/script/lua_api/l_vmanip.cpp b/src/script/lua_api/l_vmanip.cpp
index f13866408..0d8123acd 100644
--- a/src/script/lua_api/l_vmanip.cpp
+++ b/src/script/lua_api/l_vmanip.cpp
@@ -190,7 +190,7 @@ int LuaVoxelManip::l_calc_lighting(lua_State *L)
Mapgen mg;
mg.vm = vm;
mg.ndef = ndef;
- mg.water_level = emerge->params.water_level;
+ mg.water_level = emerge->mgparams->water_level;
mg.calcLighting(pmin, pmax, fpmin, fpmax, propagate_shadow);
diff --git a/src/server.cpp b/src/server.cpp
index f7f698d50..97a53f189 100644
--- a/src/server.cpp
+++ b/src/server.cpp
@@ -266,9 +266,6 @@ Server::Server(
//lock environment
MutexAutoLock envlock(m_env_mutex);
- // Load mapgen params from Settings
- m_emerge->loadMapgenParams();
-
// Create the Map (loads map_meta.txt, overriding configured mapgen params)
ServerMap *servermap = new ServerMap(path_world, this, m_emerge);
@@ -331,8 +328,11 @@ Server::Server(
m_clients.setEnv(m_env);
+ if (!servermap->settings_mgr.makeMapgenParams())
+ FATAL_ERROR("Couldn't create any mapgen type");
+
// Initialize mapgens
- m_emerge->initMapgens();
+ m_emerge->initMapgens(servermap->getMapgenParams());
m_enable_rollback_recording = g_settings->getBool("enable_rollback_recording");
if (m_enable_rollback_recording) {
@@ -402,11 +402,8 @@ Server::~Server()
m_emerge->stopThreads();
// Delete things in the reverse order of creation
- delete m_env;
-
- // N.B. the EmergeManager should be deleted after the Environment since Map
- // depends on EmergeManager to write its current params to the map meta
delete m_emerge;
+ delete m_env;
delete m_rollback;
delete m_banmanager;
delete m_event;
@@ -655,7 +652,7 @@ void Server::AsyncRunStep(bool initial_step)
m_env->getGameTime(),
m_lag,
m_gamespec.id,
- m_emerge->params.mg_name,
+ Mapgen::getMapgenName(m_emerge->mgparams->mgtype),
m_mods);
counter = 0.01;
}
diff --git a/src/subgame.cpp b/src/subgame.cpp
index 7e9a0b368..55bbd3954 100644
--- a/src/subgame.cpp
+++ b/src/subgame.cpp
@@ -313,8 +313,8 @@ bool loadGameConfAndInitWorld(const std::string &path, const SubgameSpec &gamesp
Settings conf;
MapgenParams params;
- params.load(*g_settings);
- params.save(conf);
+ params.readParams(g_settings);
+ params.writeParams(&conf);
conf.writeLines(oss);
oss << "[end_of_params]\n";
diff --git a/src/unittest/CMakeLists.txt b/src/unittest/CMakeLists.txt
index a07ed8ba5..34de99e12 100644
--- a/src/unittest/CMakeLists.txt
+++ b/src/unittest/CMakeLists.txt
@@ -6,6 +6,7 @@ set (UNITTEST_SRCS
${CMAKE_CURRENT_SOURCE_DIR}/test_connection.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_filepath.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_inventory.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/test_map_settings_manager.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_mapnode.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_nodedef.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_noderesolver.cpp
diff --git a/src/unittest/test_map_settings_manager.cpp b/src/unittest/test_map_settings_manager.cpp
new file mode 100644
index 000000000..b2ad53192
--- /dev/null
+++ b/src/unittest/test_map_settings_manager.cpp
@@ -0,0 +1,255 @@
+ /*
+Minetest
+Copyright (C) 2010-2014 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#include "test.h"
+
+#include "noise.h"
+#include "settings.h"
+#include "mapgen_v5.h"
+#include "util/sha1.h"
+#include "map_settings_manager.h"
+
+class TestMapSettingsManager : public TestBase {
+public:
+ TestMapSettingsManager() { TestManager::registerTestModule(this); }
+ const char *getName() { return "TestMapSettingsManager"; }
+
+ void makeUserConfig(Settings *conf);
+ std::string makeMetaFile(bool make_corrupt);
+
+ void runTests(IGameDef *gamedef);
+
+ void testMapSettingsManager();
+ void testMapMetaSaveLoad();
+ void testMapMetaFailures();
+};
+
+static TestMapSettingsManager g_test_instance;
+
+void TestMapSettingsManager::runTests(IGameDef *gamedef)
+{
+ TEST(testMapSettingsManager);
+ TEST(testMapMetaSaveLoad);
+ TEST(testMapMetaFailures);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+void check_noise_params(const NoiseParams *np1, const NoiseParams *np2)
+{
+ UASSERTEQ(float, np1->offset, np2->offset);
+ UASSERTEQ(float, np1->scale, np2->scale);
+ UASSERT(np1->spread == np2->spread);
+ UASSERTEQ(s32, np1->seed, np2->seed);
+ UASSERTEQ(u16, np1->octaves, np2->octaves);
+ UASSERTEQ(float, np1->persist, np2->persist);
+ UASSERTEQ(float, np1->lacunarity, np2->lacunarity);
+ UASSERTEQ(u32, np1->flags, np2->flags);
+}
+
+
+std::string read_file_to_string(const std::string &filepath)
+{
+ std::string buf;
+ FILE *f = fopen(filepath.c_str(), "rb");
+ if (!f)
+ return "";
+
+ fseek(f, 0, SEEK_END);
+
+ long filesize = ftell(f);
+ if (filesize == -1)
+ return "";
+ rewind(f);
+
+ buf.resize(filesize);
+
+ fread(&buf[0], 1, filesize, f);
+
+ fclose(f);
+ return buf;
+}
+
+
+void TestMapSettingsManager::makeUserConfig(Settings *conf)
+{
+ conf->set("mg_name", "v7");
+ conf->set("seed", "5678");
+ conf->set("water_level", "20");
+ conf->set("mgv5_np_factor", "0, 12, (500, 250, 500), 920382, 5, 0.45, 3.0");
+ conf->set("mgv5_np_height", "0, 15, (500, 250, 500), 841746, 5, 0.5, 3.0");
+ conf->set("mgv5_np_filler_depth", "20, 1, (150, 150, 150), 261, 4, 0.7, 1.0");
+ conf->set("mgv5_np_ground", "-43, 40, (80, 80, 80), 983240, 4, 0.55, 2.0");
+}
+
+
+std::string TestMapSettingsManager::makeMetaFile(bool make_corrupt)
+{
+ std::string metafile = getTestTempFile();
+
+ const char *metafile_contents =
+ "mg_name = v5\n"
+ "seed = 1234\n"
+ "mg_flags = light\n"
+ "mgv5_np_filler_depth = 20, 1, (150, 150, 150), 261, 4, 0.7, 1.0\n"
+ "mgv5_np_height = 20, 10, (250, 250, 250), 84174, 4, 0.5, 1.0\n";
+
+ FILE *f = fopen(metafile.c_str(), "wb");
+ UASSERT(f != NULL);
+
+ fputs(metafile_contents, f);
+ if (!make_corrupt)
+ fputs("[end_of_params]\n", f);
+
+ fclose(f);
+
+ return metafile;
+}
+
+
+void TestMapSettingsManager::testMapSettingsManager()
+{
+ Settings user_settings;
+ makeUserConfig(&user_settings);
+
+ std::string test_mapmeta_path = makeMetaFile(false);
+
+ MapSettingsManager mgr(&user_settings, test_mapmeta_path);
+ std::string value;
+
+ UASSERT(mgr.getMapSetting("mg_name", &value));
+ UASSERT(value == "v7");
+
+ // Pretend we're initializing the ServerMap
+ UASSERT(mgr.loadMapMeta());
+
+ // Pretend some scripts are requesting mapgen params
+ UASSERT(mgr.getMapSetting("mg_name", &value));
+ UASSERT(value == "v5");
+ UASSERT(mgr.getMapSetting("seed", &value));
+ UASSERT(value == "1234");
+ UASSERT(mgr.getMapSetting("water_level", &value));
+ UASSERT(value == "20");
+
+ // Pretend we have some mapgen settings configured from the scripting
+ UASSERT(mgr.setMapSetting("water_level", "15"));
+ UASSERT(mgr.setMapSetting("seed", "02468"));
+ UASSERT(mgr.setMapSetting("mg_flags", "nolight", true));
+
+ NoiseParams script_np_filler_depth(0, 100, v3f(200, 100, 200), 261, 4, 0.7, 2.0);
+ NoiseParams script_np_factor(0, 100, v3f(50, 50, 50), 920381, 3, 0.45, 2.0);
+ NoiseParams script_np_height(0, 100, v3f(450, 450, 450), 84174, 4, 0.5, 2.0);
+ NoiseParams meta_np_height(20, 10, v3f(250, 250, 250), 84174, 4, 0.5, 1.0);
+ NoiseParams user_np_ground(-43, 40, v3f(80, 80, 80), 983240, 4, 0.55, 2.0, NOISE_FLAG_EASED);
+
+ mgr.setMapSettingNoiseParams("mgv5_np_filler_depth", &script_np_filler_depth, true);
+ mgr.setMapSettingNoiseParams("mgv5_np_height", &script_np_height);
+ mgr.setMapSettingNoiseParams("mgv5_np_factor", &script_np_factor);
+
+ // Now make our Params and see if the values are correctly sourced
+ MapgenParams *params = mgr.makeMapgenParams();
+ UASSERT(params->mgtype == MAPGEN_V5);
+ UASSERT(params->chunksize == 5);
+ UASSERT(params->water_level == 15);
+ UASSERT(params->seed == 1234);
+ UASSERT((params->flags & MG_LIGHT) == 0);
+
+ MapgenV5Params *v5params = (MapgenV5Params *)params;
+
+ check_noise_params(&v5params->np_filler_depth, &script_np_filler_depth);
+ check_noise_params(&v5params->np_factor, &script_np_factor);
+ check_noise_params(&v5params->np_height, &meta_np_height);
+ check_noise_params(&v5params->np_ground, &user_np_ground);
+
+ UASSERT(mgr.setMapSetting("foobar", "25") == false);
+
+ // Pretend the ServerMap is shutting down
+ UASSERT(mgr.saveMapMeta());
+
+ // Make sure our interface expectations are met
+ UASSERT(mgr.mapgen_params == params);
+ UASSERT(mgr.makeMapgenParams() == params);
+
+ // Load the resulting map_meta.txt and make sure it contains what we expect
+ unsigned char expected_contents_hash[20] = {
+ 0xf6, 0x44, 0x90, 0xb7, 0xab, 0xd8, 0x91, 0xf4, 0x08, 0x96,
+ 0xfc, 0x7e, 0xed, 0x01, 0xc5, 0x9a, 0xfd, 0x2f, 0x2d, 0x79
+ };
+
+ SHA1 ctx;
+ std::string metafile_contents = read_file_to_string(test_mapmeta_path);
+ ctx.addBytes(&metafile_contents[0], metafile_contents.size());
+ unsigned char *sha1_result = ctx.getDigest();
+ int resultdiff = memcmp(sha1_result, expected_contents_hash, 20);
+ free(sha1_result);
+
+ UASSERT(!resultdiff);
+}
+
+
+void TestMapSettingsManager::testMapMetaSaveLoad()
+{
+ Settings conf;
+ std::string path = getTestTempDirectory()
+ + DIR_DELIM + "foobar" + DIR_DELIM + "map_meta.txt";
+
+ // Create a set of mapgen params and save them to map meta
+ conf.set("seed", "12345");
+ conf.set("water_level", "5");
+ MapSettingsManager mgr1(&conf, path);
+ MapgenParams *params1 = mgr1.makeMapgenParams();
+ UASSERT(params1);
+ UASSERT(mgr1.saveMapMeta());
+
+ // Now try loading the map meta to mapgen params
+ conf.set("seed", "67890");
+ conf.set("water_level", "32");
+ MapSettingsManager mgr2(&conf, path);
+ UASSERT(mgr2.loadMapMeta());
+ MapgenParams *params2 = mgr2.makeMapgenParams();
+ UASSERT(params2);
+
+ // Check that both results are correct
+ UASSERTEQ(u64, params1->seed, 12345);
+ UASSERTEQ(s16, params1->water_level, 5);
+ UASSERTEQ(u64, params2->seed, 12345);
+ UASSERTEQ(s16, params2->water_level, 5);
+}
+
+
+void TestMapSettingsManager::testMapMetaFailures()
+{
+ std::string test_mapmeta_path;
+ Settings conf;
+
+ // Check to see if it'll fail on a non-existent map meta file
+ test_mapmeta_path = "woobawooba/fgdfg/map_meta.txt";
+ UASSERT(!fs::PathExists(test_mapmeta_path));
+
+ MapSettingsManager mgr1(&conf, test_mapmeta_path);
+ UASSERT(!mgr1.loadMapMeta());
+
+ // Check to see if it'll fail on a corrupt map meta file
+ test_mapmeta_path = makeMetaFile(true);
+ UASSERT(fs::PathExists(test_mapmeta_path));
+
+ MapSettingsManager mgr2(&conf, test_mapmeta_path);
+ UASSERT(!mgr2.loadMapMeta());
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-28 09:20:09 +0000