///////////////////////////////////////////////////////////////////////////////
-MapgenV6::MapgenV6(int mapgenid, MapgenV6Params *params) {
+MapgenV6::MapgenV6(int mapgenid, MapgenV6Params *params, EmergeManager *emerge) {
this->generating = false;
this->id = mapgenid;
+ this->emerge = emerge;
this->seed = (int)params->seed;
this->water_level = params->water_level;
// Generate general ground level to full area
stone_surface_max_y = generateGround();
+ generateSomething();
+
const s16 max_spread_amount = MAP_BLOCKSIZE;
// Limit dirt flow area by 1 because mud is flown into neighbors.
s16 mudflow_minpos = -max_spread_amount + 1;
// Grow grass
growGrass();
- // Generate some trees
+ // Generate some trees, and add grass, if a jungle
if (flags & MG_TREES)
- placeTrees();
+ placeTreesAndJungleGrass();
+
+ // Generate the registered ores
+ for (unsigned int i = 0; i != emerge->ores.size(); i++) {
+ Ore *ore = emerge->ores[i];
+ ore->generate(this, blockseed + i, node_min, node_max);
+ }
// Calculate lighting
- updateLighting(node_min, node_max);
+ calcLighting(node_min, node_max);
this->generating = false;
}
noise_height_select->perlinMap2D(
x + 0.5 * noise_height_select->np->spread.X,
z + 0.5 * noise_height_select->np->spread.Z);
- }
-
- if (!(flags & MG_FLAT)) {
+
noise_mud->perlinMap2D(
x + 0.5 * noise_mud->np->spread.X,
z + 0.5 * noise_mud->np->spread.Z);
noise_mud->transformNoiseMap();
}
+
noise_beach->perlinMap2D(
x + 0.2 * noise_beach->np->spread.X,
z + 0.7 * noise_beach->np->spread.Z);
}
-void MapgenV6::placeTrees() {
+void MapgenV6::placeTreesAndJungleGrass() {
//TimeTaker t("placeTrees");
+ if (node_max.Y < water_level)
+ return;
+
+ PseudoRandom grassrandom(blockseed + 53);
+ content_t c_junglegrass = ndef->getId("mapgen_junglegrass");
+ // if we don't have junglegrass, don't place cignore... that's bad
+ if (c_junglegrass == CONTENT_IGNORE)
+ c_junglegrass = CONTENT_AIR;
+ MapNode n_junglegrass(c_junglegrass);
+ v3s16 em = vm->m_area.getExtent();
// Divide area into parts
s16 div = 8;
s16 sidelen = central_area_size.X / div;
double area = sidelen * sidelen;
+ // 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
// Amount of trees, jungle area
u32 tree_count = area * getTreeAmount(p2d_center);
- bool is_jungle = (flags & MGV6_JUNGLES) && (getHumidity(p2d_center) > 0.75);
- if (is_jungle)
- tree_count *= 4;
+
+ float humidity;
+ bool is_jungle = false;
+ if (flags & MGV6_JUNGLES) {
+ humidity = getHumidity(p2d_center);
+ if (humidity > 0.75) {
+ is_jungle = true;
+ tree_count *= 4;
+ }
+ }
+
+ // Add jungle grass
+ if (is_jungle) {
+ 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);
+
+ s16 y = find_ground_level(v2s16(x, z)); ////////////////optimize this!
+ if (y < water_level || y < node_min.Y || y > node_max.Y)
+ 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) {
+ vm->m_area.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++) {
}
}
}
- //printf("placeTrees: %dms\n", t.stop());
+ //printf("placeTreesAndJungleGrass: %dms\n", t.stop());
}
}
+void MapgenV6::defineCave(Cave &cave, PseudoRandom ps,
+ v3s16 node_min, bool large_cave) {
+ cave.min_tunnel_diameter = 2;
+ cave.max_tunnel_diameter = ps.range(2,6);
+ cave.dswitchint = ps.range(1,14);
+ cave.flooded = true; //large_cave && ps.range(0,4);
+ if(large_cave){
+ cave.part_max_length_rs = ps.range(2,4);
+ cave.tunnel_routepoints = ps.range(5, ps.range(15,30));
+ cave.min_tunnel_diameter = 5;
+ cave.max_tunnel_diameter = ps.range(7, ps.range(8,24));
+ } else {
+ cave.part_max_length_rs = ps.range(2,9);
+ cave.tunnel_routepoints = ps.range(10, ps.range(15,30));
+ }
+ cave.large_cave_is_flat = (ps.range(0,1) == 0);
+}
+
+
void MapgenV6::generateCaves(int max_stone_y) {
// 24ms @cs=8
//TimeTaker timer1("caves");
break;*/
bool large_cave = (jj >= caves_count);
- s16 min_tunnel_diameter = 2;
- s16 max_tunnel_diameter = ps.range(2,6);
- int dswitchint = ps.range(1,14);
- u16 tunnel_routepoints = 0;
- int part_max_length_rs = 0;
- if(large_cave){
- part_max_length_rs = ps.range(2,4);
- tunnel_routepoints = ps.range(5, ps.range(15,30));
- min_tunnel_diameter = 5;
- max_tunnel_diameter = ps.range(7, ps.range(8,24));
- } else {
- part_max_length_rs = ps.range(2,9);
- tunnel_routepoints = ps.range(10, ps.range(15,30));
- }
- bool large_cave_is_flat = (ps.range(0,1) == 0);
+
+ Cave cave;
+ defineCave(cave, ps, node_min, large_cave);
v3f main_direction(0,0,0);
// Allow a bit more
//(this should be more than the maximum radius of the tunnel)
s16 insure = 10;
- s16 more = max_spread_amount - max_tunnel_diameter / 2 - insure;
+ s16 more = max_spread_amount - cave.max_tunnel_diameter / 2 - insure;
ar += v3s16(1,0,1) * more * 2;
of -= v3s16(1,0,1) * more;
s16 route_y_min = 0;
// Allow half a diameter + 7 over stone surface
- s16 route_y_max = -of.Y + max_stone_y + max_tunnel_diameter/2 + 7;
+ s16 route_y_max = -of.Y + max_stone_y + cave.max_tunnel_diameter/2 + 7;
// Limit maximum to area
route_y_max = rangelim(route_y_max, 0, ar.Y-1);
s16 min = 0;
if(node_min.Y < water_level && node_max.Y > water_level)
{
- min = water_level - max_tunnel_diameter/3 - of.Y;
- route_y_max = water_level + max_tunnel_diameter/3 - of.Y;
+ min = water_level - cave.max_tunnel_diameter/3 - of.Y;
+ route_y_max = water_level + cave.max_tunnel_diameter/3 - of.Y;
}
- route_y_min = ps.range(min, min + max_tunnel_diameter);
+ route_y_min = ps.range(min, min + cave.max_tunnel_diameter);
route_y_min = rangelim(route_y_min, 0, route_y_max);
}
Generate some tunnel starting from orp
*/
- for(u16 j=0; j<tunnel_routepoints; j++)
+ for(u16 j=0; j<cave.tunnel_routepoints; j++)
{
- if(j%dswitchint==0 && large_cave == false)
+ if(j%cave.dswitchint==0 && large_cave == false)
{
main_direction = v3f(
((float)(ps.next()%20)-(float)10)/10,
}
// Randomize size
- s16 min_d = min_tunnel_diameter;
- s16 max_d = max_tunnel_diameter;
+ s16 min_d = cave.min_tunnel_diameter;
+ s16 max_d = cave.max_tunnel_diameter;
s16 rs = ps.range(min_d, max_d);
// Every second section is rough
if(large_cave)
{
maxlen = v3s16(
- rs*part_max_length_rs,
- rs*part_max_length_rs/2,
- rs*part_max_length_rs
+ rs*cave.part_max_length_rs,
+ rs*cave.part_max_length_rs/2,
+ rs*cave.part_max_length_rs
);
}
else
{
maxlen = v3s16(
- rs*part_max_length_rs,
- ps.range(1, rs*part_max_length_rs),
- rs*part_max_length_rs
+ rs*cave.part_max_length_rs,
+ ps.range(1, rs*cave.part_max_length_rs),
+ rs*cave.part_max_length_rs
);
}
/*// Make better floors in small caves
if(y0 <= -rs/2 && rs<=7)
continue;*/
- if (large_cave_is_flat) {
+ if (cave.large_cave_is_flat) {
// Make large caves not so tall
if (rs > 7 && abs(y0) >= rs/3)
continue;
u32 i = vm->m_area.index(p);
if(large_cave) {
- if (full_node_min.Y < water_level &&
+ if (cave.flooded && full_node_min.Y < water_level &&
full_node_max.Y > water_level) {
if (p.Y <= water_level)
vm->m_data[i] = waternode;
else
vm->m_data[i] = airnode;
- } else if (full_node_max.Y < water_level) {
+ } else if (cave.flooded && full_node_max.Y < water_level) {
if (p.Y < startp.Y - 2)
vm->m_data[i] = lavanode;
else