This commit refactors the majority of the Mapgen settings system.
- MapgenParams is now owned by MapSettingsManager, itself a part of ServerMap,
instead of the EmergeManager.
- New Script API functions added:
core.get_mapgen_setting
core.get_mapgen_setting_noiseparams,
core.set_mapgen_setting, and
core.set_mapgen_setting_noiseparams.
- minetest.get/set_mapgen_params are deprecated by the above new functions.
- It is now possible to view and modify any arbitrary mapgen setting from a mod,
rather than the base MapgenParams structure.
- MapgenSpecificParams has been removed.
jni/src/log.cpp \
jni/src/main.cpp \
jni/src/map.cpp \
+ jni/src/map_settings_manager.cpp \
jni/src/mapblock.cpp \
jni/src/mapblock_mesh.cpp \
jni/src/mapgen.cpp \
jni/src/unittest/test_connection.cpp \
jni/src/unittest/test_filepath.cpp \
jni/src/unittest/test_inventory.cpp \
+ jni/src/unittest/test_map_settings_manager.cpp \
jni/src/unittest/test_mapnode.cpp \
jni/src/unittest/test_nodedef.cpp \
jni/src/unittest/test_noderesolver.cpp \
given biome_name string.
* `minetest.get_mapgen_params()` Returns mapgen parameters, a table containing
`mgname`, `seed`, `chunksize`, `water_level`, and `flags`.
+ * Deprecated: use minetest.get_mapgen_setting(name) instead
* `minetest.set_mapgen_params(MapgenParams)`
+ * Deprecated: use minetest.set_mapgen_setting(name, value, override) instead
* Set map generation parameters
* Function cannot be called after the registration period; only initialization
and `on_mapgen_init`
* `flags` contains a comma-delimited string of flags to set,
or if the prefix `"no"` is attached, clears instead.
* `flags` is in the same format and has the same options as `mg_flags` in `minetest.conf`
+* `minetest.get_mapgen_setting(name)`
+ * Gets the *active* mapgen setting (or nil if none exists) in string format with the following
+ order of precedence:
+ 1) Settings loaded from map_meta.txt or overrides set during mod execution
+ 2) Settings set by mods without a metafile override
+ 3) Settings explicitly set in the user config file, minetest.conf
+ 4) Settings set as the user config default
+* `minetest.get_mapgen_setting_noiseparams(name)`
+ * Same as above, but returns the value as a NoiseParams table if the setting `name` exists
+ and is a valid NoiseParams
+* `minetest.set_mapgen_setting(name, value, [override_meta=false])`
+ * Sets a mapgen param to `value`, and will take effect if the corresponding mapgen setting
+ is not already present in map_meta.txt. If the optional boolean override_meta is set to true,
+ this setting will become the active setting regardless of the map metafile contents.
+ * Note: to set the seed, use "seed", not "fixed_map_seed"
+* `minetest.set_mapgen_setting_noiseparams(name, value, [override_meta=false])`
+ * Same as above, except value is a NoiseParams table
* `minetest.set_noiseparams(name, noiseparams, set_default)`
* Sets the noiseparams setting of `name` to the noiseparams table specified in `noiseparams`.
* `set_default` is an optional boolean (default: `true`) that specifies whether the setting
light.cpp
log.cpp
map.cpp
+ map_settings_manager.cpp
mapblock.cpp
mapgen.cpp
mapgen_flat.cpp
}
-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, ¶ms, this);
+ Mapgen *mg = Mapgen::createMapgen(params->mgtype, i, params, this);
m_mapgens.push_back(mg);
}
+
+ return true;
}
// 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;
return m_mapgens[0]->getGroundLevelAtPoint(p);
}
-
+// TODO(hmmmm): Move this to ServerMap
bool EmergeManager::isBlockUnderground(v3s16 blockpos)
{
#if 0
#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(
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;
EmergeManager(IGameDef *gamedef);
~EmergeManager();
- void loadMapgenParams();
- void initMapgens();
+ bool initMapgens(MapgenParams *mgparams);
void startThreads();
void stopThreads();
*/
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.
*/
}
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
#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);
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;
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
}
}
-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);
#include "modifiedstate.h"
#include "util/container.h"
#include "nodetimer.h"
+#include "map_settings_manager.h"
class Settings;
class Database;
class EmergeManager;
class ServerEnvironment;
struct BlockMakeData;
-struct MapgenParams;
-
/*
MapEditEvent
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();*/
u64 getSeed();
s16 getWaterLevel();
+ MapSettingsManager settings_mgr;
+
private:
// Emerge manager
EmergeManager *m_emerge;
--- /dev/null
+/*
+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;
+}
--- /dev/null
+/*
+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
{
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:
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);
}
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;
};
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:
///////////////////////////////////////////////////////////////////////////////////////
-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(¶ms->np_terrain, seed, csize.X, csize.Z);
+ noise_filler_depth = new Noise(¶ms->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;
}
extern FlagDesc flagdesc_mapgen_flat[];
-struct MapgenFlatParams : public MapgenSpecificParams {
+struct MapgenFlatParams : public MapgenParams {
u32 spflags;
s16 ground_level;
s16 large_cave_depth;
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; }
///////////////////////////////////////////////////////////////////////////////////////
-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(¶ms->np_seabed, seed, csize.X, csize.Z);
+ noise_filler_depth = new Noise(¶ms->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;
extern FlagDesc flagdesc_mapgen_fractal[];
-struct MapgenFractalParams : public MapgenSpecificParams {
+struct MapgenFractalParams : public MapgenParams {
u32 spflags;
float cave_width;
u16 fractal;
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; }
#include "mapgen.h"
-struct MapgenSinglenodeParams : public MapgenSpecificParams {
+struct MapgenSinglenodeParams : public MapgenParams {
MapgenSinglenodeParams() {}
~MapgenSinglenodeParams() {}
};
-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(¶ms->np_filler_depth, seed, csize.X, csize.Z);
+ noise_factor = new Noise(¶ms->np_factor, seed, csize.X, csize.Z);
+ noise_height = new Noise(¶ms->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(¶ms->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;
}
extern FlagDesc flagdesc_mapgen_v5[];
-struct MapgenV5Params : public MapgenSpecificParams {
+struct MapgenV5Params : public MapgenParams {
u32 spflags;
float cave_width;
NoiseParams np_filler_depth;
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; }
/////////////////////////////////////////////////////////////////////////////
-MapgenV6::MapgenV6(int mapgenid, MapgenParams *params, EmergeManager *emerge)
+MapgenV6::MapgenV6(int mapgenid, MapgenV6Params *params, EmergeManager *emerge)
: Mapgen(mapgenid, params, emerge)
{
this->m_emerge = 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 = ¶ms->np_cave;
+ np_humidity = ¶ms->np_humidity;
+ np_trees = ¶ms->np_trees;
+ np_apple_trees = ¶ms->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(¶ms->np_terrain_base, seed, csize.X, csize.Y);
+ noise_terrain_higher = new Noise(¶ms->np_terrain_higher, seed, csize.X, csize.Y);
+ noise_steepness = new Noise(¶ms->np_steepness, seed, csize.X, csize.Y);
+ noise_height_select = new Noise(¶ms->np_height_select, seed, csize.X, csize.Y);
+ noise_mud = new Noise(¶ms->np_mud, seed, csize.X, csize.Y);
+ noise_beach = new Noise(¶ms->np_beach, seed, csize.X, csize.Y);
+ noise_biome = new Noise(¶ms->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(¶ms->np_humidity, seed,
csize.X + 2 * MAP_BLOCKSIZE, csize.Y + 2 * MAP_BLOCKSIZE);
//// Resolve nodes to be used
};
-struct MapgenV6Params : public MapgenSpecificParams {
+struct MapgenV6Params : public MapgenParams {
u32 spflags;
float freq_desert;
float freq_beach;
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; }
///////////////////////////////////////////////////////////////////////////////
-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(¶ms->np_terrain_base, seed, csize.X, csize.Z);
+ noise_terrain_alt = new Noise(¶ms->np_terrain_alt, seed, csize.X, csize.Z);
+ noise_terrain_persist = new Noise(¶ms->np_terrain_persist, seed, csize.X, csize.Z);
+ noise_height_select = new Noise(¶ms->np_height_select, seed, csize.X, csize.Z);
+ noise_filler_depth = new Noise(¶ms->np_filler_depth, seed, csize.X, csize.Z);
+ noise_mount_height = new Noise(¶ms->np_mount_height, seed, csize.X, csize.Z);
+ noise_ridge_uwater = new Noise(¶ms->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(¶ms->np_mountain, seed, csize.X, csize.Y + 2, csize.Z);
+ noise_ridge = new Noise(¶ms->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;
}
extern FlagDesc flagdesc_mapgen_v7[];
-struct MapgenV7Params : public MapgenSpecificParams {
+struct MapgenV7Params : public MapgenParams {
u32 spflags;
float cave_width;
NoiseParams np_terrain_base;
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; }
///////////////////////////////////////////////////////////////////////////////
-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
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(¶ms->np_filler_depth, seed, csize.X, csize.Z);
+ noise_inter_valley_slope = new Noise(¶ms->np_inter_valley_slope, seed, csize.X, csize.Z);
+ noise_rivers = new Noise(¶ms->np_rivers, seed, csize.X, csize.Z);
+ noise_terrain_height = new Noise(¶ms->np_terrain_height, seed, csize.X, csize.Z);
+ noise_valley_depth = new Noise(¶ms->np_valley_depth, seed, csize.X, csize.Z);
+ noise_valley_profile = new Noise(¶ms->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(¶ms->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(¶ms->np_cave1, seed, csize.X, csize.Y + 1, csize.Z);
+ noise_cave2 = new Noise(¶ms->np_cave2, seed, csize.X, csize.Y + 1, csize.Z);
+ noise_massive_caves = new Noise(¶ms->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);
//extern Profiler *mapgen_profiler;
-struct MapgenValleysParams : public MapgenSpecificParams {
+struct MapgenValleysParams : public MapgenParams {
u32 spflags;
s16 large_cave_depth;
s16 massive_cave_depth;
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; }
{
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;
{
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;
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;
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();
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();
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);
// 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);
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);
//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);
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) {
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;
m_env->getGameTime(),
m_lag,
m_gamespec.id,
- m_emerge->params.mg_name,
+ Mapgen::getMapgenName(m_emerge->mgparams->mgtype),
m_mods);
counter = 0.01;
}
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";
${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
--- /dev/null
+ /*
+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());
+}
projects / oweals / minetest.git / commitdiff