aboutsummaryrefslogtreecommitdiff
path: root/src/mapgen/mapgen_v6.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/mapgen/mapgen_v6.cpp')
-rw-r--r--src/mapgen/mapgen_v6.cpp955
1 files changed, 478 insertions, 477 deletions
diff --git a/src/mapgen/mapgen_v6.cpp b/src/mapgen/mapgen_v6.cpp
index 8a0f01409..e9692246c 100644
--- a/src/mapgen/mapgen_v6.cpp
+++ b/src/mapgen/mapgen_v6.cpp
@@ -19,6 +19,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
+
#include <cmath>
#include "mapgen.h"
#include "voxel.h"
@@ -38,64 +39,70 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "mg_decoration.h"
#include "mapgen_v6.h"
-FlagDesc flagdesc_mapgen_v6[] = {{"jungles", MGV6_JUNGLES},
- {"biomeblend", MGV6_BIOMEBLEND}, {"mudflow", MGV6_MUDFLOW},
- {"snowbiomes", MGV6_SNOWBIOMES}, {"flat", MGV6_FLAT},
- {"trees", MGV6_TREES}, {NULL, 0}};
+
+FlagDesc flagdesc_mapgen_v6[] = {
+ {"jungles", MGV6_JUNGLES},
+ {"biomeblend", MGV6_BIOMEBLEND},
+ {"mudflow", MGV6_MUDFLOW},
+ {"snowbiomes", MGV6_SNOWBIOMES},
+ {"flat", MGV6_FLAT},
+ {"trees", MGV6_TREES},
+ {NULL, 0}
+};
+
/////////////////////////////////////////////////////////////////////////////
-MapgenV6::MapgenV6(MapgenV6Params *params, EmergeParams *emerge) :
- Mapgen(MAPGEN_V6, params, emerge)
+
+MapgenV6::MapgenV6(MapgenV6Params *params, EmergeParams *emerge)
+ : Mapgen(MAPGEN_V6, params, emerge)
{
m_emerge = emerge;
ystride = csize.X;
heightmap = new s16[csize.X * csize.Z];
- spflags = params->spflags;
- freq_desert = params->freq_desert;
- freq_beach = params->freq_beach;
+ spflags = params->spflags;
+ freq_desert = params->freq_desert;
+ freq_beach = params->freq_beach;
dungeon_ymin = params->dungeon_ymin;
dungeon_ymax = params->dungeon_ymax;
- np_cave = &params->np_cave;
- np_humidity = &params->np_humidity;
- np_trees = &params->np_trees;
+ np_cave = &params->np_cave;
+ np_humidity = &params->np_humidity;
+ np_trees = &params->np_trees;
np_apple_trees = &params->np_apple_trees;
np_dungeons = NoiseParams(0.9, 0.5, v3f(500.0, 500.0, 500.0), 0, 2, 0.8, 2.0);
//// Create noise objects
- 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(&params->np_humidity, 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(&params->np_humidity, seed,
csize.X + 2 * MAP_BLOCKSIZE, csize.Y + 2 * MAP_BLOCKSIZE);
//// Resolve nodes to be used
const NodeDefManager *ndef = emerge->ndef;
- c_stone = ndef->getId("mapgen_stone");
- c_dirt = ndef->getId("mapgen_dirt");
+ c_stone = ndef->getId("mapgen_stone");
+ c_dirt = ndef->getId("mapgen_dirt");
c_dirt_with_grass = ndef->getId("mapgen_dirt_with_grass");
- c_sand = ndef->getId("mapgen_sand");
- c_water_source = ndef->getId("mapgen_water_source");
- c_lava_source = ndef->getId("mapgen_lava_source");
- c_gravel = ndef->getId("mapgen_gravel");
- c_desert_stone = ndef->getId("mapgen_desert_stone");
- c_desert_sand = ndef->getId("mapgen_desert_sand");
- c_dirt_with_snow = ndef->getId("mapgen_dirt_with_snow");
- c_snow = ndef->getId("mapgen_snow");
- c_snowblock = ndef->getId("mapgen_snowblock");
- c_ice = ndef->getId("mapgen_ice");
+ c_sand = ndef->getId("mapgen_sand");
+ c_water_source = ndef->getId("mapgen_water_source");
+ c_lava_source = ndef->getId("mapgen_lava_source");
+ c_gravel = ndef->getId("mapgen_gravel");
+ c_desert_stone = ndef->getId("mapgen_desert_stone");
+ c_desert_sand = ndef->getId("mapgen_desert_sand");
+ c_dirt_with_snow = ndef->getId("mapgen_dirt_with_snow");
+ c_snow = ndef->getId("mapgen_snow");
+ c_snowblock = ndef->getId("mapgen_snowblock");
+ c_ice = ndef->getId("mapgen_ice");
if (c_gravel == CONTENT_IGNORE)
c_gravel = c_stone;
@@ -112,9 +119,9 @@ MapgenV6::MapgenV6(MapgenV6Params *params, EmergeParams *emerge) :
if (c_ice == CONTENT_IGNORE)
c_ice = c_water_source;
- c_cobble = ndef->getId("mapgen_cobble");
- c_mossycobble = ndef->getId("mapgen_mossycobble");
- c_stair_cobble = ndef->getId("mapgen_stair_cobble");
+ c_cobble = ndef->getId("mapgen_cobble");
+ c_mossycobble = ndef->getId("mapgen_mossycobble");
+ c_stair_cobble = ndef->getId("mapgen_stair_cobble");
c_stair_desert_stone = ndef->getId("mapgen_stair_desert_stone");
if (c_mossycobble == CONTENT_IGNORE)
@@ -125,29 +132,22 @@ MapgenV6::MapgenV6(MapgenV6Params *params, EmergeParams *emerge) :
c_stair_desert_stone = c_desert_stone;
if (c_stone == CONTENT_IGNORE)
- errorstream << "Mapgen v6: Mapgen alias 'mapgen_stone' is invalid!"
- << std::endl;
+ errorstream << "Mapgen v6: Mapgen alias 'mapgen_stone' is invalid!" << std::endl;
if (c_dirt == CONTENT_IGNORE)
- errorstream << "Mapgen v6: Mapgen alias 'mapgen_dirt' is invalid!"
- << std::endl;
+ errorstream << "Mapgen v6: Mapgen alias 'mapgen_dirt' is invalid!" << std::endl;
if (c_dirt_with_grass == CONTENT_IGNORE)
- errorstream << "Mapgen v6: Mapgen alias 'mapgen_dirt_with_grass' is "
- "invalid!"
- << std::endl;
+ errorstream << "Mapgen v6: Mapgen alias 'mapgen_dirt_with_grass' is invalid!" << std::endl;
if (c_sand == CONTENT_IGNORE)
- errorstream << "Mapgen v6: Mapgen alias 'mapgen_sand' is invalid!"
- << std::endl;
+ errorstream << "Mapgen v6: Mapgen alias 'mapgen_sand' is invalid!" << std::endl;
if (c_water_source == CONTENT_IGNORE)
- errorstream << "Mapgen v6: Mapgen alias 'mapgen_water_source' is invalid!"
- << std::endl;
+ errorstream << "Mapgen v6: Mapgen alias 'mapgen_water_source' is invalid!" << std::endl;
if (c_lava_source == CONTENT_IGNORE)
- errorstream << "Mapgen v6: Mapgen alias 'mapgen_lava_source' is invalid!"
- << std::endl;
+ errorstream << "Mapgen v6: Mapgen alias 'mapgen_lava_source' is invalid!" << std::endl;
if (c_cobble == CONTENT_IGNORE)
- errorstream << "Mapgen v6: Mapgen alias 'mapgen_cobble' is invalid!"
- << std::endl;
+ errorstream << "Mapgen v6: Mapgen alias 'mapgen_cobble' is invalid!" << std::endl;
}
+
MapgenV6::~MapgenV6()
{
delete noise_terrain_base;
@@ -164,72 +164,77 @@ MapgenV6::~MapgenV6()
delete m_emerge; // our responsibility
}
-MapgenV6Params::MapgenV6Params() :
- np_terrain_base(-4, 20.0, v3f(250.0, 250.0, 250.0), 82341, 5, 0.6, 2.0),
- np_terrain_higher(20, 16.0, v3f(500.0, 500.0, 500.0), 85039, 5, 0.6, 2.0),
- np_steepness(0.85, 0.5, v3f(125.0, 125.0, 125.0), -932, 5, 0.7, 2.0),
- np_height_select(0, 1.0, v3f(250.0, 250.0, 250.0), 4213, 5, 0.69, 2.0),
- np_mud(4, 2.0, v3f(200.0, 200.0, 200.0), 91013, 3, 0.55, 2.0),
- np_beach(0, 1.0, v3f(250.0, 250.0, 250.0), 59420, 3, 0.50, 2.0),
- np_biome(0, 1.0, v3f(500.0, 500.0, 500.0), 9130, 3, 0.50, 2.0),
- np_cave(6, 6.0, v3f(250.0, 250.0, 250.0), 34329, 3, 0.50, 2.0),
- np_humidity(0.5, 0.5, v3f(500.0, 500.0, 500.0), 72384, 3, 0.50, 2.0),
- np_trees(0, 1.0, v3f(125.0, 125.0, 125.0), 2, 4, 0.66, 2.0),
- np_apple_trees(0, 1.0, v3f(100.0, 100.0, 100.0), 342902, 3, 0.45, 2.0)
+
+MapgenV6Params::MapgenV6Params():
+ np_terrain_base (-4, 20.0, v3f(250.0, 250.0, 250.0), 82341, 5, 0.6, 2.0),
+ np_terrain_higher (20, 16.0, v3f(500.0, 500.0, 500.0), 85039, 5, 0.6, 2.0),
+ np_steepness (0.85, 0.5, v3f(125.0, 125.0, 125.0), -932, 5, 0.7, 2.0),
+ np_height_select (0, 1.0, v3f(250.0, 250.0, 250.0), 4213, 5, 0.69, 2.0),
+ np_mud (4, 2.0, v3f(200.0, 200.0, 200.0), 91013, 3, 0.55, 2.0),
+ np_beach (0, 1.0, v3f(250.0, 250.0, 250.0), 59420, 3, 0.50, 2.0),
+ np_biome (0, 1.0, v3f(500.0, 500.0, 500.0), 9130, 3, 0.50, 2.0),
+ np_cave (6, 6.0, v3f(250.0, 250.0, 250.0), 34329, 3, 0.50, 2.0),
+ np_humidity (0.5, 0.5, v3f(500.0, 500.0, 500.0), 72384, 3, 0.50, 2.0),
+ np_trees (0, 1.0, v3f(125.0, 125.0, 125.0), 2, 4, 0.66, 2.0),
+ np_apple_trees (0, 1.0, v3f(100.0, 100.0, 100.0), 342902, 3, 0.45, 2.0)
{
}
+
void MapgenV6Params::readParams(const Settings *settings)
{
settings->getFlagStrNoEx("mgv6_spflags", spflags, flagdesc_mapgen_v6);
settings->getFloatNoEx("mgv6_freq_desert", freq_desert);
- settings->getFloatNoEx("mgv6_freq_beach", freq_beach);
- settings->getS16NoEx("mgv6_dungeon_ymin", dungeon_ymin);
- settings->getS16NoEx("mgv6_dungeon_ymax", dungeon_ymax);
+ settings->getFloatNoEx("mgv6_freq_beach", freq_beach);
+ settings->getS16NoEx("mgv6_dungeon_ymin", dungeon_ymin);
+ settings->getS16NoEx("mgv6_dungeon_ymax", dungeon_ymax);
- settings->getNoiseParams("mgv6_np_terrain_base", np_terrain_base);
+ 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);
+ 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) const
{
settings->setFlagStr("mgv6_spflags", spflags, flagdesc_mapgen_v6);
settings->setFloat("mgv6_freq_desert", freq_desert);
- settings->setFloat("mgv6_freq_beach", freq_beach);
- settings->setS16("mgv6_dungeon_ymin", dungeon_ymin);
- settings->setS16("mgv6_dungeon_ymax", dungeon_ymax);
+ settings->setFloat("mgv6_freq_beach", freq_beach);
+ settings->setS16("mgv6_dungeon_ymin", dungeon_ymin);
+ settings->setS16("mgv6_dungeon_ymax", dungeon_ymax);
- settings->setNoiseParams("mgv6_np_terrain_base", np_terrain_base);
+ 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);
+ 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);
}
+
void MapgenV6Params::setDefaultSettings(Settings *settings)
{
- settings->setDefault("mgv6_spflags", flagdesc_mapgen_v6,
- MGV6_JUNGLES | MGV6_SNOWBIOMES | MGV6_TREES | MGV6_BIOMEBLEND |
- MGV6_MUDFLOW);
+ settings->setDefault("mgv6_spflags", flagdesc_mapgen_v6, MGV6_JUNGLES |
+ MGV6_SNOWBIOMES | MGV6_TREES | MGV6_BIOMEBLEND | MGV6_MUDFLOW);
}
+
//////////////////////// Some helper functions for the map generator
+
// Returns Y one under area minimum if not found
s16 MapgenV6::find_stone_level(v2s16 p2d)
{
@@ -249,6 +254,7 @@ s16 MapgenV6::find_stone_level(v2s16 p2d)
return (y >= y_nodes_min) ? y : y_nodes_min - 1;
}
+
// Required by mapgen.h
bool MapgenV6::block_is_underground(u64 seed, v3s16 blockpos)
{
@@ -257,22 +263,23 @@ bool MapgenV6::block_is_underground(u64 seed, v3s16 blockpos)
// Nah, this is just a heuristic, just return something
s16 minimum_groundlevel = water_level;
- if (blockpos.Y * MAP_BLOCKSIZE + MAP_BLOCKSIZE <= minimum_groundlevel)
+ if(blockpos.Y * MAP_BLOCKSIZE + MAP_BLOCKSIZE <= minimum_groundlevel)
return true;
return false;
}
+
//////////////////////// Base terrain height functions
float MapgenV6::baseTerrainLevel(float terrain_base, float terrain_higher,
- float steepness, float height_select)
+ float steepness, float height_select)
{
- float base = 1 + terrain_base;
+ float base = 1 + terrain_base;
float higher = 1 + terrain_higher;
// Limit higher ground level to at least base
- if (higher < base)
+ if(higher < base)
higher = base;
// Steepness factor of cliffs
@@ -292,61 +299,71 @@ float MapgenV6::baseTerrainLevel(float terrain_base, float terrain_higher,
return base * (1.0 - a) + higher * a;
}
+
float MapgenV6::baseTerrainLevelFromNoise(v2s16 p)
{
if (spflags & MGV6_FLAT)
return water_level;
- float terrain_base = NoisePerlin2D_PO(
- &noise_terrain_base->np, p.X, 0.5, p.Y, 0.5, seed);
- float terrain_higher = NoisePerlin2D_PO(
- &noise_terrain_higher->np, p.X, 0.5, p.Y, 0.5, seed);
- float steepness =
- NoisePerlin2D_PO(&noise_steepness->np, p.X, 0.5, p.Y, 0.5, seed);
- float height_select = NoisePerlin2D_PO(
- &noise_height_select->np, p.X, 0.5, p.Y, 0.5, seed);
-
- return baseTerrainLevel(terrain_base, terrain_higher, steepness, height_select);
+ float terrain_base = NoisePerlin2D_PO(&noise_terrain_base->np,
+ p.X, 0.5, p.Y, 0.5, seed);
+ float terrain_higher = NoisePerlin2D_PO(&noise_terrain_higher->np,
+ p.X, 0.5, p.Y, 0.5, seed);
+ float steepness = NoisePerlin2D_PO(&noise_steepness->np,
+ p.X, 0.5, p.Y, 0.5, seed);
+ float height_select = NoisePerlin2D_PO(&noise_height_select->np,
+ p.X, 0.5, p.Y, 0.5, seed);
+
+ return baseTerrainLevel(terrain_base, terrain_higher,
+ steepness, height_select);
}
+
float MapgenV6::baseTerrainLevelFromMap(v2s16 p)
{
int index = (p.Y - node_min.Z) * ystride + (p.X - node_min.X);
return baseTerrainLevelFromMap(index);
}
+
float MapgenV6::baseTerrainLevelFromMap(int index)
{
if (spflags & MGV6_FLAT)
return water_level;
- float terrain_base = noise_terrain_base->result[index];
+ float terrain_base = noise_terrain_base->result[index];
float terrain_higher = noise_terrain_higher->result[index];
- float steepness = noise_steepness->result[index];
- float height_select = noise_height_select->result[index];
+ float steepness = noise_steepness->result[index];
+ float height_select = noise_height_select->result[index];
- return baseTerrainLevel(terrain_base, terrain_higher, steepness, height_select);
+ return baseTerrainLevel(terrain_base, terrain_higher,
+ steepness, height_select);
}
+
s16 MapgenV6::find_ground_level_from_noise(u64 seed, v2s16 p2d, s16 precision)
{
return baseTerrainLevelFromNoise(p2d) + MGV6_AVERAGE_MUD_AMOUNT;
}
+
int MapgenV6::getGroundLevelAtPoint(v2s16 p)
{
return baseTerrainLevelFromNoise(p) + MGV6_AVERAGE_MUD_AMOUNT;
}
+
int MapgenV6::getSpawnLevelAtPoint(v2s16 p)
{
s16 level_at_point = baseTerrainLevelFromNoise(p) + MGV6_AVERAGE_MUD_AMOUNT;
- if (level_at_point <= water_level || level_at_point > water_level + 16)
- return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point
+ if (level_at_point <= water_level ||
+ level_at_point > water_level + 16)
+ return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point
return level_at_point;
}
+
//////////////////////// Noise functions
float MapgenV6::getMudAmount(v2s16 p)
@@ -355,19 +372,22 @@ float MapgenV6::getMudAmount(v2s16 p)
return getMudAmount(index);
}
+
bool MapgenV6::getHaveBeach(v2s16 p)
{
int index = (p.Y - node_min.Z) * ystride + (p.X - node_min.X);
return getHaveBeach(index);
}
+
BiomeV6Type MapgenV6::getBiome(v2s16 p)
{
- int index = (p.Y - full_node_min.Z) * (ystride + 2 * MAP_BLOCKSIZE) +
- (p.X - full_node_min.X);
+ int index = (p.Y - full_node_min.Z) * (ystride + 2 * MAP_BLOCKSIZE)
+ + (p.X - full_node_min.X);
return getBiome(index, p);
}
+
float MapgenV6::getHumidity(v2s16 p)
{
/*double noise = noise2d_perlin(
@@ -375,8 +395,8 @@ float MapgenV6::getHumidity(v2s16 p)
seed+72384, 4, 0.66);
noise = (noise + 1.0)/2.0;*/
- int index = (p.Y - full_node_min.Z) * (ystride + 2 * MAP_BLOCKSIZE) +
- (p.X - full_node_min.X);
+ int index = (p.Y - full_node_min.Z) * (ystride + 2 * MAP_BLOCKSIZE)
+ + (p.X - full_node_min.X);
float noise = noise_humidity->result[index];
if (noise < 0.0)
@@ -386,6 +406,7 @@ float MapgenV6::getHumidity(v2s16 p)
return noise;
}
+
float MapgenV6::getTreeAmount(v2s16 p)
{
/*double noise = noise2d_perlin(
@@ -400,6 +421,7 @@ float MapgenV6::getTreeAmount(v2s16 p)
return 0.04 * (noise - zeroval) / (1.0 - zeroval);
}
+
bool MapgenV6::getHaveAppleTree(v2s16 p)
{
/*is_apple_tree = noise2d_perlin(
@@ -411,6 +433,7 @@ bool MapgenV6::getHaveAppleTree(v2s16 p)
return noise > 0.2;
}
+
float MapgenV6::getMudAmount(int index)
{
if (spflags & MGV6_FLAT)
@@ -423,6 +446,7 @@ float MapgenV6::getMudAmount(int index)
return noise_mud->result[index];
}
+
bool MapgenV6::getHaveBeach(int index)
{
// Determine whether to have sand here
@@ -434,6 +458,7 @@ bool MapgenV6::getHaveBeach(int index)
return (sandnoise > freq_beach);
}
+
BiomeV6Type MapgenV6::getBiome(int index, v2s16 p)
{
// Just do something very simple as for now
@@ -445,8 +470,7 @@ BiomeV6Type MapgenV6::getBiome(int index, v2s16 p)
float h = noise_humidity->result[index];
if (spflags & MGV6_SNOWBIOMES) {
- float blend = (spflags & MGV6_BIOMEBLEND) ? noise2d(p.X, p.Y, seed) / 40
- : 0;
+ float blend = (spflags & MGV6_BIOMEBLEND) ? noise2d(p.X, p.Y, seed) / 40 : 0;
if (d > MGV6_FREQ_HOT + blend) {
if (h > MGV6_FREQ_JUNGLE + blend)
@@ -476,14 +500,17 @@ BiomeV6Type MapgenV6::getBiome(int index, v2s16 p)
return BT_JUNGLE;
return BT_NORMAL;
+
}
+
u32 MapgenV6::get_blockseed(u64 seed, v3s16 p)
{
s32 x = p.X, y = p.Y, z = p.Z;
return (u32)(seed % 0x100000000ULL) + z * 38134234 + y * 42123 + x * 23;
}
+
//////////////////////// Map generator
void MapgenV6::makeChunk(BlockMakeData *data)
@@ -492,14 +519,14 @@ void MapgenV6::makeChunk(BlockMakeData *data)
assert(data->vmanip);
assert(data->nodedef);
assert(data->blockpos_requested.X >= data->blockpos_min.X &&
- data->blockpos_requested.Y >= data->blockpos_min.Y &&
- data->blockpos_requested.Z >= data->blockpos_min.Z);
+ data->blockpos_requested.Y >= data->blockpos_min.Y &&
+ data->blockpos_requested.Z >= data->blockpos_min.Z);
assert(data->blockpos_requested.X <= data->blockpos_max.X &&
- data->blockpos_requested.Y <= data->blockpos_max.Y &&
- data->blockpos_requested.Z <= data->blockpos_max.Z);
+ data->blockpos_requested.Y <= data->blockpos_max.Y &&
+ data->blockpos_requested.Z <= data->blockpos_max.Z);
this->generating = true;
- this->vm = data->vmanip;
+ this->vm = data->vmanip;
this->ndef = data->nodedef;
// Hack: use minimum block coords for old code that assumes a single block
@@ -551,6 +578,7 @@ void MapgenV6::makeChunk(BlockMakeData *data)
// Flow mud away from steep edges
if (spflags & MGV6_MUDFLOW)
flowMud(mudflow_minpos, mudflow_maxpos);
+
}
// Update heightmap after mudflow
@@ -558,53 +586,50 @@ void MapgenV6::makeChunk(BlockMakeData *data)
// Add dungeons
if ((flags & MG_DUNGEONS) && stone_surface_max_y >= node_min.Y &&
- full_node_min.Y >= dungeon_ymin &&
- full_node_max.Y <= dungeon_ymax) {
- u16 num_dungeons = std::fmax(
- std::floor(NoisePerlin3D(&np_dungeons, node_min.X,
- node_min.Y, node_min.Z, seed)),
- 0.0f);
+ full_node_min.Y >= dungeon_ymin && full_node_max.Y <= dungeon_ymax) {
+ u16 num_dungeons = std::fmax(std::floor(
+ NoisePerlin3D(&np_dungeons, node_min.X, node_min.Y, node_min.Z, seed)), 0.0f);
if (num_dungeons >= 1) {
PseudoRandom ps(blockseed + 4713);
DungeonParams dp;
- dp.seed = seed;
- dp.num_dungeons = num_dungeons;
- dp.only_in_ground = true;
- dp.corridor_len_min = 1;
- dp.corridor_len_max = 13;
- dp.num_rooms = ps.range(2, 16);
+ dp.seed = seed;
+ dp.num_dungeons = num_dungeons;
+ dp.only_in_ground = true;
+ dp.corridor_len_min = 1;
+ dp.corridor_len_max = 13;
+ dp.num_rooms = ps.range(2, 16);
dp.large_room_chance = (ps.range(1, 4) == 1) ? 1 : 0;
- dp.np_alt_wall = NoiseParams(-0.4, 1.0, v3f(40.0, 40.0, 40.0),
- 32474, 6, 1.1, 2.0);
+ dp.np_alt_wall
+ = NoiseParams(-0.4, 1.0, v3f(40.0, 40.0, 40.0), 32474, 6, 1.1, 2.0);
if (getBiome(0, v2s16(node_min.X, node_min.Z)) == BT_DESERT) {
- dp.c_wall = c_desert_stone;
- dp.c_alt_wall = CONTENT_IGNORE;
- dp.c_stair = c_stair_desert_stone;
-
- dp.diagonal_dirs = true;
- dp.holesize = v3s16(2, 3, 2);
- dp.room_size_min = v3s16(6, 9, 6);
- dp.room_size_max = v3s16(10, 11, 10);
+ dp.c_wall = c_desert_stone;
+ dp.c_alt_wall = CONTENT_IGNORE;
+ dp.c_stair = c_stair_desert_stone;
+
+ dp.diagonal_dirs = true;
+ dp.holesize = v3s16(2, 3, 2);
+ dp.room_size_min = v3s16(6, 9, 6);
+ dp.room_size_max = v3s16(10, 11, 10);
dp.room_size_large_min = v3s16(10, 13, 10);
dp.room_size_large_max = v3s16(18, 21, 18);
- dp.notifytype = GENNOTIFY_TEMPLE;
+ dp.notifytype = GENNOTIFY_TEMPLE;
} else {
- dp.c_wall = c_cobble;
- dp.c_alt_wall = c_mossycobble;
- dp.c_stair = c_stair_cobble;
-
- dp.diagonal_dirs = false;
- dp.holesize = v3s16(1, 2, 1);
- dp.room_size_min = v3s16(4, 4, 4);
- dp.room_size_max = v3s16(8, 6, 8);
+ dp.c_wall = c_cobble;
+ dp.c_alt_wall = c_mossycobble;
+ dp.c_stair = c_stair_cobble;
+
+ dp.diagonal_dirs = false;
+ dp.holesize = v3s16(1, 2, 1);
+ dp.room_size_min = v3s16(4, 4, 4);
+ dp.room_size_max = v3s16(8, 6, 8);
dp.room_size_large_min = v3s16(8, 8, 8);
dp.room_size_large_max = v3s16(16, 16, 16);
- dp.notifytype = GENNOTIFY_DUNGEON;
+ dp.notifytype = GENNOTIFY_DUNGEON;
}
DungeonGen dgen(ndef, &gennotify, &dp);
@@ -632,12 +657,13 @@ void MapgenV6::makeChunk(BlockMakeData *data)
// Calculate lighting
if (flags & MG_LIGHT)
calcLighting(node_min - v3s16(1, 1, 1) * MAP_BLOCKSIZE,
- node_max + v3s16(1, 0, 1) * MAP_BLOCKSIZE, full_node_min,
- full_node_max);
+ node_max + v3s16(1, 0, 1) * MAP_BLOCKSIZE,
+ full_node_min, full_node_max);
this->generating = false;
}
+
void MapgenV6::calculateNoise()
{
int x = node_min.X;
@@ -661,9 +687,10 @@ void MapgenV6::calculateNoise()
// only humidity at point does
}
+
int MapgenV6::generateGround()
{
- // TimeTaker timer1("Generating ground level");
+ //TimeTaker timer1("Generating ground level");
MapNode n_air(CONTENT_AIR), n_water_source(c_water_source);
MapNode n_stone(c_stone), n_desert_stone(c_desert_stone);
MapNode n_ice(c_ice);
@@ -671,242 +698,218 @@ int MapgenV6::generateGround()
u32 index = 0;
for (s16 z = node_min.Z; z <= node_max.Z; z++)
- for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
- // Surface height
- s16 surface_y = (s16)baseTerrainLevelFromMap(index);
-
- // Log it
- if (surface_y > stone_surface_max_y)
- stone_surface_max_y = surface_y;
-
- BiomeV6Type bt = getBiome(v2s16(x, z));
-
- // Fill ground with stone
- const v3s16 &em = vm->m_area.getExtent();
- u32 i = vm->m_area.index(x, node_min.Y, z);
- for (s16 y = node_min.Y; y <= node_max.Y; y++) {
- if (vm->m_data[i].getContent() == CONTENT_IGNORE) {
- if (y <= surface_y) {
- vm->m_data[i] = (y >= MGV6_DESERT_STONE_BASE &&
- bt == BT_DESERT)
- ? n_desert_stone
- : n_stone;
- } else if (y <= water_level) {
- vm->m_data[i] = (y >= MGV6_ICE_BASE &&
- bt == BT_TUNDRA)
- ? n_ice
- : n_water_source;
- } else {
- vm->m_data[i] = n_air;
- }
+ for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
+ // Surface height
+ s16 surface_y = (s16)baseTerrainLevelFromMap(index);
+
+ // Log it
+ if (surface_y > stone_surface_max_y)
+ stone_surface_max_y = surface_y;
+
+ BiomeV6Type bt = getBiome(v2s16(x, z));
+
+ // Fill ground with stone
+ const v3s16 &em = vm->m_area.getExtent();
+ u32 i = vm->m_area.index(x, node_min.Y, z);
+ for (s16 y = node_min.Y; y <= node_max.Y; y++) {
+ if (vm->m_data[i].getContent() == CONTENT_IGNORE) {
+ if (y <= surface_y) {
+ vm->m_data[i] = (y >= MGV6_DESERT_STONE_BASE
+ && bt == BT_DESERT) ?
+ n_desert_stone : n_stone;
+ } else if (y <= water_level) {
+ vm->m_data[i] = (y >= MGV6_ICE_BASE
+ && bt == BT_TUNDRA) ?
+ n_ice : n_water_source;
+ } else {
+ vm->m_data[i] = n_air;
}
- VoxelArea::add_y(em, i, 1);
}
+ VoxelArea::add_y(em, i, 1);
}
+ }
return stone_surface_max_y;
}
+
void MapgenV6::addMud()
{
// 15ms @cs=8
- // TimeTaker timer1("add mud");
+ //TimeTaker timer1("add mud");
MapNode n_dirt(c_dirt), n_gravel(c_gravel);
MapNode n_sand(c_sand), n_desert_sand(c_desert_sand);
MapNode addnode;
u32 index = 0;
for (s16 z = node_min.Z; z <= node_max.Z; z++)
- for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
- // Randomize mud amount
- s16 mud_add_amount = getMudAmount(index) / 2.0 + 0.5;
+ for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
+ // Randomize mud amount
+ s16 mud_add_amount = getMudAmount(index) / 2.0 + 0.5;
+
+ // Find ground level
+ s16 surface_y = find_stone_level(v2s16(x, z)); /////////////////optimize this!
+
+ // Handle area not found
+ if (surface_y == vm->m_area.MinEdge.Y - 1)
+ continue;
+
+ BiomeV6Type bt = getBiome(v2s16(x, z));
+ addnode = (bt == BT_DESERT) ? n_desert_sand : n_dirt;
+
+ if (bt == BT_DESERT && surface_y + mud_add_amount <= water_level + 1) {
+ addnode = n_sand;
+ } else if (mud_add_amount <= 0) {
+ mud_add_amount = 1 - mud_add_amount;
+ addnode = n_gravel;
+ } else if (bt != BT_DESERT && getHaveBeach(index) &&
+ surface_y + mud_add_amount <= water_level + 2) {
+ addnode = n_sand;
+ }
- // Find ground level
- s16 surface_y = find_stone_level(
- v2s16(x, z)); /////////////////optimize this!
+ if ((bt == BT_DESERT || bt == BT_TUNDRA) && surface_y > 20)
+ mud_add_amount = MYMAX(0, mud_add_amount - (surface_y - 20) / 5);
- // Handle area not found
- if (surface_y == vm->m_area.MinEdge.Y - 1)
- continue;
+ /* If topmost node is grass, change it to mud. It might be if it was
+ // flown to there from a neighboring chunk and then converted.
+ u32 i = vm->m_area.index(x, surface_y, z);
+ if (vm->m_data[i].getContent() == c_dirt_with_grass)
+ vm->m_data[i] = n_dirt;*/
- BiomeV6Type bt = getBiome(v2s16(x, z));
- addnode = (bt == BT_DESERT) ? n_desert_sand : n_dirt;
-
- if (bt == BT_DESERT &&
- surface_y + mud_add_amount <= water_level + 1) {
- addnode = n_sand;
- } else if (mud_add_amount <= 0) {
- mud_add_amount = 1 - mud_add_amount;
- addnode = n_gravel;
- } else if (bt != BT_DESERT && getHaveBeach(index) &&
- surface_y + mud_add_amount <= water_level + 2) {
- addnode = n_sand;
- }
+ // Add mud on ground
+ s16 mudcount = 0;
+ const v3s16 &em = vm->m_area.getExtent();
+ s16 y_start = surface_y + 1;
+ u32 i = vm->m_area.index(x, y_start, z);
+ for (s16 y = y_start; y <= node_max.Y; y++) {
+ if (mudcount >= mud_add_amount)
+ break;
- if ((bt == BT_DESERT || bt == BT_TUNDRA) && surface_y > 20)
- mud_add_amount = MYMAX(
- 0, mud_add_amount - (surface_y - 20) / 5);
-
- /* If topmost node is grass, change it to mud. It might be if it
- was
- // flown to there from a neighboring chunk and then converted.
- u32 i = vm->m_area.index(x, surface_y, z);
- if (vm->m_data[i].getContent() == c_dirt_with_grass)
- vm->m_data[i] = n_dirt;*/
-
- // Add mud on ground
- s16 mudcount = 0;
- const v3s16 &em = vm->m_area.getExtent();
- s16 y_start = surface_y + 1;
- u32 i = vm->m_area.index(x, y_start, z);
- for (s16 y = y_start; y <= node_max.Y; y++) {
- if (mudcount >= mud_add_amount)
- break;
+ vm->m_data[i] = addnode;
+ mudcount++;
- vm->m_data[i] = addnode;
- mudcount++;
-
- VoxelArea::add_y(em, i, 1);
- }
+ VoxelArea::add_y(em, i, 1);
}
+ }
}
+
void MapgenV6::flowMud(s16 &mudflow_minpos, s16 &mudflow_maxpos)
{
const v3s16 &em = vm->m_area.getExtent();
static const v3s16 dirs4[4] = {
- v3s16(0, 0, 1), // Back
- v3s16(1, 0, 0), // Right
- v3s16(0, 0, -1), // Front
- v3s16(-1, 0, 0), // Left
+ v3s16(0, 0, 1), // Back
+ v3s16(1, 0, 0), // Right
+ v3s16(0, 0, -1), // Front
+ v3s16(-1, 0, 0), // Left
};
-
+
// Iterate twice
for (s16 k = 0; k < 2; k++) {
for (s16 z = mudflow_minpos; z <= mudflow_maxpos; z++)
- for (s16 x = mudflow_minpos; x <= mudflow_maxpos; x++) {
- // Node column position
- v2s16 p2d;
- // Invert coordinates on second iteration to process
- // columns in opposite order, to avoid a directional bias.
- if (k == 1)
- p2d = v2s16(node_max.X, node_max.Z) - v2s16(x, z);
- else
- p2d = v2s16(node_min.X, node_min.Z) + v2s16(x, z);
-
- s16 y = node_max.Y;
-
- while (y >= node_min.Y) {
- for (;; y--) {
- u32 i = vm->m_area.index(p2d.X, y, p2d.Y);
- MapNode *n = nullptr;
-
- // Find next mud node in mapchunk column
- for (; y >= node_min.Y; y--) {
- n = &vm->m_data[i];
- if (n->getContent() == c_dirt ||
- n->getContent() ==
- c_dirt_with_grass ||
- n->getContent() ==
- c_gravel)
- break;
-
- VoxelArea::add_y(em, i, -1);
- }
- if (y < node_min.Y)
- // No mud found in mapchunk
- // column, process the next column
+ for (s16 x = mudflow_minpos; x <= mudflow_maxpos; x++) {
+ // Node column position
+ v2s16 p2d;
+ // Invert coordinates on second iteration to process columns in
+ // opposite order, to avoid a directional bias.
+ if (k == 1)
+ p2d = v2s16(node_max.X, node_max.Z) - v2s16(x, z);
+ else
+ p2d = v2s16(node_min.X, node_min.Z) + v2s16(x, z);
+
+ s16 y = node_max.Y;
+
+ while (y >= node_min.Y) {
+ for (;; y--) {
+ u32 i = vm->m_area.index(p2d.X, y, p2d.Y);
+ MapNode *n = nullptr;
+
+ // Find next mud node in mapchunk column
+ for (; y >= node_min.Y; y--) {
+ n = &vm->m_data[i];
+ if (n->getContent() == c_dirt ||
+ n->getContent() == c_dirt_with_grass ||
+ n->getContent() == c_gravel)
break;
- if (n->getContent() == c_dirt ||
- n->getContent() ==
- c_dirt_with_grass) {
- // Convert dirt_with_grass to dirt
- n->setContent(c_dirt);
- // Don't flow mud if the stuff
- // under it is not mud, to leave
- // at least 1 node of mud.
- u32 i2 = i;
- VoxelArea::add_y(em, i2, -1);
- MapNode *n2 = &vm->m_data[i2];
- if (n2->getContent() != c_dirt &&
- n2->getContent() !=
- c_dirt_with_grass)
- // Find next mud node in
- // column
- continue;
- }
+ VoxelArea::add_y(em, i, -1);
+ }
+ if (y < node_min.Y)
+ // No mud found in mapchunk column, process the next column
+ break;
- // Check if node above is walkable. If so,
- // cancel flowing as if node above keeps
- // it in place.
- u32 i3 = i;
- VoxelArea::add_y(em, i3, 1);
- MapNode *n3 = &vm->m_data[i3];
- if (ndef->get(*n3).walkable)
+ if (n->getContent() == c_dirt || n->getContent() == c_dirt_with_grass) {
+ // Convert dirt_with_grass to dirt
+ n->setContent(c_dirt);
+ // Don't flow mud if the stuff under it is not mud,
+ // to leave at least 1 node of mud.
+ u32 i2 = i;
+ VoxelArea::add_y(em, i2, -1);
+ MapNode *n2 = &vm->m_data[i2];
+ if (n2->getContent() != c_dirt &&
+ n2->getContent() != c_dirt_with_grass)
// Find next mud node in column
continue;
+ }
+
+ // Check if node above is walkable. If so, cancel
+ // flowing as if node above keeps it in place.
+ u32 i3 = i;
+ VoxelArea::add_y(em, i3, 1);
+ MapNode *n3 = &vm->m_data[i3];
+ if (ndef->get(*n3).walkable)
+ // Find next mud node in column
+ continue;
+
+ // Drop mud on one side
+ for (const v3s16 &dirp : dirs4) {
+ u32 i2 = i;
+ // Move to side
+ VoxelArea::add_p(em, i2, dirp);
+ // Check that side is air
+ MapNode *n2 = &vm->m_data[i2];
+ if (ndef->get(*n2).walkable)
+ continue;
+
+ // Check that under side is air
+ VoxelArea::add_y(em, i2, -1);
+ n2 = &vm->m_data[i2];
+ if (ndef->get(*n2).walkable)
+ continue;
- // Drop mud on one side
- for (const v3s16 &dirp : dirs4) {
- u32 i2 = i;
- // Move to side
- VoxelArea::add_p(em, i2, dirp);
- // Check that side is air
- MapNode *n2 = &vm->m_data[i2];
- if (ndef->get(*n2).walkable)
- continue;
-
- // Check that under side is air
+ // Loop further down until not air
+ s16 y2 = y - 1; // y of i2
+ bool dropped_to_unknown = false;
+ do {
+ y2--;
VoxelArea::add_y(em, i2, -1);
n2 = &vm->m_data[i2];
- if (ndef->get(*n2).walkable)
- continue;
-
- // Loop further down until not air
- s16 y2 = y - 1; // y of i2
- bool dropped_to_unknown = false;
- do {
- y2--;
- VoxelArea::add_y(em, i2,
- -1);
- n2 = &vm->m_data[i2];
- // If out of area or in
- // ungenerated world
- if (y2 < full_node_min.Y ||
- n2->getContent() ==
- CONTENT_IGNORE) {
- dropped_to_unknown =
- true;
- break;
- }
- } while (!ndef->get(*n2).walkable);
-
- if (!dropped_to_unknown) {
- // Move up one so that
- // we're in air
- VoxelArea::add_y(em, i2,
- 1);
- // Move mud to new place,
- // and if outside mapchunk
- // remove any decorations
- // above removed or placed
- // mud.
- moveMud(i, i2, i3, p2d,
- em);
+ // If out of area or in ungenerated world
+ if (y2 < full_node_min.Y || n2->getContent() == CONTENT_IGNORE) {
+ dropped_to_unknown = true;
+ break;
}
- // Done, find next mud node in
- // column
- break;
+ } while (!ndef->get(*n2).walkable);
+
+ if (!dropped_to_unknown) {
+ // Move up one so that we're in air
+ VoxelArea::add_y(em, i2, 1);
+ // Move mud to new place, and if outside mapchunk remove
+ // any decorations above removed or placed mud.
+ moveMud(i, i2, i3, p2d, em);
}
+ // Done, find next mud node in column
+ break;
}
}
}
+ }
}
}
-void MapgenV6::moveMud(u32 remove_index, u32 place_index, u32 above_remove_index,
- v2s16 pos, v3s16 em)
+
+void MapgenV6::moveMud(u32 remove_index, u32 place_index,
+ u32 above_remove_index, v2s16 pos, v3s16 em)
{
MapNode n_air(CONTENT_AIR);
// Copy mud from old place to new place
@@ -916,20 +919,17 @@ void MapgenV6::moveMud(u32 remove_index, u32 place_index, u32 above_remove_index
// Outside the mapchunk decorations may need to be removed if above removed
// mud or if half-buried in placed mud. Placed mud is to the side of pos so
// use 'pos.X >= node_max.X' etc.
- if (pos.X >= node_max.X || pos.X <= node_min.X || pos.Y >= node_max.Z ||
- pos.Y <= node_min.Z) {
+ if (pos.X >= node_max.X || pos.X <= node_min.X ||
+ pos.Y >= node_max.Z || pos.Y <= node_min.Z) {
// 'above remove' node is above removed mud. If it is not air, water or
// 'ignore' it is a decoration that needs removing. Also search upwards
// to remove a possible stacked decoration.
// Check for 'ignore' because stacked decorations can penetrate into
// 'ignore' nodes above the mapchunk.
while (vm->m_area.contains(above_remove_index) &&
- vm->m_data[above_remove_index].getContent() !=
- CONTENT_AIR &&
- vm->m_data[above_remove_index].getContent() !=
- c_water_source &&
- vm->m_data[above_remove_index].getContent() !=
- CONTENT_IGNORE) {
+ vm->m_data[above_remove_index].getContent() != CONTENT_AIR &&
+ vm->m_data[above_remove_index].getContent() != c_water_source &&
+ vm->m_data[above_remove_index].getContent() != CONTENT_IGNORE) {
vm->m_data[above_remove_index] = n_air;
VoxelArea::add_y(em, above_remove_index, 1);
}
@@ -946,9 +946,10 @@ void MapgenV6::moveMud(u32 remove_index, u32 place_index, u32 above_remove_index
}
}
+
void MapgenV6::placeTreesAndJungleGrass()
{
- // TimeTaker t("placeTrees");
+ //TimeTaker t("placeTrees");
if (node_max.Y < water_level)
return;
@@ -968,96 +969,98 @@ void MapgenV6::placeTreesAndJungleGrass()
// N.B. We must add jungle grass first, since tree leaves will
// obstruct the ground, giving us a false ground level
for (s16 z0 = 0; z0 < div; z0++)
- for (s16 x0 = 0; x0 < div; x0++) {
- // Center position of part of division
- v2s16 p2d_center(node_min.X + sidelen / 2 + sidelen * x0,
- node_min.Z + sidelen / 2 + sidelen * z0);
- // Minimum edge of part of division
- v2s16 p2d_min(node_min.X + sidelen * x0,
- node_min.Z + sidelen * z0);
- // Maximum edge of part of division
- v2s16 p2d_max(node_min.X + sidelen + sidelen * x0 - 1,
- node_min.Z + sidelen + sidelen * z0 - 1);
-
- // Get biome at center position of part of division
- BiomeV6Type bt = getBiome(p2d_center);
-
- // Amount of trees
- u32 tree_count;
- if (bt == BT_JUNGLE || bt == BT_TAIGA || bt == BT_NORMAL) {
- tree_count = area * getTreeAmount(p2d_center);
- if (bt == BT_JUNGLE)
- tree_count *= 4;
- } else {
- tree_count = 0;
- }
+ for (s16 x0 = 0; x0 < div; x0++) {
+ // Center position of part of division
+ v2s16 p2d_center(
+ node_min.X + sidelen / 2 + sidelen * x0,
+ node_min.Z + sidelen / 2 + sidelen * z0
+ );
+ // Minimum edge of part of division
+ v2s16 p2d_min(
+ node_min.X + sidelen * x0,
+ node_min.Z + sidelen * z0
+ );
+ // Maximum edge of part of division
+ v2s16 p2d_max(
+ node_min.X + sidelen + sidelen * x0 - 1,
+ node_min.Z + sidelen + sidelen * z0 - 1
+ );
+
+ // Get biome at center position of part of division
+ BiomeV6Type bt = getBiome(p2d_center);
+
+ // Amount of trees
+ u32 tree_count;
+ if (bt == BT_JUNGLE || bt == BT_TAIGA || bt == BT_NORMAL) {
+ tree_count = area * getTreeAmount(p2d_center);
+ if (bt == BT_JUNGLE)
+ tree_count *= 4;
+ } else {
+ tree_count = 0;
+ }
- // Add jungle grass
- if (bt == BT_JUNGLE) {
- float humidity = getHumidity(p2d_center);
- u32 grass_count = 5 * humidity * tree_count;
- for (u32 i = 0; i < grass_count; i++) {
- s16 x = grassrandom.range(p2d_min.X, p2d_max.X);
- s16 z = grassrandom.range(p2d_min.Y, p2d_max.Y);
- int mapindex = central_area_size.X *
- (z - node_min.Z) +
- (x - node_min.X);
- s16 y = heightmap[mapindex];
- if (y < water_level)
- continue;
+ // Add jungle grass
+ if (bt == BT_JUNGLE) {
+ float humidity = getHumidity(p2d_center);
+ u32 grass_count = 5 * humidity * tree_count;
+ for (u32 i = 0; i < grass_count; i++) {
+ s16 x = grassrandom.range(p2d_min.X, p2d_max.X);
+ s16 z = grassrandom.range(p2d_min.Y, p2d_max.Y);
+ int mapindex = central_area_size.X * (z - node_min.Z)
+ + (x - node_min.X);
+ s16 y = heightmap[mapindex];
+ if (y < water_level)
+ continue;
- u32 vi = vm->m_area.index(x, y, z);
- // place on dirt_with_grass, since we know it is
- // exposed to sunlight
- if (vm->m_data[vi].getContent() ==
- c_dirt_with_grass) {
- VoxelArea::add_y(em, vi, 1);
- vm->m_data[vi] = n_junglegrass;
- }
+ u32 vi = vm->m_area.index(x, y, z);
+ // place on dirt_with_grass, since we know it is exposed to sunlight
+ if (vm->m_data[vi].getContent() == c_dirt_with_grass) {
+ VoxelArea::add_y(em, vi, 1);
+ vm->m_data[vi] = n_junglegrass;
}
}
+ }
- // Put trees in random places on part of division
- for (u32 i = 0; i < tree_count; i++) {
- s16 x = myrand_range(p2d_min.X, p2d_max.X);
- s16 z = myrand_range(p2d_min.Y, p2d_max.Y);
- int mapindex = central_area_size.X * (z - node_min.Z) +
- (x - node_min.X);
- s16 y = heightmap[mapindex];
- // Don't make a tree under water level
- // Don't make a tree so high that it doesn't fit
- if (y < water_level || y > node_max.Y - 6)
+ // Put trees in random places on part of division
+ for (u32 i = 0; i < tree_count; i++) {
+ s16 x = myrand_range(p2d_min.X, p2d_max.X);
+ s16 z = myrand_range(p2d_min.Y, p2d_max.Y);
+ int mapindex = central_area_size.X * (z - node_min.Z)
+ + (x - node_min.X);
+ s16 y = heightmap[mapindex];
+ // Don't make a tree under water level
+ // Don't make a tree so high that it doesn't fit
+ if (y < water_level || y > node_max.Y - 6)
+ continue;
+
+ v3s16 p(x, y, z);
+ // Trees grow only on mud and grass
+ {
+ u32 i = vm->m_area.index(p);
+ content_t c = vm->m_data[i].getContent();
+ if (c != c_dirt &&
+ c != c_dirt_with_grass &&
+ c != c_dirt_with_snow)
continue;
+ }
+ p.Y++;
- v3s16 p(x, y, z);
- // Trees grow only on mud and grass
- {
- u32 i = vm->m_area.index(p);
- content_t c = vm->m_data[i].getContent();
- if (c != c_dirt && c != c_dirt_with_grass &&
- c != c_dirt_with_snow)
- continue;
- }
- p.Y++;
-
- // Make a tree
- if (bt == BT_JUNGLE) {
- treegen::make_jungletree(*vm, p, ndef, myrand());
- } else if (bt == BT_TAIGA) {
- treegen::make_pine_tree(*vm, p - v3s16(0, 1, 0),
- ndef, myrand());
- } else if (bt == BT_NORMAL) {
- bool is_apple_tree =
- (myrand_range(0, 3) == 0) &&
+ // Make a tree
+ if (bt == BT_JUNGLE) {
+ treegen::make_jungletree(*vm, p, ndef, myrand());
+ } else if (bt == BT_TAIGA) {
+ treegen::make_pine_tree(*vm, p - v3s16(0, 1, 0), ndef, myrand());
+ } else if (bt == BT_NORMAL) {
+ bool is_apple_tree = (myrand_range(0, 3) == 0) &&
getHaveAppleTree(v2s16(x, z));
- treegen::make_tree(*vm, p, is_apple_tree, ndef,
- myrand());
- }
+ treegen::make_tree(*vm, p, is_apple_tree, ndef, myrand());
}
}
- // printf("placeTreesAndJungleGrass: %dms\n", t.stop());
+ }
+ //printf("placeTreesAndJungleGrass: %dms\n", t.stop());
}
+
void MapgenV6::growGrass() // Add surface nodes
{
MapNode n_dirt_with_grass(c_dirt_with_grass);
@@ -1068,54 +1071,53 @@ void MapgenV6::growGrass() // Add surface nodes
u32 index = 0;
for (s16 z = full_node_min.Z; z <= full_node_max.Z; z++)
- for (s16 x = full_node_min.X; x <= full_node_max.X; x++, index++) {
- // Find the lowest surface to which enough light ends up to make
- // grass grow. Basically just wait until not air and not leaves.
- s16 surface_y = 0;
- {
- u32 i = vm->m_area.index(x, node_max.Y, z);
- s16 y;
- // Go to ground level
- for (y = node_max.Y; y >= full_node_min.Y; y--) {
- MapNode &n = vm->m_data[i];
- if (ndef->get(n).param_type != CPT_LIGHT ||
- ndef->get(n).liquid_type !=
- LIQUID_NONE ||
- n.getContent() == c_ice)
- break;
- VoxelArea::add_y(em, i, -1);
- }
- surface_y = (y >= full_node_min.Y) ? y : full_node_min.Y;
+ for (s16 x = full_node_min.X; x <= full_node_max.X; x++, index++) {
+ // Find the lowest surface to which enough light ends up to make
+ // grass grow. Basically just wait until not air and not leaves.
+ s16 surface_y = 0;
+ {
+ u32 i = vm->m_area.index(x, node_max.Y, z);
+ s16 y;
+ // Go to ground level
+ for (y = node_max.Y; y >= full_node_min.Y; y--) {
+ MapNode &n = vm->m_data[i];
+ if (ndef->get(n).param_type != CPT_LIGHT ||
+ ndef->get(n).liquid_type != LIQUID_NONE ||
+ n.getContent() == c_ice)
+ break;
+ VoxelArea::add_y(em, i, -1);
}
+ surface_y = (y >= full_node_min.Y) ? y : full_node_min.Y;
+ }
- BiomeV6Type bt = getBiome(index, v2s16(x, z));
- u32 i = vm->m_area.index(x, surface_y, z);
- content_t c = vm->m_data[i].getContent();
- if (surface_y >= water_level - 20) {
- if (bt == BT_TAIGA && c == c_dirt) {
+ BiomeV6Type bt = getBiome(index, v2s16(x, z));
+ u32 i = vm->m_area.index(x, surface_y, z);
+ content_t c = vm->m_data[i].getContent();
+ if (surface_y >= water_level - 20) {
+ if (bt == BT_TAIGA && c == c_dirt) {
+ vm->m_data[i] = n_dirt_with_snow;
+ } else if (bt == BT_TUNDRA) {
+ if (c == c_dirt) {
+ vm->m_data[i] = n_snowblock;
+ VoxelArea::add_y(em, i, -1);
vm->m_data[i] = n_dirt_with_snow;
- } else if (bt == BT_TUNDRA) {
- if (c == c_dirt) {
- vm->m_data[i] = n_snowblock;
- VoxelArea::add_y(em, i, -1);
- vm->m_data[i] = n_dirt_with_snow;
- } else if (c == c_stone &&
- surface_y < node_max.Y) {
- VoxelArea::add_y(em, i, 1);
- vm->m_data[i] = n_snowblock;
- }
- } else if (c == c_dirt) {
- vm->m_data[i] = n_dirt_with_grass;
+ } else if (c == c_stone && surface_y < node_max.Y) {
+ VoxelArea::add_y(em, i, 1);
+ vm->m_data[i] = n_snowblock;
}
+ } else if (c == c_dirt) {
+ vm->m_data[i] = n_dirt_with_grass;
}
}
+ }
}
+
void MapgenV6::generateCaves(int max_stone_y)
{
float cave_amount = NoisePerlin2D(np_cave, node_min.X, node_min.Y, seed);
- int volume_nodes = (node_max.X - node_min.X + 1) * (node_max.Y - node_min.Y + 1) *
- MAP_BLOCKSIZE;
+ int volume_nodes = (node_max.X - node_min.X + 1) *
+ (node_max.Y - node_min.Y + 1) * MAP_BLOCKSIZE;
cave_amount = MYMAX(0.0, cave_amount);
u32 caves_count = cave_amount * volume_nodes / 50000;
u32 bruises_count = 1;
@@ -1126,16 +1128,15 @@ void MapgenV6::generateCaves(int max_stone_y)
bruises_count = ps.range(0, ps.range(0, 2));
if (getBiome(v2s16(node_min.X, node_min.Z)) == BT_DESERT) {
- caves_count /= 3;
+ caves_count /= 3;
bruises_count /= 3;
}
for (u32 i = 0; i < caves_count + bruises_count; i++) {
- CavesV6 cave(ndef, &gennotify, water_level, c_water_source,
- c_lava_source);
+ CavesV6 cave(ndef, &gennotify, water_level, c_water_source, c_lava_source);
bool large_cave = (i >= caves_count);
- cave.makeCave(vm, node_min, node_max, &ps, &ps2, large_cave, max_stone_y,
- heightmap);
+ cave.makeCave(vm, node_min, node_max, &ps, &ps2,
+ large_cave, max_stone_y, heightmap);
}
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-07-20 22:00:08 +0000