# Controls the density of mountain-type floatlands.

# Is a noise offset added to the 'mgv7_np_mountain' noise value.

mgv7_float_mount_density (Floatland mountain density) float 0.6

# Typical maximum height, above and below midpoint, of floatland mountains.

mgv7_float_mount_height (Floatland mountain height) float 128.0

# Alters how mountain-type floatlands taper above and below midpoint.

mgv7_float_mount_exponent (Floatland mountain exponent) float 0.75

# Y-level of floatland midpoint and lake surface.

mgv7_floatland_level (Floatland level) int 1280

# Y-level to which floatland shadows extend.

mgv7_shadow_limit (Shadow limit) int 1024

# Defines areas of floatland smooth terrain.

# Smooth floatlands occur when noise > 0.

mgv7_np_floatland_base (Floatland base noise) noise_params_2d -0.6, 1.5, (600, 600, 600), 114, 5, 0.6, 2.0, eased

# Variation of hill height and lake depth on floatland smooth terrain.

mgv7_np_float_base_height (Floatland base height noise) noise_params_2d 48, 24, (300, 300, 300), 907, 4, 0.7, 2.0, eased

spflags = params->spflags;

mount_zero_level = params->mount_zero_level;

float_mount_density = params->float_mount_density;

float_mount_exponent = params->float_mount_exponent;

floatland_level = params->floatland_level;

shadow_limit = params->shadow_limit;

// This is to avoid a divide-by-zero.

// Parameter will be saved to map_meta.txt in limited form.

params->float_mount_height = std::fmax(params->float_mount_height, 1.0f);

float_mount_height = params->float_mount_height;

if (spflags & MGV7_MOUNTAINS)

new Noise(&params->np_mount_height, seed, csize.X, csize.Z);

if (spflags & MGV7_FLOATLANDS) {

noise_floatland_base =

new Noise(&params->np_floatland_base, seed, csize.X, csize.Z);

noise_float_base_height =

new Noise(&params->np_float_base_height, seed, csize.X, csize.Z);

new Noise(&params->np_ridge_uwater, seed, csize.X, csize.Z);

// 3D noise, 1 up, 1 down overgeneration

new Noise(&params->np_ridge, seed, csize.X, csize.Y + 2, csize.Z);

// 3D noise, 1 up, 1 down overgeneration

if ((spflags & MGV7_MOUNTAINS) || (spflags & MGV7_FLOATLANDS))

noise_mountain =

new Noise(&params->np_mountain, seed, csize.X, csize.Y + 2, csize.Z);

if (spflags & MGV7_MOUNTAINS)

if (spflags & MGV7_FLOATLANDS) {

delete noise_floatland_base;

delete noise_float_base_height;

if ((spflags & MGV7_MOUNTAINS) || (spflags & MGV7_FLOATLANDS))

delete noise_mountain;

np_floatland_base (-0.6, 1.5, v3f(600, 600, 600), 114, 5, 0.6, 2.0),

np_float_base_height (48.0, 24.0, v3f(300, 300, 300), 907, 4, 0.7, 2.0),

settings->getFloatNoEx("mgv7_float_mount_density", float_mount_density);

settings->getFloatNoEx("mgv7_float_mount_height", float_mount_height);

settings->getFloatNoEx("mgv7_float_mount_exponent", float_mount_exponent);

settings->getS16NoEx("mgv7_floatland_level", floatland_level);

settings->getS16NoEx("mgv7_shadow_limit", shadow_limit);

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_floatland_base", np_floatland_base);

settings->getNoiseParams("mgv7_np_float_base_height", np_float_base_height);

settings->getNoiseParams("mgv7_np_mountain", np_mountain);

settings->getNoiseParams("mgv7_np_ridge", np_ridge);

settings->getNoiseParams("mgv7_np_cavern", np_cavern);

settings->getNoiseParams("mgv7_np_cave1", np_cave1);

settings->getNoiseParams("mgv7_np_cave2", np_cave2);

settings->getNoiseParams("mgv7_np_dungeons", np_dungeons);

settings->setS16("mgv7_mount_zero_level", mount_zero_level);

settings->setFloat("mgv7_cave_width", cave_width);

settings->setS16("mgv7_large_cave_depth", large_cave_depth);

settings->setU16("mgv7_small_cave_num_min", small_cave_num_min);

settings->setU16("mgv7_small_cave_num_max", small_cave_num_max);

settings->setU16("mgv7_large_cave_num_min", large_cave_num_min);

settings->setU16("mgv7_large_cave_num_max", large_cave_num_max);

settings->setFloat("mgv7_large_cave_flooded", large_cave_flooded);

settings->setFloat("mgv7_float_mount_density", float_mount_density);

settings->setFloat("mgv7_float_mount_height", float_mount_height);

settings->setFloat("mgv7_float_mount_exponent", float_mount_exponent);

settings->setS16("mgv7_floatland_level", floatland_level);

settings->setS16("mgv7_shadow_limit", shadow_limit);

settings->setS16("mgv7_cavern_limit", cavern_limit);

settings->setS16("mgv7_cavern_taper", cavern_taper);

settings->setFloat("mgv7_cavern_threshold", cavern_threshold);

settings->setS16("mgv7_dungeon_ymin", dungeon_ymin);

settings->setS16("mgv7_dungeon_ymax", dungeon_ymax);

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_floatland_base", np_floatland_base);

settings->setNoiseParams("mgv7_np_float_base_height", np_float_base_height);

settings->setNoiseParams("mgv7_np_mountain", np_mountain);

settings->setNoiseParams("mgv7_np_ridge", np_ridge);

settings->setNoiseParams("mgv7_np_cavern", np_cavern);

settings->setNoiseParams("mgv7_np_cave1", np_cave1);

settings->setNoiseParams("mgv7_np_cave2", np_cave2);

settings->setNoiseParams("mgv7_np_dungeons", np_dungeons);

// Calculate lighting.

// Limit floatland shadow.

bool propagate_shadow = !((spflags & MGV7_FLOATLANDS) &&

node_min.Y <= shadow_limit && node_max.Y >= shadow_limit);

bool MapgenV7::getFloatlandMountainFromMap(int idx_xyz, int idx_xz, s16 y)

{

// Make rim 2 nodes thick to match floatland base terrain

float density_gradient = (y >= floatland_level) ?

-std::pow((float)(y - floatland_level) / float_mount_height,

float_mount_exponent) :

-std::pow((float)(floatland_level - 1 - y) / float_mount_height,

float_mount_exponent);

float floatn = noise_mountain->result[idx_xyz] + float_mount_density;

return floatn + density_gradient >= 0.0f;

}

void MapgenV7::floatBaseExtentFromMap(s16 *float_base_min, s16 *float_base_max,

int idx_xz)

{

// '+1' to avoid a layer of stone at y = MAX_MAP_GENERATION_LIMIT

s16 base_min = MAX_MAP_GENERATION_LIMIT + 1;

s16 base_max = MAX_MAP_GENERATION_LIMIT;

float n_base = noise_floatland_base->result[idx_xz];

if (n_base > 0.0f) {

float n_base_height =

std::fmax(noise_float_base_height->result[idx_xz], 1.0f);

float amp = n_base * n_base_height;

float ridge = n_base_height / 3.0f;

base_min = floatland_level - amp / 1.5f;

if (amp > ridge * 2.0f) {

// Lake bed

base_max = floatland_level - (amp - ridge * 2.0f) / 2.0f;

} else {

// Hills and ridges

float diff = std::fabs(amp - ridge) / ridge;

// Smooth ridges using the 'smoothstep function'

float smooth_diff = diff * diff * (3.0f - 2.0f * diff);

base_max = floatland_level + ridge - smooth_diff * ridge;

}

}

*float_base_min = base_min;

*float_base_max = base_max;

}

if ((spflags & MGV7_MOUNTAINS) || (spflags & MGV7_FLOATLANDS)) {

noise_mountain->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);

}

}

if (spflags & MGV7_FLOATLANDS) {

noise_floatland_base->perlinMap2D(node_min.X, node_min.Z);

noise_float_base_height->perlinMap2D(node_min.X, node_min.Z);

// Get extent of floatland base terrain

// '+1' to avoid a layer of stone at y = MAX_MAP_GENERATION_LIMIT

s16 float_base_min = MAX_MAP_GENERATION_LIMIT + 1;

s16 float_base_max = MAX_MAP_GENERATION_LIMIT;

if (spflags & MGV7_FLOATLANDS)

floatBaseExtentFromMap(&float_base_min, &float_base_max, index2d);

} else if ((spflags & MGV7_FLOATLANDS) &&

((y >= float_base_min && y <= float_base_max) ||

getFloatlandMountainFromMap(index3d, index2d, y))) {

vm->m_data[vi] = n_stone; // Floatland terrain

stone_surface_max_y = node_max.Y;

vm->m_data[vi] = n_water; // Ground level water

} else if ((spflags & MGV7_FLOATLANDS) &&

(y >= float_base_max && y <= floatland_level)) {

vm->m_data[vi] = n_water; // Floatland water

if (node_max.Y < water_level - 16 ||

((spflags & MGV7_FLOATLANDS) && node_max.Y > shadow_limit))

float float_mount_density = 0.6f;

float float_mount_height = 128.0f;

float float_mount_exponent = 0.75f;

s16 floatland_level = 1280;

s16 shadow_limit = 1024;

NoiseParams np_floatland_base;

NoiseParams np_float_base_height;

bool getFloatlandMountainFromMap(int idx_xyz, int idx_xz, s16 y);

void floatBaseExtentFromMap(s16 *float_base_min, s16 *float_base_max, int idx_xz);

float float_mount_density;

float float_mount_height;

float float_mount_exponent;

s16 floatland_level;

s16 shadow_limit;

Noise *noise_floatland_base;

Noise *noise_float_base_height;