int MapgenIndev::generateGround() {
//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), n_dirt(c_dirt),n_sand(c_sand), n_gravel(c_gravel), n_lava_source(c_lava_source);
int stone_surface_max_y = -MAX_MAP_GENERATION_LIMIT;
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;
auto bt = getBiome(index, v3POS(x, surface_y, z));
s16 heat = m_emerge->env->m_use_weather ? m_emerge->env->getServerMap().updateBlockHeat(m_emerge->env, v3POS(x,node_max.Y,z), nullptr, &heat_cache) : 0;
// Fill ground with stone
v3POS 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]) {
if (y <= surface_y) {
int index3 = (z - node_min.Z) * zstride + (y - node_min.Y) * ystride + (x - node_min.X) * xstride;
if (cave_noise_threshold && noise_cave_indev->result[index3] > cave_noise_threshold) {
vm->m_data[i] = n_air;
} else {
auto n = (y > water_level - surface_y && bt == BT_DESERT) ? n_desert_stone : layers_get(index3);
bool protect = n.getContent() != CONTENT_AIR;
if (cave_noise_threshold && noise_cave_indev->result[index3] > cave_noise_threshold - 50) {
vm->m_data[i] = protect ? n_stone : n; //cave shell without layers
protect = true;
} else {
vm->m_data[i] = n;
}
if (protect)
vm->m_flags[i] |= VOXELFLAG_CHECKED2; // no cave liquid
}
} else if (y <= water_level) {
vm->m_data[i] = (heat < 0 && y > heat/3) ? n_ice : n_water_source;
if (liquid_pressure && y <= 0)
vm->m_data[i].addLevel(m_emerge->ndef, water_level - y, 1);
} else {
vm->m_data[i] = n_air;
}
}
vm->m_area.add_y(em, i, 1);
}
}
return stone_surface_max_y;
}
void MapgenV7::generateBaseTerrain(s16 *stone_surface_min_y, s16 *stone_surface_max_y)
{
MapNode n_air(CONTENT_AIR);
MapNode n_stone(c_stone);
MapNode n_water(c_water_source);
MapNode n_ice(c_ice);
v3s16 em = vm->m_area.getExtent();
s16 surface_min_y = MAX_MAP_GENERATION_LIMIT;
s16 surface_max_y = -MAX_MAP_GENERATION_LIMIT;
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++) {
float surface_height = baseTerrainLevelFromMap(index);
s16 surface_y = (s16)surface_height;
heightmap[index] = surface_y;
ridge_heightmap[index] = surface_y;
if (surface_y < surface_min_y)
surface_min_y = surface_y;
if (surface_y > surface_max_y)
surface_max_y = surface_y;
s16 heat = m_emerge->env->m_use_weather ? m_emerge->env->getServerMap().updateBlockHeat(m_emerge->env, v3POS(x,node_max.Y,z), nullptr, &heat_cache) : 0;
u32 i = vm->m_area.index(x, node_min.Y - 1, z);
for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) {
if (vm->m_data[i].getContent() == CONTENT_IGNORE) {
if (y <= surface_y) {
int index3 = (z - node_min.Z) * zstride +
(y - node_min.Y + 1) * ystride +
(x - node_min.X);
vm->m_data[i] = layers_get(index3);
}
else if (y <= water_level)
{
vm->m_data[i] = (heat < 0 && y > heat/3) ? n_ice : n_water;
if (liquid_pressure && y <= 0)
vm->m_data[i].addLevel(m_emerge->ndef, water_level - y, 1);
}
else
vm->m_data[i] = n_air;
}
vm->m_area.add_y(em, i, 1);
}
}
*stone_surface_min_y = surface_min_y;
*stone_surface_max_y = surface_max_y;
}
int MapgenV6::generateGround()
{
//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);
int stone_surface_max_y = -MAX_MAP_GENERATION_LIMIT;
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(v3POS(x, node_min.Y, z));
s16 heat = m_emerge->env->m_use_weather ? m_emerge->env->getServerMap().updateBlockHeat(m_emerge->env, v3POS(x,node_max.Y,z), nullptr, &heat_cache) : 0;
// Fill ground with stone
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 - surface_y
&& bt == BT_DESERT) ?
n_desert_stone : n_stone;
} else if (y <= water_level) {
vm->m_data[i] = ((heat < 0 && y > heat/3) || (y >= MGV6_ICE_BASE
&& bt == BT_TUNDRA)) ?
n_ice : n_water_source;
if (liquid_pressure && y <= 0)
vm->m_data[i].addLevel(m_emerge->ndef, water_level - y, 1);
} else {
vm->m_data[i] = n_air;
}
}
vm->m_area.add_y(em, i, 1);
}
}
return stone_surface_max_y;
}
int MapgenV6::generateGround()
{
//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);
int stone_surface_max_y = -MAP_GENERATION_LIMIT;
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
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 >= DESERT_STONE_BASE
&& bt == BT_DESERT) ?
n_desert_stone : n_stone;
} else if (y <= water_level) {
vm->m_data[i] = (y >= ICE_BASE
&& bt == BT_TUNDRA) ?
n_ice : n_water_source;
} else {
vm->m_data[i] = n_air;
}
}
vm->m_area.add_y(em, i, 1);
}
}
return stone_surface_max_y;
}
void MapgenV7::generateRidgeTerrain()
{
if (node_max.Y < water_level)
return;
MapNode n_water(c_water_source);
MapNode n_ice(c_ice);
MapNode n_air(CONTENT_AIR);
u32 index = 0;
float width = 0.2; // TODO: figure out acceptable perlin noise values
for (s16 z = node_min.Z; z <= node_max.Z; z++)
for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) {
u32 vi = vm->m_area.index(node_min.X, y, z);
for (s16 x = node_min.X; x <= node_max.X; x++, index++, vi++) {
int j = (z - node_min.Z) * csize.X + (x - node_min.X);
if (heightmap[j] < water_level - 16)
continue;
float uwatern = noise_ridge_uwater->result[j] * 2;
if (fabs(uwatern) > width)
continue;
float altitude = y - water_level;
float height_mod = (altitude + 17) / 2.5;
float width_mod = width - fabs(uwatern);
float nridge = noise_ridge->result[index] * MYMAX(altitude, 0) / 7.0;
if (nridge + width_mod * height_mod < 0.6)
continue;
if (y < ridge_heightmap[j])
ridge_heightmap[j] = y - 1;
s16 heat = m_emerge->env->m_use_weather ? m_emerge->env->getServerMap().updateBlockHeat(m_emerge->env, v3POS(x,node_max.Y,z), NULL, &heat_cache) : 0;
MapNode n_water_or_ice = (heat < 0 && y > water_level + heat/4) ? n_ice : n_water;
vm->m_data[vi] = (y > water_level) ? n_air : n_water_or_ice;
}
}
}
int MapgenV6::generateGround() {
//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);
int stone_surface_max_y = -MAP_GENERATION_LIMIT;
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;
BiomeType bt = getBiome(index, v2s16(x, z));
// Fill ground with stone
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 > water_level - surface_y && bt == BT_DESERT) ?
n_desert_stone : n_stone;
} else if (y <= water_level) {
s16 heat = emerge->env->m_use_weather ? emerge->env->getServerMap().updateBlockHeat(emerge->env, v3s16(x,y,z)) : 0;
vm->m_data[i] = (heat < 0 && y > heat/3) ? n_ice : n_water_source;
} else {
vm->m_data[i] = n_air;
}
}
vm->m_area.add_y(em, i, 1);
}
}
return stone_surface_max_y;
}
void CaveV5::carveRoute(v3f vec, float f, bool randomize_xz)
{
MapNode airnode(CONTENT_AIR);
MapNode waternode(c_water_source);
MapNode lavanode(c_lava_source);
MapNode n_ice(c_ice);
v3s16 startp(orp.X, orp.Y, orp.Z);
startp += of;
float nval = NoisePerlin3D(np_caveliquids, startp.X,
startp.Y, startp.Z, mg->seed);
//MapNode liquidnode = nval < 0.40 ? lavanode : waternode;
v3f fp = orp + vec * f;
fp.X += 0.1 * ps->range(-10, 10);
fp.Z += 0.1 * ps->range(-10, 10);
v3s16 cp(fp.X, fp.Y, fp.Z);
s16 d0 = -rs/2;
s16 d1 = d0 + rs;
if (randomize_xz) {
d0 += ps->range(-1, 1);
d1 += ps->range(-1, 1);
}
for (s16 z0 = d0; z0 <= d1; z0++) {
s16 si = rs / 2 - MYMAX(0, abs(z0) - rs / 7 - 1);
for (s16 x0 = -si - ps->range(0,1); x0 <= si - 1 + ps->range(0,1); x0++) {
s16 maxabsxz = MYMAX(abs(x0), abs(z0));
s16 si2 = rs / 2 - MYMAX(0, maxabsxz - rs / 7 - 1);
for (s16 y0 = -si2; y0 <= si2; y0++) {
if (large_cave_is_flat) {
// Make large caves not so tall
if (rs > 7 && abs(y0) >= rs / 3)
continue;
}
v3s16 p(cp.X + x0, cp.Y + y0, cp.Z + z0);
p += of;
if (vm->m_area.contains(p) == false)
continue;
u32 i = vm->m_area.index(p);
content_t c = vm->m_data[i].getContent();
if (!ndef->get(c).is_ground_content)
continue;
s16 heat = mg->m_emerge->env->m_use_weather ? mg->m_emerge->env->getServerMap().updateBlockHeat(mg->m_emerge->env, p, nullptr, &mg->heat_cache) : 0;
MapNode n_water_or_ice = (heat < 0 && (p.Y > water_level + heat/4 || p.Y > startp.Y - 2 + heat/4)) ? n_ice : waternode;
MapNode liquidnode = nval < 0.40 ? lavanode : n_water_or_ice;
int full_ymin = node_min.Y - MAP_BLOCKSIZE;
int full_ymax = node_max.Y + MAP_BLOCKSIZE;
if (flooded && full_ymin < water_level &&
full_ymax > water_level)
vm->m_data[i] = (p.Y <= water_level) ?
n_water_or_ice : airnode;
else if (flooded && full_ymax < water_level)
vm->m_data[i] = (p.Y < startp.Y - 4) ?
liquidnode : airnode;
else
vm->m_data[i] = airnode;
}
}
}
}
void CavesV6::carveRoute(v3f vec, float f, bool randomize_xz,
bool tunnel_above_ground)
{
MapNode airnode(CONTENT_AIR);
MapNode waternode(c_water_source);
MapNode lavanode(c_lava_source);
MapNode n_ice(c_ice);
bool flooded = ps->range(1, 2) == 2;
v3s16 startp(orp.X, orp.Y, orp.Z);
startp += of;
v3f fp = orp + vec * f;
fp.X += 0.1f * ps->range(-10, 10);
fp.Z += 0.1f * ps->range(-10, 10);
v3s16 cp(fp.X, fp.Y, fp.Z);
s16 d0 = -rs / 2;
s16 d1 = d0 + rs;
if (randomize_xz) {
d0 += ps->range(-1, 1);
d1 += ps->range(-1, 1);
}
for (s16 z0 = d0; z0 <= d1; z0++) {
s16 si = rs / 2 - MYMAX(0, abs(z0) - rs / 7 - 1);
for (s16 x0 = -si - ps->range(0,1); x0 <= si - 1 + ps->range(0,1); x0++) {
if (tunnel_above_ground)
continue;
s16 maxabsxz = MYMAX(abs(x0), abs(z0));
s16 si2 = rs / 2 - MYMAX(0, maxabsxz - rs / 7 - 1);
//fmtodomerge: s16 heat = mg->m_emerge->env->m_use_weather ? mg->m_emerge->env->getServerMap().updateBlockHeat(mg->m_emerge->env, v3POS(cp.X + x0, cp.Y + -si2, cp.Z + z0), nullptr, &mg->heat_cache) : 0;
s16 heat = 10;
for (s16 y0 = -si2; y0 <= si2; y0++) {
if (large_cave_is_flat) {
// Make large caves not so tall
if (rs > 7 && abs(y0) >= rs / 3)
continue;
}
v3s16 p(cp.X + x0, cp.Y + y0, cp.Z + z0);
p += of;
if (vm->m_area.contains(p) == false)
continue;
u32 i = vm->m_area.index(p);
content_t c = vm->m_data[i].getContent();
if (!c || c == CONTENT_AIR || !ndef->get(c).is_ground_content)
continue;
if (large_cave) {
int full_ymin = node_min.Y - MAP_BLOCKSIZE;
int full_ymax = node_max.Y + MAP_BLOCKSIZE;
bool protect_huge = vm->m_flags[i] & VOXELFLAG_CHECKED2;
if (flooded && full_ymin < water_level && full_ymax > water_level) {
if (!protect_huge) {
MapNode n_water_or_ice = (heat < 0 && (p.Y > water_level + heat/4 || p.Y > startp.Y - 2 + heat/4)) ? n_ice : waternode;
vm->m_data[i] = (p.Y <= water_level) ? n_water_or_ice : airnode;
}
} else if (flooded && full_ymax < water_level) {
if (!protect_huge)
vm->m_data[i] = (p.Y < startp.Y - 2) ? lavanode : airnode;
} else {
vm->m_data[i] = airnode;
}
} else {
/*
if (c == CONTENT_IGNORE || c == CONTENT_AIR)
continue;
*/
vm->m_data[i] = airnode;
vm->m_flags[i] |= VMANIP_FLAG_CAVE;
}
}
}
}
}
int MapgenMath::generateTerrain() {
MapNode n_ice(c_ice);
u32 index = 0;
v3POS em = vm->m_area.getExtent();
auto zstride_1d = csize.X * (csize.Y + 1);
/* debug
v3f vec0 = (v3f(node_min.X, node_min.Y, node_min.Z) - center) * scale ;
errorstream << " X=" << node_min.X << " Y=" << node_min.Y << " Z=" << node_min.Z
//<< " N="<< mengersponge(vec0.X, vec0.Y, vec0.Z, distance, iterations)
<< " N=" << (*func)(vec0.X, vec0.Y, vec0.Z, distance, iterations)
<< " Sc=" << scale << " gen=" << params["generator"].asString() << " J=" << Json::FastWriter().write(params) << std::endl;
*/
//errorstream << Json::StyledWriter().write( mg_params->params ).c_str()<< std::endl;
//errorstream << " iterations="<<iterations<< " scale="<<scale <<" invert="<<invert<< std::endl;
#if USE_MANDELBULBER
v3f vec0(node_min.X, node_min.Y, node_min.Z);
vec0 = (vec0 - center) * scale;
/*
errorstream << " X=" << node_min.X << " Y=" << node_min.Y << " Z=" << node_min.Z
<< " N=" << Compute<normal_mode>(CVector3(vec0.X, vec0.Y, vec0.Z), mg_params->par)
//<<" F="<< Compute<fake_AO>(CVector3(node_min.X,node_min.Y,node_min.Z), par)
//<<" L="<<node_min.getLength()<< " -="<<node_min.getLength() - Compute<normal_mode>(CVector3(node_min.X,node_min.Y,node_min.Z), par)
<< " Sc=" << scale << " internal=" << internal
<< std::endl;
*/
#endif
double d = 0;
for (s16 z = node_min.Z; z <= node_max.Z; z++) {
for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
s16 heat = m_emerge->env->m_use_weather ? m_emerge->env->getServerMap().updateBlockHeat(m_emerge->env, v3POS(x,node_max.Y,z), nullptr, &heat_cache) : 0;
u32 i = vm->m_area.index(x, node_min.Y, z);
for (s16 y = node_min.Y; y <= node_max.Y; y++) {
v3f vec = (v3f(x, y, z) - center) * scale ;
if (invert_xy)
std::swap(vec.X, vec.Y);
if (invert_yz)
std::swap(vec.Y, vec.Z);
#if USE_MANDELBULBER
if (!internal)
d = Compute<normal_mode>(CVector3(vec.X, vec.Y, vec.Z), mg_params->par);
else
#endif
if (internal)
d = (*func)(vec.X, vec.Y, vec.Z, scale.X, iterations);
if ((!invert && d > 0) || (invert && d == 0) ) {
if (!vm->m_data[i]) {
//vm->m_data[i] = (y > water_level + biome->filler) ?
// MapNode(biome->c_filler) : n_stone;
if (invert) {
int index3 = (z - node_min.Z) * zstride_1d +
(y - node_min.Y) * ystride +
(x - node_min.X);
vm->m_data[i] = Mapgen_features::layers_get(index3);
} else {
vm->m_data[i] = layers_get(d, result_max);
}
// vm->m_data[i] = (y > water_level + biome->filler) ?
// MapNode(biome->c_filler) : layers_get(d, result_max);
}
} else if (y <= water_level) {
vm->m_data[i] = (heat < 0 && y > heat/3) ? n_ice : n_water;
} else {
vm->m_data[i] = n_air;
}
vm->m_area.add_y(em, i, 1);
}
}
}
return 0;
}
