MapgenParams is no longer a polymorphic class, eliminating the need for messy and bug-prone reallocations.
Separation between the common and mapgen-specific parameters is now strongly defined.
Mapgen parameters objects are now properly encapsulated within the proper subsystems.
#include "main.h"
#include "util/mathconstants.h"
-NoiseParams nparams_biome_def_heat =
- {50, 50, v3f(500.0, 500.0, 500.0), 5349, 3, 0.70};
-NoiseParams nparams_biome_def_humidity =
- {50, 50, v3f(500.0, 500.0, 500.0), 842, 3, 0.55};
+NoiseParams nparams_biome_def_heat(50, 50, v3f(500.0, 500.0, 500.0), 5349, 3, 0.70);
+NoiseParams nparams_biome_def_humidity(50, 50, v3f(500.0, 500.0, 500.0), 842, 3, 0.55);
BiomeDefManager::BiomeDefManager() {
#include "mapgen_v7.h"
#include "cavegen.h"
-NoiseParams nparams_caveliquids =
- {0, 1, v3f(150.0, 150.0, 150.0), 776, 3, 0.6};
+NoiseParams nparams_caveliquids(0, 1, v3f(150.0, 150.0, 150.0), 776, 3, 0.6);
///////////////////////////////////////////////////////////////////////////////
settings->setDefault("mg_name", "v6");
settings->setDefault("water_level", "1");
settings->setDefault("chunksize", "5");
- settings->setDefault("mg_flags", "trees, caves, v6_biome_blend");
- settings->setDefault("mgv6_freq_desert", "0.45");
- settings->setDefault("mgv6_freq_beach", "0.15");
-
- settings->setDefault("mgv6_np_terrain_base", "-4, 20, (250, 250, 250), 82341, 5, 0.6");
- settings->setDefault("mgv6_np_terrain_higher", "20, 16, (500, 500, 500), 85039, 5, 0.6");
- settings->setDefault("mgv6_np_steepness", "0.85, 0.5, (125, 125, 125), -932, 5, 0.7");
- settings->setDefault("mgv6_np_height_select", "0.5, 1, (250, 250, 250), 4213, 5, 0.69");
- settings->setDefault("mgv6_np_mud", "4, 2, (200, 200, 200), 91013, 3, 0.55");
- settings->setDefault("mgv6_np_beach", "0, 1, (250, 250, 250), 59420, 3, 0.50");
- settings->setDefault("mgv6_np_biome", "0, 1, (250, 250, 250), 9130, 3, 0.50");
- settings->setDefault("mgv6_np_cave", "6, 6, (250, 250, 250), 34329, 3, 0.50");
- settings->setDefault("mgv6_np_humidity", "0.5, 0.5, (500, 500, 500), 72384, 4, 0.66");
- settings->setDefault("mgv6_np_trees", "0, 1, (125, 125, 125), 2, 4, 0.66");
- settings->setDefault("mgv6_np_apple_trees", "0, 1, (100, 100, 100), 342902, 3, 0.45");
-
- settings->setDefault("mgv7_np_terrain_base", "4, 70, (300, 300, 300), 82341, 6, 0.7");
- settings->setDefault("mgv7_np_terrain_alt", "4, 25, (600, 600, 600), 5934, 5, 0.6");
- settings->setDefault("mgv7_np_terrain_persist", "0.6, 0.1, (500, 500, 500), 539, 3, 0.6");
- settings->setDefault("mgv7_np_height_select", "-0.5, 1, (250, 250, 250), 4213, 5, 0.69");
- settings->setDefault("mgv7_np_filler_depth", "0, 1.2, (150, 150, 150), 261, 4, 0.7");
- settings->setDefault("mgv7_np_mount_height", "100, 30, (500, 500, 500), 72449, 4, 0.6");
- settings->setDefault("mgv7_np_ridge_uwater", "0, 1, (500, 500, 500), 85039, 4, 0.6");
- settings->setDefault("mgv7_np_mountain", "0, 1, (250, 350, 250), 5333, 5, 0.68");
- settings->setDefault("mgv7_np_ridge", "0, 1, (100, 120, 100), 6467, 4, 0.75");
-
- settings->setDefault("mgindev_np_terrain_base", "-4, 20, (250, 250, 250), 82341, 5, 0.6, 10, 10");
- settings->setDefault("mgindev_np_terrain_higher", "20, 16, (500, 500, 500), 85039, 5, 0.6, 10, 10");
- settings->setDefault("mgindev_np_steepness", "0.85, 0.5, (125, 125, 125), -932, 5, 0.7, 2, 10");
- settings->setDefault("mgindev_np_mud", "4, 2, (200, 200, 200), 91013, 3, 0.55, 1, 1");
- settings->setDefault("mgindev_np_float_islands1", "0, 1, (256, 256, 256), 3683, 6, 0.6, 1, 1.5");
- settings->setDefault("mgindev_np_float_islands2", "0, 1, (8, 8, 8 ), 9292, 2, 0.5, 1, 1.5");
- settings->setDefault("mgindev_np_float_islands3", "0, 1, (256, 256, 256), 6412, 2, 0.5, 1, 0.5");
- settings->setDefault("mgindev_np_biome", "0, 1, (250, 250, 250), 9130, 3, 0.50, 1, 10");
- settings->setDefault("mgindev_float_islands", "500");
+ settings->setDefault("mg_flags", "trees, caves");
settings->setDefault("mgmath_generator", "mandelbox");
//#define DGEN_USE_TORCHES
-NoiseParams nparams_dungeon_rarity =
- {0.0, 1.0, v3f(500.0, 500.0, 500.0), 0, 2, 0.8};
-NoiseParams nparams_dungeon_wetness =
- {0.0, 1.0, v3f(40.0, 40.0, 40.0), 32474, 4, 1.1};
-NoiseParams nparams_dungeon_density =
- {0.0, 1.0, v3f(2.5, 2.5, 2.5), 0, 2, 1.4};
+NoiseParams nparams_dungeon_rarity(0.0, 1.0, v3f(500.0, 500.0, 500.0), 0, 2, 0.8);
+NoiseParams nparams_dungeon_wetness(0.0, 1.0, v3f(40.0, 40.0, 40.0), 32474, 4, 1.1);
+NoiseParams nparams_dungeon_density(0.0, 1.0, v3f(2.5, 2.5, 2.5), 0, 2, 1.4);
///////////////////////////////////////////////////////////////////////////////
this->ndef = gamedef->getNodeDefManager();
this->biomedef = new BiomeDefManager();
- this->params = NULL;
+ this->gennotify = 0;
// Note that accesses to this variable are not synchronized.
// This is because the *only* thread ever starting or stopping
// EmergeThreads should be the ServerThread.
this->threads_active = false;
- this->luaoverride_params = NULL;
- this->luaoverride_params_modified = 0;
- this->luaoverride_flagmask = 0;
-
- this->gennotify = 0;
-
mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
- int nthreads;
- if (g_settings->get("num_emerge_threads").empty()) {
- int nprocs = porting::getNumberOfProcessors();
- // leave a proc for the main thread and one for some other misc threads
- nthreads = (nprocs > 2) ? nprocs - 2 : 1;
- } else {
- nthreads = g_settings->getU16("num_emerge_threads");
- }
+ // if unspecified, leave a proc for the main thread and one for
+ // some other misc thread
+ int nthreads = 0;
+ if (!g_settings->tryGetS16("num_emerge_threads", nthreads))
+ nthreads = porting::getNumberOfProcessors() - 2;
if (nthreads < 1)
nthreads = 1;
- qlimit_total = g_settings->getU16("emergequeue_limit_total");
- qlimit_diskonly = g_settings->get("emergequeue_limit_diskonly").empty() ?
- nthreads * 5 + 1 :
- g_settings->getU16("emergequeue_limit_diskonly");
- qlimit_generate = g_settings->get("emergequeue_limit_generate").empty() ?
- nthreads + 1 :
- g_settings->getU16("emergequeue_limit_generate");
+ qlimit_total = g_settings->getU16("emergequeue_limit_total");
+ if (!g_settings->tryGetU16("emergequeue_limit_diskonly", qlimit_diskonly))
+ qlimit_diskonly = nthreads * 5 + 1;
+ if (!g_settings->tryGetU16("emergequeue_limit_generate", qlimit_generate))
+ qlimit_generate = nthreads + 1;
for (int i = 0; i != nthreads; i++)
emergethread.push_back(new EmergeThread((Server *)gamedef, i));
infostream << "EmergeManager: using " << nthreads << " threads" << std::endl;
+
+ loadParamsFromSettings(g_settings);
+
+ if (g_settings->get("fixed_map_seed").empty()) {
+ params.seed = (((u64)(myrand() & 0xffff) << 0)
+ | ((u64)(myrand() & 0xffff) << 16)
+ | ((u64)(myrand() & 0xffff) << 32)
+ | ((u64)(myrand() & 0xffff) << 48));
+ }
}
}
-void EmergeManager::initMapgens(MapgenParams *mgparams) {
- Mapgen *mg;
-
+void EmergeManager::initMapgens() {
if (mapgen.size())
return;
for (size_t i = 0; i != decorations.size(); i++)
decorations[i]->resolveNodeNames(ndef);
- // Apply mapgen parameter overrides from Lua
- if (luaoverride_params) {
- if (luaoverride_params_modified & MGPARAMS_SET_MGNAME) {
- MapgenParams *mgp = setMapgenType(mgparams, luaoverride_params->mg_name);
- if (!mgp) {
- errorstream << "EmergeManager: Failed to set new mapgen name"
- << std::endl;
- } else {
- mgparams = mgp;
- }
- }
-
- if (luaoverride_params_modified & MGPARAMS_SET_SEED)
- mgparams->seed = luaoverride_params->seed;
-
- if (luaoverride_params_modified & MGPARAMS_SET_WATER_LEVEL)
- mgparams->water_level = luaoverride_params->water_level;
-
- if (luaoverride_params_modified & MGPARAMS_SET_FLAGS) {
- mgparams->flags &= ~luaoverride_flagmask;
- mgparams->flags |= luaoverride_params->flags;
+ if (!params.sparams) {
+ params.sparams = createMapgenParams(params.mg_name);
+ if (!params.sparams) {
+ params.mg_name = DEFAULT_MAPGEN;
+ params.sparams = createMapgenParams(params.mg_name);
+ assert(params.sparams);
}
-
- delete luaoverride_params;
- luaoverride_params = NULL;
+ params.sparams->readParams(g_settings);
}
// Create the mapgens
- this->params = mgparams;
for (size_t i = 0; i != emergethread.size(); i++) {
- mg = createMapgen(params->mg_name, i, params);
- if (!mg) {
- infostream << "EmergeManager: Falling back to Mapgen V6" << std::endl;
-
- params = setMapgenType(params, "v6");
- mg = createMapgen(params->mg_name, i, params);
- if (!mg) {
- errorstream << "EmergeManager: CRITICAL ERROR: Failed to fall"
- "back to Mapgen V6, not generating map" << std::endl;
- }
- }
+ Mapgen *mg = createMapgen(params.mg_name, i, ¶ms);
+ assert(mg);
mapgen.push_back(mg);
}
}
-MapgenParams *EmergeManager::setMapgenType(MapgenParams *mgparams,
- std::string newname) {
- MapgenParams *newparams = createMapgenParams(newname);
- if (!newparams) {
- errorstream << "EmergeManager: Mapgen override failed" << std::endl;
- return NULL;
- }
-
- newparams->mg_name = newname;
- newparams->seed = mgparams->seed;
- newparams->water_level = mgparams->water_level;
- newparams->chunksize = mgparams->chunksize;
- newparams->flags = mgparams->flags;
-
- if (!newparams->readParams(g_settings)) {
- errorstream << "EmergeManager: Mapgen override failed" << std::endl;
- delete newparams;
- return NULL;
- }
-
- delete mgparams;
- return newparams;
-}
-
-
Mapgen *EmergeManager::getCurrentMapgen() {
for (unsigned int i = 0; i != emergethread.size(); i++) {
if (emergethread[i]->IsSameThread())
//yuck, but then again, should i bother being accurate?
//the height of the nodes in a single block is quite variable
- return blockpos.Y * (MAP_BLOCKSIZE + 1) <= params->water_level;
+ return blockpos.Y * (MAP_BLOCKSIZE + 1) <= params.water_level;
}
u32 EmergeManager::getBlockSeed(v3s16 p) {
- return (u32)(params->seed & 0xFFFFFFFF) +
+ return (u32)(params.seed & 0xFFFFFFFF) +
p.Z * 38134234 +
p.Y * 42123 +
p.X * 23;
}
-MapgenParams *EmergeManager::createMapgenParams(std::string mgname) {
+MapgenSpecificParams *EmergeManager::createMapgenParams(std::string mgname) {
std::map<std::string, MapgenFactory *>::const_iterator iter;
iter = mglist.find(mgname);
if (iter == mglist.end()) {
}
-MapgenParams *EmergeManager::getParamsFromSettings(Settings *settings) {
- std::string mg_name = settings->get("mg_name");
- MapgenParams *mgparams = createMapgenParams(mg_name);
- if (!mgparams)
- return NULL;
+void EmergeManager::loadParamsFromSettings(Settings *settings) {
+ std::string seed_str;
+ const char *setname = (settings == g_settings) ? "fixed_map_seed" : "seed";
- std::string seedstr = settings->get(settings == g_settings ?
- "fixed_map_seed" : "seed");
+ if (settings->tryGet(setname, seed_str))
+ params.seed = read_seed(seed_str.c_str());
- mgparams->mg_name = mg_name;
- mgparams->seed = read_seed(seedstr.c_str());
- mgparams->water_level = settings->getS16("water_level");
- mgparams->chunksize = settings->getS16("chunksize");
- mgparams->flags = settings->getFlagStr("mg_flags", flagdesc_mapgen);
+ settings->tryGet("mg_name", params.mg_name);
+ settings->tryGetS16("water_level", params.water_level);
+ settings->tryGetS16("chunksize", params.chunksize);
+ settings->tryGetFlagStr("mg_flags", params.flags, flagdesc_mapgen);
+
+ delete params.sparams;
+ params.sparams = createMapgenParams(params.mg_name);
+ if (params.sparams)
+ params.sparams->readParams(settings);
- if (!mgparams->readParams(settings)) {
- delete mgparams;
- return NULL;
- }
- return mgparams;
}
-void EmergeManager::setParamsToSettings(Settings *settings) {
- settings->set("mg_name", params->mg_name);
- settings->setU64("seed", params->seed);
- settings->setS16("water_level", params->water_level);
- settings->setS16("chunksize", params->chunksize);
- settings->setFlagStr("mg_flags", params->flags, flagdesc_mapgen);
+void EmergeManager::saveParamsToSettings(Settings *settings) {
+ settings->set("mg_name", params.mg_name);
+ settings->setU64("seed", params.seed);
+ settings->setS16("water_level", params.water_level);
+ settings->setS16("chunksize", params.chunksize);
+ settings->setFlagStr("mg_flags", params.flags, flagdesc_mapgen);
- params->writeParams(settings);
+ if (params.sparams)
+ params.sparams->writeParams(settings);
}
#include "irr_v3d.h"
#include "util/container.h"
#include "map.h" // for ManualMapVoxelManipulator
+#include "mapgen.h" // for MapgenParams
#define MGPARAMS_SET_MGNAME 1
#define MGPARAMS_SET_SEED 2
infostream << "EmergeThread: " x << std::endl; }
class EmergeThread;
-class Mapgen;
-struct MapgenParams;
-struct MapgenFactory;
+//class Mapgen;
+//struct MapgenFactory;
class Biome;
class BiomeDefManager;
class Decoration;
bool threads_active;
//settings
- MapgenParams *params;
+ MapgenParams params;
bool mapgen_debug_info;
u16 qlimit_total;
u16 qlimit_diskonly;
u32 gennotify;
- MapgenParams *luaoverride_params;
- u32 luaoverride_params_modified;
- u32 luaoverride_flagmask;
-
//block emerge queue data structures
JMutex queuemutex;
std::map<v3s16, BlockEmergeData *> blocks_enqueued;
EmergeManager(IGameDef *gamedef);
~EmergeManager();
- void initMapgens(MapgenParams *mgparams);
- MapgenParams *setMapgenType(MapgenParams *mgparams, std::string newname);
+ void initMapgens();
Mapgen *getCurrentMapgen();
Mapgen *createMapgen(std::string mgname, int mgid,
MapgenParams *mgparams);
- MapgenParams *createMapgenParams(std::string mgname);
+ MapgenSpecificParams *createMapgenParams(std::string mgname);
void startThreads();
void stopThreads();
bool enqueueBlockEmerge(u16 peer_id, v3s16 p, bool allow_generate);
void registerMapgen(std::string name, MapgenFactory *mgfactory);
- MapgenParams *getParamsFromSettings(Settings *settings);
- void setParamsToSettings(Settings *settings);
+ void loadParamsFromSettings(Settings *settings);
+ void saveParamsToSettings(Settings *settings);
//mapgen helper methods
Biome *getBiomeAtPoint(v3s16 p);
*/
ServerMap::ServerMap(std::string savedir, IGameDef *gamedef, EmergeManager *emerge):
Map(dout_server, gamedef),
- m_seed(0),
+ m_emerge(emerge),
m_map_metadata_changed(true)
{
verbosestream<<__FUNCTION_NAME<<std::endl;
- m_emerge = emerge;
- m_mgparams = m_emerge->getParamsFromSettings(g_settings);
- if (!m_mgparams)
- m_mgparams = new MapgenV6Params();
-
- m_seed = m_mgparams->seed;
-
- if (g_settings->get("fixed_map_seed").empty())
- {
- m_seed = (((u64)(myrand() & 0xffff) << 0)
- | ((u64)(myrand() & 0xffff) << 16)
- | ((u64)(myrand() & 0xffff) << 32)
- | ((u64)(myrand() & 0xffff) << 48));
- m_mgparams->seed = m_seed;
- }
-
- /*
- Experimental and debug stuff
- */
-
- {
- }
-
/*
Try to load map; if not found, create a new one.
*/
infostream<<"ServerMap: Successfully loaded map "
<<"metadata from "<<savedir
<<", assuming valid save directory."
- <<" seed="<<m_seed<<"."
+ <<" seed="<< m_emerge->params.seed <<"."
<<std::endl;
m_map_saving_enabled = true;
/*
Close database if it was opened
*/
- delete(dbase);
+ delete dbase;
#if 0
/*
delete chunk;
}
#endif
+}
+
+u64 ServerMap::getSeed()
+{
+ return m_emerge->params.seed;
+}
- delete m_mgparams;
+s16 ServerMap::getWaterLevel()
+{
+ return m_emerge->params.water_level;
}
bool ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
bool enable_mapgen_debug_info = m_emerge->mapgen_debug_info;
EMERGE_DBG_OUT("initBlockMake(): " PP(blockpos) " - " PP(blockpos));
- s16 chunksize = m_mgparams->chunksize;
+ s16 chunksize = m_emerge->params.chunksize;
s16 coffset = -chunksize / 2;
v3s16 chunk_offset(coffset, coffset, coffset);
v3s16 blockpos_div = getContainerPos(blockpos - chunk_offset, chunksize);
blockpos_over_limit(blockpos_max + extra_borders))
return false;
- data->seed = m_seed;
+ data->seed = m_emerge->params.seed;
data->blockpos_min = blockpos_min;
data->blockpos_max = blockpos_max;
data->blockpos_requested = blockpos;
Settings params;
- m_emerge->setParamsToSettings(¶ms);
+ m_emerge->saveParamsToSettings(¶ms);
params.writeLines(ss);
ss<<"[end_of_params]\n";
params.parseConfigLine(line);
}
- MapgenParams *mgparams;
- try {
- mgparams = m_emerge->getParamsFromSettings(¶ms);
- } catch (SettingNotFoundException &e) {
- infostream << "Couldn't get a setting from map_meta.txt: "
- << e.what() << std::endl;
- mgparams = NULL;
- }
-
- if (mgparams) {
- if (m_mgparams)
- delete m_mgparams;
- m_mgparams = mgparams;
- m_seed = mgparams->seed;
- } else {
- if (params.exists("seed")) {
- m_seed = read_seed(params.get("seed").c_str());
- m_mgparams->seed = m_seed;
- }
- }
+ m_emerge->loadParamsFromSettings(¶ms);
- verbosestream<<"ServerMap::loadMapMeta(): "<<"seed="<<m_seed<<std::endl;
+ verbosestream<<"ServerMap::loadMapMeta(): seed="
+ << m_emerge->params.seed<<std::endl;
}
void ServerMap::saveSectorMeta(ServerMapSector *sector)
block = getBlockNoCreateNoEx(getNodeBlockPos(p));
}
- f32 heat = m_emerge->biomedef->calcBlockHeat(p, m_seed,
+ f32 heat = m_emerge->biomedef->calcBlockHeat(p, getSeed(),
env->getTimeOfDayF(), gametime * env->getTimeOfDaySpeed());
if(block) {
block = getBlockNoCreateNoEx(getNodeBlockPos(p));
}
- f32 humidity = m_emerge->biomedef->calcBlockHumidity(p, m_seed,
+ f32 humidity = m_emerge->biomedef->calcBlockHumidity(p, getSeed(),
env->getTimeOfDayF(), gametime * env->getTimeOfDaySpeed());
if(block) {
bool isSavingEnabled(){ return m_map_saving_enabled; }
- u64 getSeed(){ return m_seed; }
-
- MapgenParams *getMapgenParams(){ return m_mgparams; }
- void setMapgenParams(MapgenParams *mgparams){ m_mgparams = mgparams; }
-
- // Parameters fed to the Mapgen
- MapgenParams *m_mgparams;
+ u64 getSeed();
+ s16 getWaterLevel();
virtual s16 updateBlockHeat(ServerEnvironment *env, v3s16 p, MapBlock *block = NULL);
virtual s16 updateBlockHumidity(ServerEnvironment *env, v3s16 p, MapBlock *block = NULL);
private:
- // Seed used for all kinds of randomness in generation
- u64 m_seed;
-
// Emerge manager
EmergeManager *m_emerge;
#include "util/serialize.h"
#include "filesys.h"
+
FlagDesc flagdesc_mapgen[] = {
{"trees", MG_TREES},
{"caves", MG_CAVES},
{"dungeons", MG_DUNGEONS},
- {"v6_jungles", MGV6_JUNGLES},
- {"v6_biome_blend", MGV6_BIOME_BLEND},
{"flat", MG_FLAT},
{"nolight", MG_NOLIGHT},
- {"v6_nomudflow", MGV6_NOMUDFLOW},
{NULL, 0}
};
vm->spreadLight(bank, light_sources, ndef);
}
}
-
-
-//////////////////////// Mapgen V6 parameter read/write
-
-bool MapgenV6Params::readParams(Settings *settings) {
- freq_desert = settings->getFloat("mgv6_freq_desert");
- freq_beach = settings->getFloat("mgv6_freq_beach");
-
- bool success =
- settings->getNoiseParams("mgv6_np_terrain_base", np_terrain_base) &&
- settings->getNoiseParams("mgv6_np_terrain_higher", np_terrain_higher) &&
- settings->getNoiseParams("mgv6_np_steepness", np_steepness) &&
- settings->getNoiseParams("mgv6_np_height_select", np_height_select) &&
- settings->getNoiseParams("mgv6_np_mud", np_mud) &&
- settings->getNoiseParams("mgv6_np_beach", np_beach) &&
- settings->getNoiseParams("mgv6_np_biome", np_biome) &&
- settings->getNoiseParams("mgv6_np_cave", np_cave) &&
- settings->getNoiseParams("mgv6_np_humidity", np_humidity) &&
- settings->getNoiseParams("mgv6_np_trees", np_trees) &&
- settings->getNoiseParams("mgv6_np_apple_trees", np_apple_trees);
- return success;
-}
-
-
-void MapgenV6Params::writeParams(Settings *settings) {
- settings->setFloat("mgv6_freq_desert", freq_desert);
- settings->setFloat("mgv6_freq_beach", freq_beach);
-
- settings->setNoiseParams("mgv6_np_terrain_base", np_terrain_base);
- settings->setNoiseParams("mgv6_np_terrain_higher", np_terrain_higher);
- settings->setNoiseParams("mgv6_np_steepness", np_steepness);
- settings->setNoiseParams("mgv6_np_height_select", np_height_select);
- settings->setNoiseParams("mgv6_np_mud", np_mud);
- settings->setNoiseParams("mgv6_np_beach", np_beach);
- settings->setNoiseParams("mgv6_np_biome", np_biome);
- settings->setNoiseParams("mgv6_np_cave", np_cave);
- settings->setNoiseParams("mgv6_np_humidity", np_humidity);
- settings->setNoiseParams("mgv6_np_trees", np_trees);
- settings->setNoiseParams("mgv6_np_apple_trees", np_apple_trees);
-}
-
-
-bool MapgenV7Params::readParams(Settings *settings) {
- bool success =
- settings->getNoiseParams("mgv7_np_terrain_base", np_terrain_base) &&
- settings->getNoiseParams("mgv7_np_terrain_alt", np_terrain_alt) &&
- settings->getNoiseParams("mgv7_np_terrain_persist", np_terrain_persist) &&
- settings->getNoiseParams("mgv7_np_height_select", np_height_select) &&
- settings->getNoiseParams("mgv7_np_filler_depth", np_filler_depth) &&
- settings->getNoiseParams("mgv7_np_mount_height", np_mount_height) &&
- settings->getNoiseParams("mgv7_np_ridge_uwater", np_ridge_uwater) &&
- settings->getNoiseParams("mgv7_np_mountain", np_mountain) &&
- settings->getNoiseParams("mgv7_np_ridge", np_ridge);
- return success;
-}
-
-
-void MapgenV7Params::writeParams(Settings *settings) {
- settings->setNoiseParams("mgv7_np_terrain_base", np_terrain_base);
- settings->setNoiseParams("mgv7_np_terrain_alt", np_terrain_alt);
- settings->setNoiseParams("mgv7_np_terrain_persist", np_terrain_persist);
- settings->setNoiseParams("mgv7_np_height_select", np_height_select);
- settings->setNoiseParams("mgv7_np_filler_depth", np_filler_depth);
- settings->setNoiseParams("mgv7_np_mount_height", np_mount_height);
- settings->setNoiseParams("mgv7_np_ridge_uwater", np_ridge_uwater);
- settings->setNoiseParams("mgv7_np_mountain", np_mountain);
- settings->setNoiseParams("mgv7_np_ridge", np_ridge);
-}
#include "noise.h"
#include "settings.h"
+#define DEFAULT_MAPGEN "v6"
+
/////////////////// Mapgen flags
#define MG_TREES 0x01
#define MG_CAVES 0x02
#define MG_DUNGEONS 0x04
-#define MGV6_JUNGLES 0x08
-#define MGV6_BIOME_BLEND 0x10
-#define MG_FLAT 0x20
-#define MG_NOLIGHT 0x40
-#define MGV7_MOUNTAINS 0x80
-#define MGV7_RIDGES 0x100
-#define MGV6_NOMUDFLOW 0x200
+#define MG_FLAT 0x08
+#define MG_NOLIGHT 0x10
/////////////////// Ore generation flags
// Use absolute value of height to determine ore placement
};
+struct MapgenSpecificParams {
+ virtual void readParams(Settings *settings) = 0;
+ virtual void writeParams(Settings *settings) = 0;
+ virtual ~MapgenSpecificParams() {}
+};
+
struct MapgenParams {
std::string mg_name;
int chunksize;
int water_level;
u32 flags;
+ MapgenSpecificParams *sparams;
+
MapgenParams() {
mg_name = "v6";
seed = 0;
water_level = 1;
chunksize = 5;
- flags = MG_TREES | MG_CAVES | MGV6_BIOME_BLEND;
+ flags = MG_TREES | MG_CAVES;
+ sparams = NULL;
}
-
- virtual bool readParams(Settings *settings) { return true; }
- virtual void writeParams(Settings *settings) {}
- virtual ~MapgenParams() {}
};
class Mapgen {
struct MapgenFactory {
virtual Mapgen *createMapgen(int mgid, MapgenParams *params,
EmergeManager *emerge) = 0;
- virtual MapgenParams *createMapgenParams() = 0;
+ virtual MapgenSpecificParams *createMapgenParams() = 0;
virtual ~MapgenFactory() {}
};
#include "util/numeric.h"
#include "log.h"
-/////////////////// Mapgen Indev perlin noise (default values - not used, from config or defaultsettings)
-
-NoiseIndevParams nparams_indev_def;
-
-/*
-NoiseIndevParams nparams_indev_def_terrain_base;
-// (-AVERAGE_MUD_AMOUNT, 20.0, v3f(250.0, 250.0, 250.0), 82341, 5, 0.6, 1);
-NoiseIndevParams nparams_indev_def_terrain_higher;
-// (20.0, 16.0, v3f(500.0, 500.0, 500.0), 85039, 5, 0.6, 1);
-NoiseIndevParams nparams_indev_def_steepness;
-// (0.85, 0.5, v3f(125.0, 125.0, 125.0), -932, 5, 0.7, 1);
-NoiseIndevParams nparams_indev_def_mud;
-// (AVERAGE_MUD_AMOUNT, 2.0, v3f(200.0, 200.0, 200.0), 91013, 3, 0.55, 1);
-NoiseIndevParams nparams_indev_def_float_islands;
-// (1, 10.0, v3f(500.0, 500.0, 500.0), 32451, 5, 0.6, 1);
-NoiseIndevParams nparams_indev_def_biome;
-*/
-
///////////////////////////////////////////////////////////////////////////////
void NoiseIndev::init(NoiseIndevParams *np, int seed, int sx, int sy, int sz) {
}
}
-MapgenIndev::MapgenIndev(int mapgenid, MapgenIndevParams *params, EmergeManager *emerge)
+MapgenIndev::MapgenIndev(int mapgenid, MapgenParams *params, EmergeManager *emerge)
: MapgenV6(mapgenid, params, emerge)
{
- noiseindev_terrain_base = new NoiseIndev(¶ms->npindev_terrain_base, seed, csize.X, csize.Z);
- noiseindev_terrain_higher = new NoiseIndev(¶ms->npindev_terrain_higher, seed, csize.X, csize.Z);
- noiseindev_steepness = new NoiseIndev(¶ms->npindev_steepness, seed, csize.X, csize.Z);
- noiseindev_mud = new NoiseIndev(¶ms->npindev_mud, seed, csize.X, csize.Z);
- noiseindev_float_islands1 = new NoiseIndev(¶ms->npindev_float_islands1, seed, csize.X, csize.Y, csize.Z);
- noiseindev_float_islands2 = new NoiseIndev(¶ms->npindev_float_islands2, seed, csize.X, csize.Y, csize.Z);
- noiseindev_float_islands3 = new NoiseIndev(¶ms->npindev_float_islands3, seed, csize.X, csize.Z);
- noiseindev_biome = new NoiseIndev(¶ms->npindev_biome, seed, csize.X, csize.Z);
+ MapgenIndevParams *sp = (MapgenIndevParams *)params->sparams;
+
+ float_islands = sp->float_islands;
+
+ noiseindev_terrain_base = new NoiseIndev(&sp->npindev_terrain_base, seed, csize.X, csize.Z);
+ noiseindev_terrain_higher = new NoiseIndev(&sp->npindev_terrain_higher, seed, csize.X, csize.Z);
+ noiseindev_steepness = new NoiseIndev(&sp->npindev_steepness, seed, csize.X, csize.Z);
+ noiseindev_mud = new NoiseIndev(&sp->npindev_mud, seed, csize.X, csize.Z);
+ noiseindev_float_islands1 = new NoiseIndev(&sp->npindev_float_islands1, seed, csize.X, csize.Y, csize.Z);
+ noiseindev_float_islands2 = new NoiseIndev(&sp->npindev_float_islands2, seed, csize.X, csize.Y, csize.Z);
+ noiseindev_float_islands3 = new NoiseIndev(&sp->npindev_float_islands3, seed, csize.X, csize.Z);
+ noiseindev_biome = new NoiseIndev(&sp->npindev_biome, seed, csize.X, csize.Z);
}
MapgenIndev::~MapgenIndev() {
delete noiseindev_terrain_base;
delete noiseindev_terrain_higher;
delete noiseindev_steepness;
- //delete noise_height_select;
- //delete noise_trees;
delete noiseindev_mud;
- //delete noise_beach;
delete noiseindev_float_islands1;
delete noiseindev_float_islands2;
delete noiseindev_float_islands3;
z + 0.2 * noiseindev_biome->npindev->spread.Z * farscale(noiseindev_biome->npindev->farspread, x, z));
}
-bool MapgenIndevParams::readParams(Settings *settings) {
- freq_desert = settings->getFloat("mgv6_freq_desert");
- freq_beach = settings->getFloat("mgv6_freq_beach");
-
- bool success =
- settings->getNoiseIndevParams("mgindev_np_terrain_base", npindev_terrain_base) &&
- settings->getNoiseIndevParams("mgindev_np_terrain_higher", npindev_terrain_higher) &&
- settings->getNoiseIndevParams("mgindev_np_steepness", npindev_steepness) &&
- settings->getNoiseParams("mgv6_np_height_select", np_height_select) &&
- settings->getNoiseParams("mgv6_np_trees", np_trees) &&
- settings->getNoiseIndevParams("mgindev_np_mud", npindev_mud) &&
- settings->getNoiseParams("mgv6_np_beach", np_beach) &&
- settings->getNoiseIndevParams("mgindev_np_biome", npindev_biome) &&
- settings->getNoiseParams("mgv6_np_cave", np_cave) &&
- settings->getNoiseIndevParams("mgindev_np_float_islands1", npindev_float_islands1) &&
- settings->getNoiseIndevParams("mgindev_np_float_islands2", npindev_float_islands2) &&
- settings->getNoiseIndevParams("mgindev_np_float_islands3", npindev_float_islands3);
- return success;
+MapgenIndevParams::MapgenIndevParams() {
+ float_islands = 500;
+ npindev_terrain_base = NoiseIndevParams(-4, 20, v3f(250, 250, 250), 82341, 5, 0.6, 10, 10);
+ npindev_terrain_higher = NoiseIndevParams(20, 16, v3f(500, 500, 500), 85039, 5, 0.6, 10, 10);
+ npindev_steepness = NoiseIndevParams(0.85, 0.5, v3f(125, 125, 125), -932, 5, 0.7, 2, 10);
+ npindev_mud = NoiseIndevParams(4, 2, v3f(200, 200, 200), 91013, 3, 0.55, 1, 1);
+ npindev_biome = NoiseIndevParams(0, 1, v3f(250, 250, 250), 9130, 3, 0.50, 1, 10);
+ npindev_float_islands1 = NoiseIndevParams(0, 1, v3f(256, 256, 256), 3683, 6, 0.6, 1, 1.5);
+ npindev_float_islands2 = NoiseIndevParams(0, 1, v3f(8, 8, 8 ), 9292, 2, 0.5, 1, 1.5);
+ npindev_float_islands3 = NoiseIndevParams(0, 1, v3f(256, 256, 256), 6412, 2, 0.5, 1, 0.5);
+}
+
+void MapgenIndevParams::readParams(Settings *settings) {
+ MapgenV6Params::readParams(settings);
+
+ settings->tryGetS16("mgindev_float_islands", float_islands);
+
+ settings->getNoiseIndevParams("mgindev_np_terrain_base", npindev_terrain_base);
+ settings->getNoiseIndevParams("mgindev_np_terrain_higher", npindev_terrain_higher);
+ settings->getNoiseIndevParams("mgindev_np_steepness", npindev_steepness);
+ settings->getNoiseIndevParams("mgindev_np_mud", npindev_mud);
+ settings->getNoiseIndevParams("mgindev_np_biome", npindev_biome);
+ settings->getNoiseIndevParams("mgindev_np_float_islands1", npindev_float_islands1);
+ settings->getNoiseIndevParams("mgindev_np_float_islands2", npindev_float_islands2);
+ settings->getNoiseIndevParams("mgindev_np_float_islands3", npindev_float_islands3);
}
void MapgenIndevParams::writeParams(Settings *settings) {
- settings->setFloat("mgv6_freq_desert", freq_desert);
- settings->setFloat("mgv6_freq_beach", freq_beach);
+ MapgenV6Params::writeParams(settings);
+
+ settings->setS16("mgindev_float_islands", float_islands);
settings->setNoiseIndevParams("mgindev_np_terrain_base", npindev_terrain_base);
settings->setNoiseIndevParams("mgindev_np_terrain_higher", npindev_terrain_higher);
settings->setNoiseIndevParams("mgindev_np_steepness", npindev_steepness);
- settings->setNoiseParams("mgv6_np_height_select", np_height_select);
- settings->setNoiseParams("mgv6_np_trees", np_trees);
settings->setNoiseIndevParams("mgindev_np_mud", npindev_mud);
- settings->setNoiseParams("mgv6_np_beach", np_beach);
settings->setNoiseIndevParams("mgindev_np_biome", npindev_biome);
- settings->setNoiseParams("mgv6_np_cave", np_cave);
settings->setNoiseIndevParams("mgindev_np_float_islands1", npindev_float_islands1);
settings->setNoiseIndevParams("mgindev_np_float_islands2", npindev_float_islands2);
settings->setNoiseIndevParams("mgindev_np_float_islands3", npindev_float_islands3);
}
void MapgenIndev::generateExperimental() {
- int float_islands = g_settings->getS16("mgindev_float_islands");
if (float_islands)
generateFloatIslands(float_islands);
}
void transformNoiseMapFarScale(float xx = 0, float yy = 0, float zz = 0);
};
-extern NoiseIndevParams nparams_indev_def;
-/*
-extern NoiseIndevParams nparams_indev_def_terrain_base;
-extern NoiseIndevParams nparams_indev_def_terrain_higher;
-extern NoiseIndevParams nparams_indev_def_steepness;
-//extern NoiseIndevParams nparams_indev_def_height_select;
-//extern NoiseIndevParams nparams_indev_def_trees;
-extern NoiseIndevParams nparams_indev_def_mud;
-//extern NoiseIndevParams nparams_indev_def_beach;
-extern NoiseIndevParams nparams_indev_def_biome;
-//extern NoiseIndevParams nparams_indev_def_cave;
-extern NoiseIndevParams nparams_indev_def_float_islands;
-*/
struct MapgenIndevParams : public MapgenV6Params {
+ s16 float_islands;
NoiseIndevParams npindev_terrain_base;
NoiseIndevParams npindev_terrain_higher;
NoiseIndevParams npindev_steepness;
- //NoiseParams *np_height_select;
- //NoiseParams *np_trees;
NoiseIndevParams npindev_mud;
- //NoiseParams *np_beach;
NoiseIndevParams npindev_biome;
- //NoiseParams *np_cave;
NoiseIndevParams npindev_float_islands1;
NoiseIndevParams npindev_float_islands2;
NoiseIndevParams npindev_float_islands3;
- MapgenIndevParams() {
- //freq_desert = 0.45;
- //freq_beach = 0.15;
- npindev_terrain_base = nparams_indev_def; //&nparams_indev_def_terrain_base;
- npindev_terrain_higher = nparams_indev_def; //&nparams_indev_def_terrain_higher;
- npindev_steepness = nparams_indev_def; //&nparams_indev_def_steepness;
- //np_height_select = &nparams_v6_def_height_select;
- //np_trees = &nparams_v6_def_trees;
- npindev_mud = nparams_indev_def; //&nparams_indev_def_mud;
- //np_beach = &nparams_v6_def_beach;
- npindev_biome = nparams_indev_def; //&nparams_indev_def_biome;
- //np_cave = &nparams_v6_def_cave;
- npindev_float_islands1 = nparams_indev_def; //&nparams_indev_def_float_islands;
- npindev_float_islands2 = nparams_indev_def; //&nparams_indev_def_float_islands;
- npindev_float_islands3 = nparams_indev_def; //&nparams_indev_def_float_islands;
+ MapgenIndevParams();
+ ~MapgenIndevParams() {}
- }
-
- bool readParams(Settings *settings);
+ void readParams(Settings *settings);
void writeParams(Settings *settings);
};
class MapgenIndev : public MapgenV6 {
- public:
+public:
NoiseIndev *noiseindev_terrain_base;
NoiseIndev *noiseindev_terrain_higher;
NoiseIndev *noiseindev_steepness;
- //NoiseIndev *noise_height_select;
- //NoiseIndev *noise_trees;
NoiseIndev *noiseindev_mud;
- //NoiseIndev *noise_beach;
NoiseIndev *noiseindev_biome;
- //NoiseIndevParams *np_cave;
NoiseIndev *noiseindev_float_islands1;
NoiseIndev *noiseindev_float_islands2;
NoiseIndev *noiseindev_float_islands3;
+ s16 float_islands;
- MapgenIndev(int mapgenid, MapgenIndevParams *params, EmergeManager *emerge);
+ MapgenIndev(int mapgenid, MapgenParams *params, EmergeManager *emerge);
~MapgenIndev();
void calculateNoise();
float baseTerrainLevelFromMap(int index);
float getMudAmount(int index);
void generateCaves(int max_stone_y);
- //void defineCave(Cave & cave, PseudoRandom ps, v3s16 node_min, bool large_cave);
void generateExperimental();
void generateFloatIslands(int min_y);
struct MapgenFactoryIndev : public MapgenFactoryV6 {
Mapgen *createMapgen(int mgid, MapgenParams *params, EmergeManager *emerge) {
- return new MapgenIndev(mgid, (MapgenIndevParams *)params, emerge);
+ return new MapgenIndev(mgid, params, emerge);
};
- MapgenParams *createMapgenParams() {
+ MapgenSpecificParams *createMapgenParams() {
return new MapgenIndevParams();
};
};
//////////////////////// Mapgen Math parameter read/write
-bool MapgenMathParams::readParams(Settings *settings) {
+void MapgenMathParams::readParams(Settings *settings) {
//params = settings->getJson("mg_math");
// can be counfigured from here.
std::string value = "{}";
}
if (params["generator"].empty()) params["generator"] = settings->get("mgmath_generator");
-
- return true;
}
///////////////////////////////////////////////////////////////////////////////
-MapgenMath::MapgenMath(int mapgenid, MapgenMathParams *params_, EmergeManager *emerge) : MapgenV7(mapgenid, params_, emerge) {
- mg_params = params_;
+MapgenMath::MapgenMath(int mapgenid, MapgenParams *params_, EmergeManager *emerge) : MapgenV7(mapgenid, params_, emerge) {
+ mg_params = (MapgenMathParams *)params_;
this->flags |= MG_NOLIGHT;
Json::Value & params = mg_params->params;
struct MapgenMathParams : public MapgenV7Params {
- MapgenMathParams() {
- }
+ MapgenMathParams() {}
+ ~MapgenMathParams() {}
Json::Value params;
- bool readParams(Settings *settings);
+ void readParams(Settings *settings);
void writeParams(Settings *settings);
};
public:
MapgenMathParams * mg_params;
- MapgenMath(int mapgenid, MapgenMathParams *mg_params, EmergeManager *emerge);
+ MapgenMath(int mapgenid, MapgenParams *mg_params, EmergeManager *emerge);
~MapgenMath();
int generateTerrain();
struct MapgenFactoryMath : public MapgenFactory {
Mapgen *createMapgen(int mgid, MapgenParams *params, EmergeManager *emerge) {
- return new MapgenMath(mgid, (MapgenMathParams *)params, emerge);
+ return new MapgenMath(mgid, params, emerge);
};
- MapgenParams *createMapgenParams() {
+ MapgenSpecificParams *createMapgenParams() {
return new MapgenMathParams();
};
};
//////////////////////// Mapgen Singlenode parameter read/write
-bool MapgenSinglenodeParams::readParams(Settings *settings) {
- return true;
+void MapgenSinglenodeParams::readParams(Settings *settings) {
}
///////////////////////////////////////////////////////////////////////////////
-MapgenSinglenode::MapgenSinglenode(int mapgenid, MapgenSinglenodeParams *params) {
+MapgenSinglenode::MapgenSinglenode(int mapgenid, MapgenParams *params) {
flags = params->flags;
}
#include "mapgen.h"
-struct MapgenSinglenodeParams : public MapgenParams {
+struct MapgenSinglenodeParams : public MapgenSpecificParams {
MapgenSinglenodeParams() {}
~MapgenSinglenodeParams() {}
- bool readParams(Settings *settings);
+ void readParams(Settings *settings);
void writeParams(Settings *settings);
};
public:
u32 flags;
- MapgenSinglenode(int mapgenid, MapgenSinglenodeParams *params);
+ MapgenSinglenode(int mapgenid, MapgenParams *params);
~MapgenSinglenode();
void makeChunk(BlockMakeData *data);
struct MapgenFactorySinglenode : public MapgenFactory {
Mapgen *createMapgen(int mgid, MapgenParams *params, EmergeManager *emerge) {
- return new MapgenSinglenode(mgid, (MapgenSinglenodeParams *)params);
+ return new MapgenSinglenode(mgid, params);
};
- MapgenParams *createMapgenParams() {
+ MapgenSpecificParams *createMapgenParams() {
return new MapgenSinglenodeParams();
};
};
#include "treegen.h"
#include "mapgen_v6.h"
-/////////////////// Mapgen V6 perlin noise default values
-NoiseParams nparams_v6_def_terrain_base =
- {-AVERAGE_MUD_AMOUNT, 20.0, v3f(250.0, 250.0, 250.0), 82341, 5, 0.6};
-NoiseParams nparams_v6_def_terrain_higher =
- {20.0, 16.0, v3f(500.0, 500.0, 500.0), 85039, 5, 0.6};
-NoiseParams nparams_v6_def_steepness =
- {0.85, 0.5, v3f(125.0, 125.0, 125.0), -932, 5, 0.7};
-NoiseParams nparams_v6_def_height_select =
- {0.5, 1.0, v3f(250.0, 250.0, 250.0), 4213, 5, 0.69};
-NoiseParams nparams_v6_def_mud =
- {AVERAGE_MUD_AMOUNT, 2.0, v3f(200.0, 200.0, 200.0), 91013, 3, 0.55};
-NoiseParams nparams_v6_def_beach =
- {0.0, 1.0, v3f(250.0, 250.0, 250.0), 59420, 3, 0.50};
-NoiseParams nparams_v6_def_biome =
- {0.0, 1.0, v3f(250.0, 250.0, 250.0), 9130, 3, 0.50};
-NoiseParams nparams_v6_def_cave =
- {6.0, 6.0, v3f(250.0, 250.0, 250.0), 34329, 3, 0.50};
-NoiseParams nparams_v6_def_humidity =
- {0.5, 0.5, v3f(500.0, 500.0, 500.0), 72384, 4, 0.66};
-NoiseParams nparams_v6_def_trees =
- {0.0, 1.0, v3f(125.0, 125.0, 125.0), 2, 4, 0.66};
-NoiseParams nparams_v6_def_apple_trees =
- {0.0, 1.0, v3f(100.0, 100.0, 100.0), 342902, 3, 0.45};
-
+FlagDesc flagdesc_mapgen_v6[] = {
+ {"v6_jungles", MGV6_JUNGLES},
+ {"v6_biome_blend", MGV6_BIOME_BLEND},
+ {"v6_nomudflow", MGV6_NOMUDFLOW},
+ {NULL, 0}
+};
///////////////////////////////////////////////////////////////////////////////
-MapgenV6::MapgenV6(int mapgenid, MapgenV6Params *params, EmergeManager *emerge) {
+MapgenV6::MapgenV6(int mapgenid, MapgenParams *params, EmergeManager *emerge) {
this->generating = false;
this->id = mapgenid;
this->emerge = emerge;
- this->seed = (int)params->seed;
+ this->seed = (int)params->seed;
this->water_level = params->water_level;
- this->flags = params->flags;
- this->csize = v3s16(1, 1, 1) * params->chunksize * MAP_BLOCKSIZE;
- this->gennotify = emerge->gennotify;
-
- this->freq_desert = params->freq_desert;
- this->freq_beach = params->freq_beach;
+ this->flags = params->flags;
+ this->csize = v3s16(1, 1, 1) * params->chunksize * MAP_BLOCKSIZE;
+ this->gennotify = emerge->gennotify;
this->ystride = csize.X; //////fix this
- np_cave = ¶ms->np_cave;
- np_humidity = ¶ms->np_humidity;
- np_trees = ¶ms->np_trees;
- np_apple_trees = ¶ms->np_apple_trees;
-
- 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, csize.Y);
+ MapgenV6Params *sp = (MapgenV6Params *)params->sparams;
+
+ this->spflags = sp->spflags;
+ this->freq_desert = sp->freq_desert;
+ this->freq_beach = sp->freq_beach;
+
+ np_cave = &sp->np_cave;
+ np_humidity = &sp->np_humidity;
+ np_trees = &sp->np_trees;
+ np_apple_trees = &sp->np_apple_trees;
+
+ 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, csize.X, csize.Y);
}
}
+MapgenV6Params::MapgenV6Params() {
+ spflags = MGV6_BIOME_BLEND;
+ freq_desert = 0.45;
+ freq_beach = 0.15;
+
+ np_terrain_base = NoiseParams(-4, 20.0, v3f(250.0, 250.0, 250.0), 82341, 5, 0.6);
+ np_terrain_higher = NoiseParams(20, 16.0, v3f(500.0, 500.0, 500.0), 85039, 5, 0.6);
+ np_steepness = NoiseParams(0.85,0.5, v3f(125.0, 125.0, 125.0), -932, 5, 0.7);
+ np_height_select = NoiseParams(0.5, 1.0, v3f(250.0, 250.0, 250.0), 4213, 5, 0.69);
+ np_mud = NoiseParams(4, 2.0, v3f(200.0, 200.0, 200.0), 91013, 3, 0.55);
+ np_beach = NoiseParams(0, 1.0, v3f(250.0, 250.0, 250.0), 59420, 3, 0.50);
+ np_biome = NoiseParams(0, 1.0, v3f(250.0, 250.0, 250.0), 9130, 3, 0.50);
+ np_cave = NoiseParams(6, 6.0, v3f(250.0, 250.0, 250.0), 34329, 3, 0.50);
+ np_humidity = NoiseParams(0.5, 0.5, v3f(500.0, 500.0, 500.0), 72384, 4, 0.66);
+ np_trees = NoiseParams(0, 1.0, v3f(125.0, 125.0, 125.0), 2, 4, 0.66);
+ np_apple_trees = NoiseParams(0, 1.0, v3f(100.0, 100.0, 100.0), 342902, 3, 0.45);
+}
+
+
+void MapgenV6Params::readParams(Settings *settings) {
+ settings->tryGetFlagStr("mgv6_spflags", spflags, flagdesc_mapgen_v6);
+ settings->tryGetFloat("mgv6_freq_desert", freq_desert);
+ settings->tryGetFloat("mgv6_freq_beach", freq_beach);
+
+ settings->getNoiseParams("mgv6_np_terrain_base", np_terrain_base);
+ settings->getNoiseParams("mgv6_np_terrain_higher", np_terrain_higher);
+ settings->getNoiseParams("mgv6_np_steepness", np_steepness);
+ settings->getNoiseParams("mgv6_np_height_select", np_height_select);
+ settings->getNoiseParams("mgv6_np_mud", np_mud);
+ settings->getNoiseParams("mgv6_np_beach", np_beach);
+ settings->getNoiseParams("mgv6_np_biome", np_biome);
+ settings->getNoiseParams("mgv6_np_cave", np_cave);
+ settings->getNoiseParams("mgv6_np_humidity", np_humidity);
+ settings->getNoiseParams("mgv6_np_trees", np_trees);
+ settings->getNoiseParams("mgv6_np_apple_trees", np_apple_trees);
+}
+
+
+void MapgenV6Params::writeParams(Settings *settings) {
+ settings->setFlagStr("mgv6_spflags", spflags, flagdesc_mapgen_v6);
+ settings->setFloat("mgv6_freq_desert", freq_desert);
+ settings->setFloat("mgv6_freq_beach", freq_beach);
+
+ settings->setNoiseParams("mgv6_np_terrain_base", np_terrain_base);
+ settings->setNoiseParams("mgv6_np_terrain_higher", np_terrain_higher);
+ settings->setNoiseParams("mgv6_np_steepness", np_steepness);
+ settings->setNoiseParams("mgv6_np_height_select", np_height_select);
+ settings->setNoiseParams("mgv6_np_mud", np_mud);
+ settings->setNoiseParams("mgv6_np_beach", np_beach);
+ settings->setNoiseParams("mgv6_np_biome", np_biome);
+ settings->setNoiseParams("mgv6_np_cave", np_cave);
+ settings->setNoiseParams("mgv6_np_humidity", np_humidity);
+ settings->setNoiseParams("mgv6_np_trees", np_trees);
+ settings->setNoiseParams("mgv6_np_apple_trees", np_apple_trees);
+}
+
+
//////////////////////// Some helper functions for the map generator
if (d > freq_desert)
return BT_DESERT;
- if ((flags & MGV6_BIOME_BLEND) &&
+ if ((spflags & MGV6_BIOME_BLEND) &&
(d > freq_desert - 0.10) &&
((noise2d(p.X, p.Y, seed) + 1.0) > (freq_desert - d) * 20.0))
return BT_DESERT;
addDirtGravelBlobs();
// Flow mud away from steep edges
- if (!(flags & MGV6_NOMUDFLOW))
+ if (!(spflags & MGV6_NOMUDFLOW))
flowMud(mudflow_minpos, mudflow_maxpos);
}
float humidity;
bool is_jungle = false;
- if (flags & MGV6_JUNGLES) {
+ if (spflags & MGV6_JUNGLES) {
humidity = getHumidity(p2d_center);
if (humidity > 0.75) {
is_jungle = true;
#define AVERAGE_MUD_AMOUNT 4
+/////////////////// Mapgen V6 flags
+#define MGV6_JUNGLES 0x01
+#define MGV6_BIOME_BLEND 0x02
+#define MGV6_NOMUDFLOW 0x04
+
+
+extern FlagDesc flagdesc_mapgen_v6[];
+
+
enum BiomeType
{
BT_NORMAL,
BT_DESERT
};
-extern NoiseParams nparams_v6_def_terrain_base;
-extern NoiseParams nparams_v6_def_terrain_higher;
-extern NoiseParams nparams_v6_def_steepness;
-extern NoiseParams nparams_v6_def_height_select;
-extern NoiseParams nparams_v6_def_mud;
-extern NoiseParams nparams_v6_def_beach;
-extern NoiseParams nparams_v6_def_biome;
-extern NoiseParams nparams_v6_def_cave;
-extern NoiseParams nparams_v6_def_humidity;
-extern NoiseParams nparams_v6_def_trees;
-extern NoiseParams nparams_v6_def_apple_trees;
-
-struct MapgenV6Params : public MapgenParams {
+struct MapgenV6Params : public MapgenSpecificParams {
+ u32 spflags;
float freq_desert;
float freq_beach;
NoiseParams np_terrain_base;
NoiseParams np_trees;
NoiseParams np_apple_trees;
- MapgenV6Params() {
- freq_desert = 0.45;
- freq_beach = 0.15;
- np_terrain_base = nparams_v6_def_terrain_base;
- np_terrain_higher = nparams_v6_def_terrain_higher;
- np_steepness = nparams_v6_def_steepness;
- np_height_select = nparams_v6_def_height_select;
- np_mud = nparams_v6_def_mud;
- np_beach = nparams_v6_def_beach;
- np_biome = nparams_v6_def_biome;
- np_cave = nparams_v6_def_cave;
- np_humidity = nparams_v6_def_humidity;
- np_trees = nparams_v6_def_trees;
- np_apple_trees = nparams_v6_def_apple_trees;
- }
-
+ MapgenV6Params();
~MapgenV6Params() {}
- bool readParams(Settings *settings);
+ void readParams(Settings *settings);
void writeParams(Settings *settings);
};
int ystride;
u32 flags;
+ u32 spflags;
u32 blockseed;
v3s16 node_min;
content_t c_stair_cobble;
content_t c_stair_sandstone;
- MapgenV6(int mapgenid, MapgenV6Params *params, EmergeManager *emerge);
+ MapgenV6(int mapgenid, MapgenParams *params, EmergeManager *emerge);
~MapgenV6();
void makeChunk(BlockMakeData *data);
struct MapgenFactoryV6 : public MapgenFactory {
Mapgen *createMapgen(int mgid, MapgenParams *params, EmergeManager *emerge) {
- return new MapgenV6(mgid, (MapgenV6Params *)params, emerge);
+ return new MapgenV6(mgid, params, emerge);
};
- MapgenParams *createMapgenParams() {
+ MapgenSpecificParams *createMapgenParams() {
return new MapgenV6Params();
};
};
#include "mapgen_v7.h"
-/////////////////// Mapgen V7 perlin noise default values
-NoiseParams nparams_v7_def_terrain_base =
- {4, 70, v3f(300, 300, 300), 82341, 6, 0.7};
-NoiseParams nparams_v7_def_terrain_alt =
- {4, 25, v3f(600, 600, 600), 5934, 5, 0.6};
-NoiseParams nparams_v7_def_terrain_persist =
- {0.6, 0.1, v3f(500, 500, 500), 539, 3, 0.6};
-NoiseParams nparams_v7_def_height_select =
- {-0.5, 1, v3f(250, 250, 250), 4213, 5, 0.69};
-
-NoiseParams nparams_v7_def_filler_depth =
- {0, 1.2, v3f(150, 150, 150), 261, 4, 0.7};
-
-NoiseParams nparams_v7_def_mount_height =
- {100, 30, v3f(500, 500, 500), 72449, 4, 0.6};
-NoiseParams nparams_v7_def_ridge_uwater =
- {0, 1, v3f(500, 500, 500), 85039, 4, 0.6};
-NoiseParams nparams_v7_def_mountain =
- {0, 1, v3f(250, 350, 250), 5333, 5, 0.68};
-NoiseParams nparams_v7_def_ridge =
- {0, 1, v3f(100, 100, 100), 6467, 4, 0.75};
-
+FlagDesc flagdesc_mapgen_v7[] = {
+ {"v7_mountains", MGV7_MOUNTAINS},
+ {"v7_ridges", MGV7_RIDGES},
+ {NULL, 0}
+};
///////////////////////////////////////////////////////////////////////////////
-MapgenV7::MapgenV7(int mapgenid, MapgenV7Params *params, EmergeManager *emerge) {
+MapgenV7::MapgenV7(int mapgenid, MapgenParams *params, EmergeManager *emerge) {
this->generating = false;
this->id = mapgenid;
this->emerge = emerge;
this->heightmap = new s16[csize.X * csize.Z];
this->ridge_heightmap = new s16[csize.X * csize.Z];
+ MapgenV7Params *sp = (MapgenV7Params *)params->sparams;
+
// Terrain noise
- 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);
-
+ 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);
+
// 3d terrain noise
- noise_mountain = new Noise(¶ms->np_mountain, seed, csize.X, csize.Y, csize.Z);
- noise_ridge = new Noise(¶ms->np_ridge, seed, csize.X, csize.Y, csize.Z);
-
+ noise_mountain = new Noise(&sp->np_mountain, seed, csize.X, csize.Y, csize.Z);
+ noise_ridge = new Noise(&sp->np_ridge, seed, csize.X, csize.Y, csize.Z);
+
// Biome noise
noise_heat = new Noise(bmgr->np_heat, seed, csize.X, csize.Z);
noise_humidity = new Noise(bmgr->np_humidity, seed, csize.X, csize.Z);
}
+MapgenV7Params::MapgenV7Params() {
+ spflags = MGV7_MOUNTAINS | MGV7_RIDGES;
+
+ np_terrain_base = NoiseParams(4, 70, v3f(300, 300, 300), 82341, 6, 0.7);
+ np_terrain_alt = NoiseParams(4, 25, v3f(600, 600, 600), 5934, 5, 0.6);
+ np_terrain_persist = NoiseParams(0.6, 0.1, v3f(500, 500, 500), 539, 3, 0.6);
+ np_height_select = NoiseParams(-0.5, 1, v3f(250, 250, 250), 4213, 5, 0.69);
+ np_filler_depth = NoiseParams(0, 1.2, v3f(150, 150, 150), 261, 4, 0.7);
+ np_mount_height = NoiseParams(100, 30, v3f(500, 500, 500), 72449, 4, 0.6);
+ np_ridge_uwater = NoiseParams(0, 1, v3f(500, 500, 500), 85039, 4, 0.6);
+ np_mountain = NoiseParams(0, 1, v3f(250, 350, 250), 5333, 5, 0.68);
+ np_ridge = NoiseParams(0, 1, v3f(100, 100, 100), 6467, 4, 0.75);
+}
+
+
+void MapgenV7Params::readParams(Settings *settings) {
+ settings->tryGetFlagStr("mgv7_spflags", spflags, flagdesc_mapgen_v7);
+
+ settings->getNoiseParams("mgv7_np_terrain_base", np_terrain_base);
+ settings->getNoiseParams("mgv7_np_terrain_alt", np_terrain_alt);
+ settings->getNoiseParams("mgv7_np_terrain_persist", np_terrain_persist);
+ settings->getNoiseParams("mgv7_np_height_select", np_height_select);
+ settings->getNoiseParams("mgv7_np_filler_depth", np_filler_depth);
+ settings->getNoiseParams("mgv7_np_mount_height", np_mount_height);
+ settings->getNoiseParams("mgv7_np_ridge_uwater", np_ridge_uwater);
+ settings->getNoiseParams("mgv7_np_mountain", np_mountain);
+ settings->getNoiseParams("mgv7_np_ridge", np_ridge);
+}
+
+
+void MapgenV7Params::writeParams(Settings *settings) {
+ settings->setFlagStr("mgv7_spflags", spflags, flagdesc_mapgen_v7);
+
+ settings->setNoiseParams("mgv7_np_terrain_base", np_terrain_base);
+ settings->setNoiseParams("mgv7_np_terrain_alt", np_terrain_alt);
+ settings->setNoiseParams("mgv7_np_terrain_persist", np_terrain_persist);
+ settings->setNoiseParams("mgv7_np_height_select", np_height_select);
+ settings->setNoiseParams("mgv7_np_filler_depth", np_filler_depth);
+ settings->setNoiseParams("mgv7_np_mount_height", np_mount_height);
+ settings->setNoiseParams("mgv7_np_ridge_uwater", np_ridge_uwater);
+ settings->setNoiseParams("mgv7_np_mountain", np_mountain);
+ settings->setNoiseParams("mgv7_np_ridge", np_ridge);
+}
+
+
+///////////////////////////////////////
+
+
int MapgenV7::getGroundLevelAtPoint(v2s16 p) {
// Base terrain calculation
s16 y = baseTerrainLevelAtPoint(p.X, p.Y);
noise_filler_depth->perlinMap2D(x, z);
- if (flags & MGV7_MOUNTAINS) {
+ if (spflags & MGV7_MOUNTAINS) {
noise_mountain->perlinMap3D(x, y, z);
noise_mount_height->perlinMap2D(x, z);
noise_mount_height->transformNoiseMap();
}
- if (flags & MGV7_RIDGES) {
+ if (spflags & MGV7_RIDGES) {
noise_ridge->perlinMap3D(x, y, z);
noise_ridge_uwater->perlinMap2D(x, z);
}
int MapgenV7::generateTerrain() {
int ymax = generateBaseTerrain();
- if (flags & MGV7_MOUNTAINS)
+ if (spflags & MGV7_MOUNTAINS)
generateMountainTerrain();
- if (flags & MGV7_RIDGES)
+ if (spflags & MGV7_RIDGES)
generateRidgeTerrain();
return ymax;
#endif
-#include "mapgen_v6.h"
+NoiseParams nparams_v7_def_cave(6, 6.0, v3f(250.0, 250.0, 250.0), 34329, 3, 0.50);
+
void MapgenV7::generateCaves(int max_stone_y) {
PseudoRandom ps(blockseed + 21343);
int volume_nodes = (node_max.X - node_min.X + 1) *
(node_max.Y - node_min.Y + 1) *
(node_max.Z - node_min.Z + 1);
- float cave_amount = NoisePerlin2D(&nparams_v6_def_cave,
+ float cave_amount = NoisePerlin2D(&nparams_v7_def_cave,
node_min.X, node_min.Y, seed);
u32 caves_count = MYMAX(0.0, cave_amount) * volume_nodes / 250000;
for (u32 i = 0; i < bruises_count; i++) {
CaveV7 cave(this, &ps, true);
cave.makeCave(node_min, node_max, max_stone_y);
- }
+ }
}
#include "mapgen.h"
-extern NoiseParams nparams_v7_def_terrain_base;
-extern NoiseParams nparams_v7_def_terrain_alt;
-extern NoiseParams nparams_v7_def_terrain_persist;
-extern NoiseParams nparams_v7_def_height_select;
-extern NoiseParams nparams_v7_def_filler_depth;
-extern NoiseParams nparams_v7_def_mount_height;
-extern NoiseParams nparams_v7_def_ridge_uwater;
-extern NoiseParams nparams_v7_def_mountain;
-extern NoiseParams nparams_v7_def_ridge;
-
-struct MapgenV7Params : public MapgenParams {
+/////////////////// Mapgen V7 flags
+#define MGV7_MOUNTAINS 0x01
+#define MGV7_RIDGES 0x02
+
+
+extern FlagDesc flagdesc_mapgen_v7[];
+
+
+struct MapgenV7Params : public MapgenSpecificParams {
+ u32 spflags;
NoiseParams np_terrain_base;
NoiseParams np_terrain_alt;
NoiseParams np_terrain_persist;
NoiseParams np_mountain;
NoiseParams np_ridge;
- MapgenV7Params() {
- np_terrain_base = nparams_v7_def_terrain_base;
- np_terrain_alt = nparams_v7_def_terrain_alt;
- np_terrain_persist = nparams_v7_def_terrain_persist;
- np_height_select = nparams_v7_def_height_select;
- np_filler_depth = nparams_v7_def_filler_depth;
- np_mount_height = nparams_v7_def_mount_height;
- np_ridge_uwater = nparams_v7_def_ridge_uwater;
- np_mountain = nparams_v7_def_mountain;
- np_ridge = nparams_v7_def_ridge;
- }
-
+ MapgenV7Params();
~MapgenV7Params() {}
- bool readParams(Settings *settings);
+ void readParams(Settings *settings);
void writeParams(Settings *settings);
};
int ystride;
int zstride;
u32 flags;
+ u32 spflags;
u32 blockseed;
v3s16 node_min;
content_t c_desert_sand;
content_t c_desert_stone;
- MapgenV7(int mapgenid, MapgenV7Params *params, EmergeManager *emerge);
+ MapgenV7(int mapgenid, MapgenParams *params, EmergeManager *emerge);
~MapgenV7();
virtual void makeChunk(BlockMakeData *data);
struct MapgenFactoryV7 : public MapgenFactory {
Mapgen *createMapgen(int mgid, MapgenParams *params, EmergeManager *emerge) {
- return new MapgenV7(mgid, (MapgenV7Params *)params, emerge);
+ return new MapgenV7(mgid, params, emerge);
};
- MapgenParams *createMapgenParams() {
+ MapgenSpecificParams *createMapgenParams() {
return new MapgenV7Params();
};
};
int seed;
int octaves;
float persist;
+
+ NoiseParams() {}
+
+ NoiseParams(float offset_, float scale_, v3f spread_,
+ int seed_, int octaves_, float persist_)
+ {
+ offset = offset_;
+ scale = scale_;
+ spread = spread_;
+ seed = seed_;
+ octaves = octaves_;
+ persist = persist_;
+ }
};
return 1; }
case MGOBJ_HEATMAP: { // Mapgen V7 specific objects
case MGOBJ_HUMIDMAP:
- if (strcmp(emerge->params->mg_name.c_str(), "v7"))
+ if (strcmp(emerge->params.mg_name.c_str(), "v7"))
return 0;
MapgenV7 *mgv7 = (MapgenV7 *)mg;
return 0;
EmergeManager *emerge = getServer(L)->getEmergeManager();
- if (!emerge || emerge->mapgen.size())
- return 0;
+ ASSERT(emerge);
- MapgenParams *oparams = new MapgenParams;
- u32 paramsmodified = 0;
- u32 flagmask = 0;
+ std::string flagstr;
lua_getfield(L, 1, "mgname");
if (lua_isstring(L, -1)) {
- oparams->mg_name = std::string(lua_tostring(L, -1));
- paramsmodified |= MGPARAMS_SET_MGNAME;
+ emerge->params.mg_name = std::string(lua_tostring(L, -1));
+ delete emerge->params.sparams;
+ emerge->params.sparams = NULL;
}
lua_getfield(L, 1, "seed");
- if (lua_isnumber(L, -1)) {
- oparams->seed = lua_tointeger(L, -1);
- paramsmodified |= MGPARAMS_SET_SEED;
- }
+ if (lua_isnumber(L, -1))
+ emerge->params.seed = lua_tointeger(L, -1);
lua_getfield(L, 1, "water_level");
- if (lua_isnumber(L, -1)) {
- oparams->water_level = lua_tointeger(L, -1);
- paramsmodified |= MGPARAMS_SET_WATER_LEVEL;
+ if (lua_isnumber(L, -1))
+ emerge->params.water_level = lua_tointeger(L, -1);
+
+ lua_getfield(L, 1, "flagmask");
+ if (lua_isstring(L, -1)) {
+ flagstr = lua_tostring(L, -1);
+ emerge->params.flags &= ~readFlagString(flagstr, flagdesc_mapgen);
}
lua_getfield(L, 1, "flags");
if (lua_isstring(L, -1)) {
- std::string flagstr = std::string(lua_tostring(L, -1));
- oparams->flags = readFlagString(flagstr, flagdesc_mapgen);
- paramsmodified |= MGPARAMS_SET_FLAGS;
-
- lua_getfield(L, 1, "flagmask");
- if (lua_isstring(L, -1)) {
- flagstr = std::string(lua_tostring(L, -1));
- flagmask = readFlagString(flagstr, flagdesc_mapgen);
- }
+ flagstr = lua_tostring(L, -1);
+ emerge->params.flags |= readFlagString(flagstr, flagdesc_mapgen);
}
- delete emerge->luaoverride_params;
-
- emerge->luaoverride_params = oparams;
- emerge->luaoverride_params_modified = paramsmodified;
- emerge->luaoverride_flagmask = flagmask;
-
return 0;
}
Mapgen mg;
mg.vm = vm;
mg.ndef = ndef;
- mg.water_level = emerge->params->water_level;
+ mg.water_level = emerge->params.water_level;
mg.calcLighting(p1, p2);
m_clients.setEnv(m_env);
// Run some callbacks after the MG params have been set up but before activation
- MapgenParams *mgparams = servermap->getMapgenParams();
- m_script->environment_OnMapgenInit(mgparams);
+ m_script->environment_OnMapgenInit(&m_emerge->params);
// Initialize mapgens
- m_emerge->initMapgens(mgparams);
- servermap->setMapgenParams(m_emerge->params);
+ m_emerge->initMapgens();
// Give environment reference to scripting api
m_script->initializeEnvironment(m_env);
#endif
#if 1
- s16 water_level = map.m_mgparams->water_level;
+ s16 water_level = map.getWaterLevel();
// Try to find a good place a few times
for(s32 i=0; i<1000; i++)
projects / oweals / minetest.git / commitdiff