Clean up EmergeManager, do initial work on Mapgen configuration

This commit is contained in:
kwolekr 2012-12-26 03:15:16 -05:00 committed by Perttu Ahola
parent d5029958b9
commit cde3d38766
6 changed files with 328 additions and 150 deletions

@ -2019,8 +2019,8 @@ ServerMap::ServerMap(std::string savedir, IGameDef *gamedef, EmergeManager *emer
{ {
m_seed = g_settings->getU64("fixed_map_seed"); m_seed = g_settings->getU64("fixed_map_seed");
} }
emerge->seed = m_seed; //emerge->params.seed = m_seed;
emerge->water_level = g_settings->getS16("default_water_level"); //emerge->params.water_level = g_settings->getS16("default_water_level");
//mapgen version //mapgen version
//chunksize //chunksize
//noiseparams //noiseparams
@ -3078,8 +3078,31 @@ void ServerMap::saveMapMeta()
} }
Settings params; Settings params;
params.setU64("seed", m_seed);
params.setS16("water_level", m_emerge->water_level); params.setS16("mg_version", m_emerge->mg_version);
params.setU64("seed", m_emerge->params->seed);
params.setS16("water_level", m_emerge->params->water_level);
params.setS16("chunksize", m_emerge->params->chunksize);
params.setS32("flags", m_emerge->params->flags);
switch (m_emerge->mg_version) {
case 6:
{
MapgenV6Params *v6params = m_emerge->params;
params.setFloat("freq_desert", v6params->freq_desert);
params.setFloat("freq_beach", v6params->freq_beach);
break;
}
case 7:
{
MapgenV7Params *v7params = m_emerge->params;
break;
}
default:
; //complain here
}
params.writeLines(os); params.writeLines(os);
@ -3119,10 +3142,36 @@ void ServerMap::loadMapMeta()
params.parseConfigLine(line); params.parseConfigLine(line);
} }
m_seed = params.getU64("seed"); m_emerge->mg_version = params.getS16("mg_version");
m_emerge->seed = m_seed; m_emerge->setMapgenParams();
m_emerge->water_level = params.getS16("water_level");
//m_emerge->np = ; m_emerge->params->seed = params.getU64("seed");
m_emerge->params->water_level = params.getS16("water_level");
m_emerge->params->chunksize = params.getS16("chunksize");
m_emerge->params->flags = params.getS32("flags");
m_seed = m_emerge->params->seed;
switch (m_emerge->mg_version) {
case 6:
{
MapgenV6Params *v6params = m_emerge->params;
v6params->freq_desert = params.getFloat("freq_desert");
v6params->freq_beach = params.getFloat("freq_beach");
break;
}
case 7:
{
MapgenV7Params *v6params = m_emerge->params;
break;
}
default:
; //complain here
}
verbosestream<<"ServerMap::loadMapMeta(): "<<"seed="<<m_seed<<std::endl; verbosestream<<"ServerMap::loadMapMeta(): "<<"seed="<<m_seed<<std::endl;
} }

@ -34,57 +34,45 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "main.h" // For g_profiler #include "main.h" // For g_profiler
#include "treegen.h" #include "treegen.h"
NoiseParams nparams_mtdefault =
{10.0, 12.0, v3f(350., 350., 350.), 82341, 5, 0.6}; //terrain
NoiseParams nparams_def_bgroup = /*
{0.5, 1/(2*1.6), v3f(350., 350., 350.), 5923, 2, 0.60}; //0 to 1 MapgenV7Params mg_def_params_v7 = {
NoiseParams nparams_def_heat = 0,
{25.0, 50.0, v3f(500., 500., 500.), 35293, 1, 0.00}; //-25 to 75 1,
NoiseParams nparams_def_humidity = 5,
{50, 100/(2*1.6), v3f(750., 750., 750.), 12094, 2, 0.60}; //0 to 100 MG_TREES | MG_CAVES | MG_DUNGEONS,
&nparams_v7_def_terrain,
&nparams_v7_def_bgroup,
&nparams_v7_def_heat,
&nparams_v7_def_humidity
};*/
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
/*
Mapgen::Mapgen(BiomeDefManager *biomedef) {
Mapgen(0, 0, biomedef);
}*/
MapgenV7::MapgenV7(BiomeDefManager *biomedef, int mapgenid, MapgenV7Params *params) {
MapgenV7::MapgenV7(BiomeDefManager *biomedef, int mapgenid, u64 seed) {
init(biomedef, mapgenid, seed,
&nparams_mtdefault, &nparams_def_bgroup,
&nparams_def_heat, &nparams_def_humidity);
}
MapgenV7::MapgenV7(BiomeDefManager *biomedef, int mapgenid, u64 seed,
NoiseParams *np_terrain, NoiseParams *np_bgroup,
NoiseParams *np_heat, NoiseParams *np_humidity) {
init(biomedef, mapgenid, seed,
np_terrain, np_bgroup, np_heat, np_humidity);
}
void MapgenV7::init(BiomeDefManager *biomedef, int mapgenid, u64 seed,
NoiseParams *np_terrain, NoiseParams *np_bgroup,
NoiseParams *np_heat, NoiseParams *np_humidity) {
this->generating = false; this->generating = false;
this->id = mapgenid; this->id = mapgenid;
this->seed = (int)seed;
this->biomedef = biomedef; this->biomedef = biomedef;
this->csize = v3s16(5, 5, 5) * MAP_BLOCKSIZE; /////////////////get this from config!
this->water_level = g_settings->getS16("default_water_level"); ////fix this!
this->ystride = csize.X;
this->seed = params->seed;
this->csize = v3s16(1, 1, 1) * params->chunksize * MAP_BLOCKSIZE; /////////////////get this from config!
this->water_level = params->water_level;
//g_settings->getS16("default_water_level");
/*
this->np_terrain = np_terrain; this->np_terrain = np_terrain;
this->np_bgroup = np_bgroup; this->np_bgroup = np_bgroup;
this->np_heat = np_heat; this->np_heat = np_heat;
this->np_humidity = np_humidity; this->np_humidity = np_humidity;
noise_terrain = new Noise(np_terrain, seed, csize.X, csize.Y); */
noise_bgroup = new Noise(np_bgroup, seed, csize.X, csize.Y); noise_terrain = new Noise(params->np_terrain, seed, csize.X, csize.Y);
noise_heat = new Noise(np_heat, seed, csize.X, csize.Y); noise_bgroup = new Noise(params->np_bgroup, seed, csize.X, csize.Y);
noise_humidity = new Noise(np_humidity, seed, csize.X, csize.Y); noise_heat = new Noise(params->np_heat, seed, csize.X, csize.Y);
noise_humidity = new Noise(params->np_humidity, seed, csize.X, csize.Y);
this->ndef = biomedef->ndef; this->ndef = biomedef->ndef;
n_air = MapNode(ndef->getId("mapgen_air")); n_air = MapNode(ndef->getId("mapgen_air"));
@ -122,9 +110,6 @@ void MapgenV7::makeChunk(BlockMakeData *data) {
this->ystride = em.X; this->ystride = em.X;
this->zstride = em.Y * em.X; this->zstride = em.Y * em.X;
if (node_max.X - node_min.X != 80)
printf("uhoh, diff = %d, ystride = %d\n", node_max.X - node_min.X, ystride);
node_min = (data->blockpos_min) * MAP_BLOCKSIZE; node_min = (data->blockpos_min) * MAP_BLOCKSIZE;
node_max = (data->blockpos_max + v3s16(1, 1, 1)) * MAP_BLOCKSIZE - v3s16(1, 1, 1); node_max = (data->blockpos_max + v3s16(1, 1, 1)) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
v3s16 full_node_min = (data->blockpos_min - 1) * MAP_BLOCKSIZE; v3s16 full_node_min = (data->blockpos_min - 1) * MAP_BLOCKSIZE;
@ -166,18 +151,18 @@ void MapgenV7::makeChunk(BlockMakeData *data) {
} }
void MapgenV7::updateLiquid(v3s16 node_min, v3s16 node_max) { void MapgenV7::updateLiquid(v3s16 nmin, v3s16 nmax) {
bool isliquid, wasliquid; bool isliquid, wasliquid;
u32 i; u32 i;
for (s16 z = node_min.Z; z <= node_max.Z; z++) { for (s16 z = nmin.Z; z <= nmax.Z; z++) {
for (s16 x = node_min.X; x <= node_max.X; x++) { for (s16 x = nmin.X; x <= nmax.X; x++) {
v2s16 p2d(x, z); v2s16 p2d(x, z);
wasliquid = true; wasliquid = true;
v3s16 em = vmanip->m_area.getExtent(); v3s16 em = vmanip->m_area.getExtent();
i = vmanip->m_area.index(v3s16(p2d.X, node_max.Y, p2d.Y)); i = vmanip->m_area.index(v3s16(p2d.X, nmax.Y, p2d.Y));
for (s16 y = node_max.Y; y >= node_min.Y; y--) { for (s16 y = nmax.Y; y >= nmin.Y; y--) {
isliquid = ndef->get(vmanip->m_data[i]).isLiquid(); isliquid = ndef->get(vmanip->m_data[i]).isLiquid();
//there was a change between liquid and nonliquid, add to queue //there was a change between liquid and nonliquid, add to queue
if (isliquid != wasliquid) if (isliquid != wasliquid)
@ -191,12 +176,12 @@ void MapgenV7::updateLiquid(v3s16 node_min, v3s16 node_max) {
} }
void MapgenV7::updateLighting(v3s16 node_min, v3s16 node_max) { void MapgenV7::updateLighting(v3s16 nmin, v3s16 nmax) {
enum LightBank banks[2] = {LIGHTBANK_DAY, LIGHTBANK_NIGHT}; enum LightBank banks[2] = {LIGHTBANK_DAY, LIGHTBANK_NIGHT};
VoxelArea a(node_min - v3s16(1,0,1) * MAP_BLOCKSIZE, VoxelArea a(nmin - v3s16(1,0,1) * MAP_BLOCKSIZE,
node_max + v3s16(1,0,1) * MAP_BLOCKSIZE); nmax + v3s16(1,0,1) * MAP_BLOCKSIZE);
bool block_is_underground = (water_level > node_max.Y); bool block_is_underground = (water_level > nmax.Y);
bool sunlight = !block_is_underground; bool sunlight = !block_is_underground;
ScopeProfiler sp(g_profiler, "EmergeThread: mapgen lighting update", SPT_AVG); ScopeProfiler sp(g_profiler, "EmergeThread: mapgen lighting update", SPT_AVG);
@ -215,20 +200,55 @@ void MapgenV7::updateLighting(v3s16 node_min, v3s16 node_max) {
} }
EmergeManager::EmergeManager(IGameDef *gamedef) { EmergeManager::EmergeManager(IGameDef *gamedef, int mg_version) {
this->seed = 0; this->mg_version = mg_version;
this->water_level = 0; this->biomedef = new BiomeDefManager(gamedef);
this->np_terrain = &nparams_mtdefault;
this->np_bgroup = &nparams_def_bgroup;
this->np_heat = &nparams_def_heat;
this->np_humidity = &nparams_def_humidity;
this->biomedef = new BiomeDefManager(gamedef); this->params = NULL;
setMapgenParams();
} }
EmergeManager::~EmergeManager() { EmergeManager::~EmergeManager() {
delete biomedef; delete biomedef;
delete params;
}
Mapgen *EmergeManager::getMapgen() {
if (!mapgen) {
switch (mg_version) {
case 6:
mapgen = new MapgenV6(0, params);
break;
case 7:
mapgen = new MapgenV7(biomedef, 0, params);
break;
default:
errorstream << "EmergeManager: Unsupported mapgen version "
<< mg_version << ", falling back to V6" << std::endl;
mg_version = 6;
mapgen = new MapgenV6(0, mgv6params);
}
}
return mapgen;
}
void EmergeManager::setMapgenParams() {
if (params)
delete params;
switch (mg_version) {
case 6:
params = new MapgenV6Params();
break;
case 7:
params = new MapgenV7Params();
break;
default: //////do something here!
;
}
} }

@ -58,18 +58,110 @@ struct BlockMakeData {
}; };
class Mapgen { /////////////////// Mapgen flags
public: #define MG_TREES 0x01
#define MG_CAVES 0x02
#define MG_DUNGEONS 0x04
#define MGV6_FORESTS 0x08
#define MGV6_BIOME_BLEND 0x10
#define AVERAGE_MUD_AMOUNT 4
/////////////////// 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), 85309, 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_trees =
{0.0, 1.0, v3f(125.0, 125.0, 125.0), 2, 4, 0.66};
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};
/////////////////// Mapgen V7 perlin noise default values
NoiseParams nparams_v7_def_terrain =
{10.0, 12.0, v3f(350., 350., 350.), 82341, 5, 0.6}; //terrain
NoiseParams nparams_v7_def_bgroup =
{0.5, 1/(2*1.6), v3f(350., 350., 350.), 5923, 2, 0.60}; //0 to 1
NoiseParams nparams_v7_def_heat =
{25.0, 50.0, v3f(500., 500., 500.), 35293, 1, 0.00}; //-25 to 75
NoiseParams nparams_v7_def_humidity =
{50, 100/(2*1.6), v3f(750., 750., 750.), 12094, 2, 0.60}; //0 to 100
struct MapgenParams {
int seed; int seed;
int water_level; int water_level;
int chunksize;
u32 flags;
MapgenParams() {
seed = 0;
water_level = 1;
chunksize = 5;
flags = MG_TREES | MG_CAVES | MGV6_BIOME_BLEND;
}
};
struct MapgenV6Params : public MapgenParams {
float freq_desert;
float freq_beach;
NoiseParams *np_terrain_base;
NoiseParams *np_terrain_higher;
NoiseParams *np_steepness;
NoiseParams *np_height_select;
NoiseParams *np_trees;
NoiseParams *np_mud;
NoiseParams *np_beach;
NoiseParams *np_biome;
NoiseParams *np_cave;
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_trees = &nparams_v6_def_trees;
np_mud = &nparams_v6_def_mud;
np_beach = &nparams_v6_def_beach;
np_biome = &nparams_v6_def_biome;
np_cave = &nparams_v6_def_cave;
}
};
struct MapgenV7Params : public MapgenParams {
NoiseParams *np_terrain;
NoiseParams *np_bgroup;
NoiseParams *np_heat;
NoiseParams *np_humidity;
MapgenV7Params() {
np_terrain = &nparams_v7_def_terrain;
np_bgroup = &nparams_v7_def_bgroup;
np_heat = &nparams_v7_def_heat;
np_humidity = &nparams_v7_def_humidity;
}
};
class Mapgen {
public:
int seed;
int water_level;
bool generating; bool generating;
int id; int id;
//virtual Mapgen(BiomeDefManager *biomedef, int mapgenid=0, u64 seed=0);
//virtual ~Mapgen();
virtual void makeChunk(BlockMakeData *data) {}; virtual void makeChunk(BlockMakeData *data) {};
//Legacy functions for Farmesh (pending removal) //Legacy functions for Farmesh (pending removal)
@ -109,9 +201,11 @@ public:
float *map_biome; float *map_biome;
float *map_cave; float *map_cave;
bool use_smooth_biome_trans; u32 flags;
float freq_desert;
float freq_beach;
MapgenV6(int mapgenid=0, u64 seed=0); MapgenV6(int mapgenid, MapgenV6Params *params);
~MapgenV6(); ~MapgenV6();
void makeChunk(BlockMakeData *data); void makeChunk(BlockMakeData *data);
@ -142,8 +236,6 @@ public:
int zstride; int zstride;
v3s16 csize; v3s16 csize;
//int seed;
//int water_level;
Noise *noise_terrain; Noise *noise_terrain;
Noise *noise_bgroup; Noise *noise_bgroup;
@ -160,24 +252,20 @@ public:
bool generating; bool generating;
int id; int id;
u32 flags;
/*
NoiseParams *np_terrain; NoiseParams *np_terrain;
NoiseParams *np_bgroup; NoiseParams *np_bgroup;
NoiseParams *np_heat; NoiseParams *np_heat;
NoiseParams *np_humidity; NoiseParams *np_humidity;*/
//should these be broken off into a "commonly used nodes" class? //should these be broken off into a "commonly used nodes" class?
MapNode n_air; MapNode n_air;
MapNode n_water; MapNode n_water;
MapNode n_lava; MapNode n_lava;
MapgenV7(BiomeDefManager *biomedef, int mapgenid=0, u64 seed=0); MapgenV7(BiomeDefManager *biomedef, int mapgenid, MapgenV7Params *params);
MapgenV7(BiomeDefManager *biomedef, int mapgenid, u64 seed,
NoiseParams *np_terrain, NoiseParams *np_bgroup,
NoiseParams *np_heat, NoiseParams *np_humidity);
void init(BiomeDefManager *biomedef, int mapgenid, u64 seed,
NoiseParams *np_terrain, NoiseParams *np_bgroup,
NoiseParams *np_heat, NoiseParams *np_humidity);
~MapgenV7(); ~MapgenV7();
void makeChunk(BlockMakeData *data); void makeChunk(BlockMakeData *data);
@ -193,24 +281,22 @@ public:
class EmergeManager { class EmergeManager {
public: public:
//settings //settings
u64 seed; int mg_version;
int water_level; MapgenParams *params;
NoiseParams *np_terrain;
NoiseParams *np_bgroup; //mapgen objects here
NoiseParams *np_heat; Mapgen *mapgen;
NoiseParams *np_humidity;
//biome manager //biome manager
BiomeDefManager *biomedef; BiomeDefManager *biomedef;
//mapgen objects here EmergeManager(IGameDef *gamedef, int mg_version=6);
EmergeManager(IGameDef *gamedef);
~EmergeManager(); ~EmergeManager();
Mapgen *getMapgen();
void setMapgenParams();
void addBlockToQueue(); void addBlockToQueue();
//mapgen helper methods //mapgen helper methods
Biome *getBiomeAtPoint(v3s16 p); Biome *getBiomeAtPoint(v3s16 p);
int getGroundLevelAtPoint(v2s16 p); int getGroundLevelAtPoint(v2s16 p);

@ -32,9 +32,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "settings.h" // For g_settings #include "settings.h" // For g_settings
#include "main.h" // For g_profiler #include "main.h" // For g_profiler
/*
#define AVERAGE_MUD_AMOUNT 4 #define AVERAGE_MUD_AMOUNT 4
NoiseParams nparams_v6_def_terrain_base = NoiseParams nparams_v6_def_terrain_base =
{-AVERAGE_MUD_AMOUNT, 20.0, v3f(250.0, 250.0, 250.0), 82341, 5, 0.6}; {-AVERAGE_MUD_AMOUNT, 20.0, v3f(250.0, 250.0, 250.0), 82341, 5, 0.6};
NoiseParams nparams_v6_def_terrain_higher = NoiseParams nparams_v6_def_terrain_higher =
@ -51,42 +51,54 @@ NoiseParams nparams_v6_def_beach =
{0.0, 1.0, v3f(250.0, 250.0, 250.0), 59420, 3, 0.50}; {0.0, 1.0, v3f(250.0, 250.0, 250.0), 59420, 3, 0.50};
NoiseParams nparams_v6_def_biome = NoiseParams nparams_v6_def_biome =
{0.0, 1.0, v3f(250.0, 250.0, 250.0), 9130, 3, 0.50}; {0.0, 1.0, v3f(250.0, 250.0, 250.0), 9130, 3, 0.50};
//NoiseParams nparams_v6_def_cave = NoiseParams nparams_v6_def_cave =
// {6.0, 6.0, v3f(250.0, 250.0, 250.0), 34329, 3, 0.50}; {6.0, 6.0, v3f(250.0, 250.0, 250.0), 34329, 3, 0.50};
NoiseParams *np_terrain_base = &nparams_v6_def_terrain_base; MapgenV6Params mg_def_params_v6 = {
NoiseParams *np_terrain_higher = &nparams_v6_def_terrain_higher; 0,
NoiseParams *np_steepness = &nparams_v6_def_steepness; 1,
NoiseParams *np_height_select = &nparams_v6_def_height_select; 5,
NoiseParams *np_trees = &nparams_v6_def_trees; MG_TREES | MG_CAVES | MGV6_BIOME_BLEND,
NoiseParams *np_mud = &nparams_v6_def_mud; 0.45,
NoiseParams *np_beach = &nparams_v6_def_beach; 0.15,
NoiseParams *np_biome = &nparams_v6_def_biome; &nparams_v6_def_terrain_base,
//NoiseParams *np_cave = &nparams_v6_def_cave; &nparams_v6_def_terrain_higher,
&nparams_v6_def_steepness,
&nparams_v6_def_height_select,
&nparams_v6_def_trees,
&nparams_v6_def_mud,
&nparams_v6_def_beach,
&nparams_v6_def_biome,
&nparams_v6_def_cave
};
*/
///////////////////////////////////////////////////////////////////////////////
MapgenV6::MapgenV6(int mapgenid, u64 seed) { MapgenV6::MapgenV6(int mapgenid, MapgenV6Params *params) {
this->generating = false; this->generating = false;
this->id = mapgenid; this->id = mapgenid;
this->seed = (int)seed;
this->water_level = 1; this->seed = params->seed;
this->water_level = params->water_level;
this->flags = flags;
this->csize = v3s16(1, 1, 1) * params->chunksize * MAP_BLOCKSIZE;
this->csize = v3s16(5, 5, 5) * MAP_BLOCKSIZE; /////////////////get this from config! this->freq_desert = params->freq_desert;
this->ystride = csize.X; this->freq_beach = params->freq_beach;
this->use_smooth_biome_trans = g_settings->getBool("mgv6_use_smooth_biome_trans"); this->ystride = csize.X; //////fix this
noise_terrain_base = new Noise(np_terrain_base, seed, csize.X, csize.Y); noise_terrain_base = new Noise(params->np_terrain_base, seed, csize.X, csize.Y);
noise_terrain_higher = new Noise(np_terrain_higher, seed, csize.X, csize.Y); noise_terrain_higher = new Noise(params->np_terrain_higher, seed, csize.X, csize.Y);
noise_steepness = new Noise(np_steepness, seed, csize.X, csize.Y); noise_steepness = new Noise(params->np_steepness, seed, csize.X, csize.Y);
noise_height_select = new Noise(np_height_select, seed, csize.X, csize.Y); noise_height_select = new Noise(params->np_height_select, seed, csize.X, csize.Y);
noise_trees = new Noise(np_trees, seed, csize.X, csize.Y); noise_trees = new Noise(params->np_trees, seed, csize.X, csize.Y);
noise_mud = new Noise(np_mud, seed, csize.X, csize.Y); noise_mud = new Noise(params->np_mud, seed, csize.X, csize.Y);
noise_beach = new Noise(np_beach, seed, csize.X, csize.Y); noise_beach = new Noise(params->np_beach, seed, csize.X, csize.Y);
noise_biome = new Noise(np_biome, seed, csize.X, csize.Y); noise_biome = new Noise(params->np_biome, seed, csize.X, csize.Y);
//noise_cave = new Noise(np_cave, seed, csize.X, csize.Y);
map_terrain_base = noise_terrain_base->result; map_terrain_base = noise_terrain_base->result;
map_terrain_higher = noise_terrain_higher->result; map_terrain_higher = noise_terrain_higher->result;
@ -96,7 +108,6 @@ MapgenV6::MapgenV6(int mapgenid, u64 seed) {
map_mud = noise_mud->result; map_mud = noise_mud->result;
map_beach = noise_beach->result; map_beach = noise_beach->result;
map_biome = noise_biome->result; map_biome = noise_biome->result;
//map_cave = noise_cave->result;
} }
@ -294,9 +305,7 @@ double MapgenV6::base_rock_level_2d(u64 seed, v2s16 p)
0.5+(float)p.X/250., 0.5+(float)p.Y/250., 0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
seed+82341, 5, 0.6);*/ seed+82341, 5, 0.6);*/
double base = water_level + map_terrain_base[index]; double base = water_level + map_terrain_base[index];
//return base;
//printf("%f ", base);
//return base;
// Higher ground level // Higher ground level
/*double higher = (double)WATER_LEVEL + 20. + 16. * noise2d_perlin( /*double higher = (double)WATER_LEVEL + 20. + 16. * noise2d_perlin(
0.5+(float)p.X/500., 0.5+(float)p.Y/500., 0.5+(float)p.X/500., 0.5+(float)p.Y/500.,
@ -316,6 +325,7 @@ double MapgenV6::base_rock_level_2d(u64 seed, v2s16 p)
b = pow(b, 7); b = pow(b, 7);
b *= 5; b *= 5;
b = rangelim(b, 0.5, 1000.0); b = rangelim(b, 0.5, 1000.0);
// Values 1.5...100 give quite horrible looking slopes // Values 1.5...100 give quite horrible looking slopes
if(b > 1.5 && b < 100.0){ if(b > 1.5 && b < 100.0){
if(b < 10.0) if(b < 10.0)
@ -323,22 +333,19 @@ double MapgenV6::base_rock_level_2d(u64 seed, v2s16 p)
else else
b = 100.0; b = 100.0;
} }
//dstream<<"b="<<b<<std::endl;
//double b = 20;
//b = 0.25;
// Offset to more low // Offset to more low
double a_off = -0.20; double a_off = -0.20;
// High/low selector // High/low selector
/*double a = (double)0.5 + b * (a_off + noise2d_perlin( /*double a = (double)0.5 + b * (a_off + noise2d_perlin(
0.5+(float)p.X/250., 0.5+(float)p.Y/250., 0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
seed+4213, 5, 0.69));*/ seed+4213, 5, 0.69));*/
double a = 0.5 + b * (a_off + map_height_select[index]); double a = 0.5 + b * (a_off + map_height_select[index]);
// Limit // Limit
a = rangelim(a, 0.0, 1.0); a = rangelim(a, 0.0, 1.0);
//dstream<<"a="<<a<<std::endl;
double h = base*(1.0-a) + higher*a; double h = base*(1.0-a) + higher*a;
return h; return h;
@ -367,7 +374,7 @@ bool MapgenV6::get_have_beach(u64 seed, v2s16 p2d)
int index = (p2d.Y - node_min.Z) * ystride + (p2d.X - node_min.X); int index = (p2d.Y - node_min.Z) * ystride + (p2d.X - node_min.X);
double sandnoise = map_beach[index]; double sandnoise = map_beach[index];
return (sandnoise > 0.15); return (sandnoise > freq_beach);
} }
BiomeType MapgenV6::get_biome(u64 seed, v2s16 p2d) BiomeType MapgenV6::get_biome(u64 seed, v2s16 p2d)
@ -378,10 +385,11 @@ BiomeType MapgenV6::get_biome(u64 seed, v2s16 p2d)
seed+9130, 3, 0.50);*/ seed+9130, 3, 0.50);*/
int index = (p2d.Y - node_min.Z) * ystride + (p2d.X - node_min.X); int index = (p2d.Y - node_min.Z) * ystride + (p2d.X - node_min.X);
double d = map_biome[index]; double d = map_biome[index];
if(d > 0.45) if(d > freq_desert)
return BT_DESERT; return BT_DESERT;
if (use_smooth_biome_trans) { if (flags & MGV6_BIOME_BLEND) {
if(d > 0.35 && (noise2d( p2d.X, p2d.Y, int(seed) ) + 1.0) > ( 0.45 - d ) * 20.0 ) if(d > freq_desert - 0.10 &&
(noise2d(p2d.X, p2d.Y, seed) + 1.0) > (freq_desert - d) * 20.0)
return BT_DESERT; return BT_DESERT;
} }
return BT_NORMAL; return BT_NORMAL;
@ -485,6 +493,10 @@ void MapgenV6::makeChunk(BlockMakeData *data)
x + 0.5 * noise_height_select->np->spread.X, x + 0.5 * noise_height_select->np->spread.X,
z + 0.5 * noise_height_select->np->spread.Z); z + 0.5 * noise_height_select->np->spread.Z);
noise_trees->perlinMap2D(
x + 0.5 * noise_trees->np->spread.X,
z + 0.5 * noise_trees->np->spread.Z);
noise_mud->perlinMap2D( noise_mud->perlinMap2D(
x + 0.5 * noise_mud->np->spread.X, x + 0.5 * noise_mud->np->spread.X,
z + 0.5 * noise_mud->np->spread.Z); z + 0.5 * noise_mud->np->spread.Z);
@ -497,11 +509,6 @@ void MapgenV6::makeChunk(BlockMakeData *data)
noise_biome->perlinMap2D( noise_biome->perlinMap2D(
x + 0.6 * noise_biome->np->spread.X, x + 0.6 * noise_biome->np->spread.X,
z + 0.2 * noise_biome->np->spread.Z); z + 0.2 * noise_biome->np->spread.Z);
/* noise_cave->perlinMap2D(
x + 0.5 * noise_cave->np->spread.X,
z + 0.5 * noise_cave->np->spread.Z);
noise_cave->transformNoiseMap();*/
} }
@ -625,9 +632,14 @@ void MapgenV6::makeChunk(BlockMakeData *data)
Loop this part, it will make stuff look older and newer nicely Loop this part, it will make stuff look older and newer nicely
*/ */
double cave_amount = 6.0 + 6.0 * noise2d_perlin( /*double cave_amount = 6.0 + 6.0 * noise2d_perlin(
0.5+(double)node_min.X/250, 0.5+(double)node_min.Y/250, 0.5+(double)node_min.X/250, 0.5+(double)node_min.Y/250,
data->seed+34329, 3, 0.50); data->seed+34329, 3, 0.50);*/
double cave_amount = np_cave->offset + np_cave->scale * noise2d_perlin(
0.5 + (double)node_min.X / np_cave->spread.X,
0.5 + (double)node_min.Y / np_cave->spread.Y,
data->seed + np_cave->seed, np_cave->octaves, np_cave->persist);
const u32 age_loops = 2; const u32 age_loops = 2;
for(u32 i_age=0; i_age<age_loops; i_age++) for(u32 i_age=0; i_age<age_loops; i_age++)
@ -651,12 +663,17 @@ void MapgenV6::makeChunk(BlockMakeData *data)
PseudoRandom ps2(blockseed+1032); PseudoRandom ps2(blockseed+1032);
if(ps.range(1, 6) == 1) if(ps.range(1, 6) == 1)
bruises_count = ps.range(0, ps.range(0, 2)); bruises_count = ps.range(0, ps.range(0, 2));
if(get_biome(data->seed, v2s16(node_min.X, node_min.Y)) == BT_DESERT){ if(get_biome(data->seed, v2s16(node_min.X, node_min.Z)) == BT_DESERT){
caves_count /= 3; caves_count /= 3;
bruises_count /= 3; bruises_count /= 3;
} }
for(u32 jj=0; jj<caves_count+bruises_count; jj++) for(u32 jj=0; jj<caves_count+bruises_count; jj++)
{ {
int avg_height = (int)
((base_rock_level_2d(data->seed, v2s16(node_min.X, node_min.Z)) +
base_rock_level_2d(data->seed, v2s16(node_max.X, node_max.Z))) / 2);
if ((node_max.Y + node_min.Y) / 2 > avg_height)
break;
bool large_cave = (jj >= caves_count); bool large_cave = (jj >= caves_count);
s16 min_tunnel_diameter = 2; s16 min_tunnel_diameter = 2;
s16 max_tunnel_diameter = ps.range(2,6); s16 max_tunnel_diameter = ps.range(2,6);
@ -984,7 +1001,7 @@ void MapgenV6::makeChunk(BlockMakeData *data)
/* /*
Add blobs of dirt and gravel underground Add blobs of dirt and gravel underground
*/ */
if(get_biome(data->seed, v2s16(node_min.X, node_min.Y)) == BT_NORMAL) if(get_biome(data->seed, v2s16(node_min.X, node_min.Z)) == BT_NORMAL)
{ {
PseudoRandom pr(blockseed+983); PseudoRandom pr(blockseed+983);
for(int i=0; i<volume_nodes/10/10/10; i++) for(int i=0; i<volume_nodes/10/10/10; i++)

@ -4464,6 +4464,10 @@ static int l_register_biome_groups(lua_State *L)
throw LuaError(L, "register_biome_groups: parameter is not a table"); throw LuaError(L, "register_biome_groups: parameter is not a table");
BiomeDefManager *bmgr = get_server(L)->getEmergeManager()->biomedef; BiomeDefManager *bmgr = get_server(L)->getEmergeManager()->biomedef;
if (!bmgr) {
verbosestream << "register_biome_groups: BiomeDefManager not active" << std::endl;
return 0;
}
lua_pushnil(L); lua_pushnil(L);
for (int i = 1; lua_next(L, index) != 0; i++) { for (int i = 1; lua_next(L, index) != 0; i++) {
@ -4484,6 +4488,10 @@ static int l_register_biome(lua_State *L)
IWritableNodeDefManager *ndef = get_server(L)->getWritableNodeDefManager(); IWritableNodeDefManager *ndef = get_server(L)->getWritableNodeDefManager();
BiomeDefManager *bmgr = get_server(L)->getEmergeManager()->biomedef; BiomeDefManager *bmgr = get_server(L)->getEmergeManager()->biomedef;
if (!bmgr) {
verbosestream << "register_biome: BiomeDefManager not active" << std::endl;
return 0;
}
groupid = getintfield_default(L, index, "group_id", 0); groupid = getintfield_default(L, index, "group_id", 0);

@ -172,12 +172,8 @@ void * EmergeThread::Thread()
ServerMap &map = ((ServerMap&)m_server->m_env->getMap()); ServerMap &map = ((ServerMap&)m_server->m_env->getMap());
EmergeManager *emerge = m_server->m_emerge; EmergeManager *emerge = m_server->m_emerge;
Mapgen *mapgen = emerge->getMapgen();
Mapgen *mapgen;
if (g_settings->getS16("use_mapgen_version") == 7) ////////this is okay for now, fix later
mapgen = new MapgenV7( m_server->m_emerge->biomedef,/*mapgenid*/ 0, map.getSeed());
else
mapgen = new MapgenV6(0, map.getSeed());
/* /*
Get block info from queue, emerge them and send them Get block info from queue, emerge them and send them
to clients. to clients.
@ -800,6 +796,7 @@ void RemoteClient::GetNextBlocks(Server *server, float dtime,
} else { } else {
if(nearest_emergefull_d == -1) if(nearest_emergefull_d == -1)
nearest_emergefull_d = d; nearest_emergefull_d = d;
goto queue_full_break;
} }
// get next one. // get next one.
@ -988,7 +985,7 @@ Server::Server(
infostream<<"- game: "<<m_gamespec.path<<std::endl; infostream<<"- game: "<<m_gamespec.path<<std::endl;
// Create emerge manager // Create emerge manager
m_emerge = new EmergeManager(this); m_emerge = new EmergeManager(this, g_settings->getS16("use_mapgen_version"));
// Create rollback manager // Create rollback manager
std::string rollback_path = m_path_world+DIR_DELIM+"rollback.txt"; std::string rollback_path = m_path_world+DIR_DELIM+"rollback.txt";
@ -1097,7 +1094,8 @@ Server::Server(
m_nodedef->updateAliases(m_itemdef); m_nodedef->updateAliases(m_itemdef);
// Add default biomes after nodedef had its aliases added // Add default biomes after nodedef had its aliases added
m_emerge->biomedef->addDefaultBiomes(); if (m_emerge->biomedef)
m_emerge->biomedef->addDefaultBiomes();
// Initialize Environment // Initialize Environment