BRNSystems/minetest
1
0
Fork 0
forked from Mirrorlandia_minetest/minetest
Code Pull Requests 1 Activity

Add MapSettingsManager and new mapgen setting script API functions

Browse Source 
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.
This commit is contained in:
kwolekr 2016-06-24 18:15:56 -04:00
parent 92705306bf
commit 3c63c3044d
31 changed files with 890 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
build/android/jni/Android.mk
View File

@ -169,6 +169,7 @@ LOCAL_SRC_FILES := \
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 \
@ -238,6 +239,7 @@ LOCAL_SRC_FILES := \
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 \

19
doc/lua_api.txt
View File

@ -2089,7 +2089,9 @@ and `minetest.auth_reload` call the authetification handler.
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`
@ -2099,6 +2101,23 @@ and `minetest.auth_reload` call the authetification handler.
* `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

1
src/CMakeLists.txt
View File

@ -414,6 +414,7 @@ set(common_SRCS
light.cpp
log.cpp
map.cpp
map_settings_manager.cpp
mapblock.cpp
mapgen.cpp
mapgen_flat.cpp

40
src/emerge.cpp
View File

@ -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;
return false;
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;
}
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(

15
src/emerge.h
View File

@ -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();

98
src/map.cpp
View File

@ -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;
@ -2906,7 +2906,8 @@ void ServerMap::save(ModifiedState save_level)
<<std::endl;
if (m_map_metadata_changed || save_level == MOD_STATE_CLEAN) {
saveMapMeta();
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);

10
src/map.h
View File

@ -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;

194
src/map_settings_manager.cpp Normal file
View File

@ -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;
}

79
src/map_settings_manager.h Normal file
View File

@ -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

62
src/mapgen.cpp
View File

@ -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())
if (settings->getNoEx(seed_name, seed_str)) {
if (!seed_str.empty())
seed = read_seed(seed_str.c_str());
else
myrand_bytes(&seed, sizeof(seed));
}
settings.getNoEx("mg_name", mg_name);
settings.getS16NoEx("water_level", water_level);
settings.getS16NoEx("chunksize", chunksize);
settings.getFlagStrNoEx("mg_flags", flags, flagdesc_mapgen);
std::string mg_name;
if (settings->getNoEx("mg_name", mg_name))
this->mgtype = Mapgen::getMapgenType(mg_name);
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);
}

20
src/mapgen.h
View File

@ -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:

28
src/mapgen_flat.cpp
View File

@ -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;
}

4
src/mapgen_flat.h
View File

@ -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; }

34
src/mapgen_fractal.cpp
View File

@ -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;

4
src/mapgen_fractal.h
View File

@ -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; }

2
src/mapgen_singlenode.h
View File

@ -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() {}

20
src/mapgen_v5.cpp
View File

@ -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;
}

4
src/mapgen_v5.h
View File

@ -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; }

33
src/mapgen_v6.cpp
View File

@ -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

4
src/mapgen_v6.h
View File

@ -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; }

30
src/mapgen_v7.cpp
View File

@ -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;
}

4
src/mapgen_v7.h
View File

@ -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; }

41
src/mapgen_valleys.cpp
View File

@ -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);

4
src/mapgen_valleys.h
View File

@ -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; }

156
src/script/lua_api/l_mapgen.cpp
View File

@ -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");
if (lua_isstring(L, -1))
params->flags &= ~readFlagString(lua_tostring(L, -1), flagdesc_mapgen, NULL);
if (getflagsfield(L, 1, "flags", flagdesc_mapgen, &flags, &flagmask)) {
params->flags &= ~flagmask;
params->flags |= flags;
lua_getfield(L, 1, "flags");
if (lua_isstring(L, -1))
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;
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);

12
src/script/lua_api/l_mapgen.h
View File

@ -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);

2
src/script/lua_api/l_vmanip.cpp
View File

@ -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);

15
src/server.cpp
View File

@ -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;
}

4
src/subgame.cpp
View File

@ -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";

1
src/unittest/CMakeLists.txt
View File

@ -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

255
src/unittest/test_map_settings_manager.cpp Normal file
View File

@ -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());
}