1 /*
2 mapgen_v7.cpp
3 Copyright (C) 2010-2013 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
4 */
5
6 /*
7 This file is part of Freeminer.
8
9 Freeminer is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
13
14 Freeminer is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with Freeminer. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23
24 #include "mapgen.h"
25 #include "voxel.h"
26 #include "noise.h"
27 #include "mapblock.h"
28 #include "mapnode.h"
29 #include "map.h"
30 #include "content_sao.h"
31 #include "nodedef.h"
32 #include "voxelalgorithms.h"
33 #include "profiler.h"
34 #include "settings.h" // For g_settings
35 #include "main.h" // For g_profiler
36 #include "emerge.h"
37 #include "dungeongen.h"
38 #include "cavegen.h"
39 #include "treegen.h"
40 #include "mg_biome.h"
41 #include "mg_ore.h"
42 #include "mg_decoration.h"
43 #include "mapgen_v7.h"
44 #include "mapgen_indev.h" //farscale
45 #include "environment.h"
46 #include "log_types.h"
47
48
49
50 FlagDesc flagdesc_mapgen_v7[] = {
51 {"mountains", MGV7_MOUNTAINS},
52 {"ridges", MGV7_RIDGES},
53 {NULL, 0}
54 };
55
56 ///////////////////////////////////////////////////////////////////////////////
57
58
MapgenV7(int mapgenid,MapgenParams * params,EmergeManager * emerge)59 MapgenV7::MapgenV7(int mapgenid, MapgenParams *params, EmergeManager *emerge):
60 Mapgen_features(mapgenid, params, emerge)
61 {
62 this->generating = false;
63 this->id = mapgenid;
64 this->emerge = emerge;
65 this->bmgr = emerge->biomemgr;
66
67 this->seed = (int)params->seed;
68 this->water_level = params->water_level;
69 this->flags = params->flags;
70 this->gennotify = emerge->gennotify;
71
72 this->csize = v3s16(1, 1, 1) * params->chunksize * MAP_BLOCKSIZE;
73
74 //// amount of elements to skip for the next index
75 //// for noise/height/biome maps (not vmanip)
76 this->ystride = csize.X;
77 this->zstride = csize.X * csize.Y;
78
79 this->biomemap = new u8[csize.X * csize.Z];
80 this->heightmap = new s16[csize.X * csize.Z];
81 this->ridge_heightmap = new s16[csize.X * csize.Z];
82
83 MapgenV7Params *sp = (MapgenV7Params *)params->sparams;
84 this->spflags = sp->spflags;
85
86 //// Terrain noise
87 noise_terrain_base = new Noise(&sp->np_terrain_base, seed, csize.X, csize.Z);
88 noise_terrain_alt = new Noise(&sp->np_terrain_alt, seed, csize.X, csize.Z);
89 noise_terrain_persist = new Noise(&sp->np_terrain_persist, seed, csize.X, csize.Z);
90 noise_height_select = new Noise(&sp->np_height_select, seed, csize.X, csize.Z);
91 noise_filler_depth = new Noise(&sp->np_filler_depth, seed, csize.X, csize.Z);
92 noise_mount_height = new Noise(&sp->np_mount_height, seed, csize.X, csize.Z);
93 noise_ridge_uwater = new Noise(&sp->np_ridge_uwater, seed, csize.X, csize.Z);
94
95 //// 3d terrain noise
96 noise_mountain = new Noise(&sp->np_mountain, seed, csize.X, csize.Y, csize.Z);
97 noise_ridge = new Noise(&sp->np_ridge, seed, csize.X, csize.Y, csize.Z);
98
99 //// Biome noise
100 noise_heat = new Noise(bmgr->np_heat, seed, csize.X, csize.Z);
101 noise_humidity = new Noise(bmgr->np_humidity, seed, csize.X, csize.Z);
102
103 //// Resolve nodes to be used
104 INodeDefManager *ndef = emerge->ndef;
105
106 c_stone = ndef->getId("mapgen_stone");
107 c_dirt = ndef->getId("mapgen_dirt");
108 c_dirt_with_grass = ndef->getId("mapgen_dirt_with_grass");
109 c_sand = ndef->getId("mapgen_sand");
110 c_water_source = ndef->getId("mapgen_water_source");
111 c_lava_source = ndef->getId("mapgen_lava_source");
112 c_ice = ndef->getId("default:ice");
113 if (c_ice == CONTENT_IGNORE)
114 c_ice = c_water_source;
115
116 //freeminer:
117 c_dirt_with_snow = ndef->getId("mapgen_dirt_with_snow");
118 if (c_dirt_with_snow == CONTENT_IGNORE)
119 c_dirt_with_snow = c_dirt;
120 float_islands = sp->float_islands;
121 noise_float_islands1 = new Noise(&sp->np_float_islands1, seed, csize.X, csize.Y, csize.Z);
122 noise_float_islands2 = new Noise(&sp->np_float_islands2, seed, csize.X, csize.Y, csize.Z);
123 noise_float_islands3 = new Noise(&sp->np_float_islands3, seed, csize.X, csize.Z);
124
125 noise_layers = new Noise(&sp->np_layers, seed, csize.X, csize.Y, csize.Z);
126 layers_init(emerge, sp->paramsj);
127 }
128
129
~MapgenV7()130 MapgenV7::~MapgenV7() {
131 delete noise_terrain_base;
132 delete noise_terrain_persist;
133 delete noise_height_select;
134 delete noise_terrain_alt;
135 delete noise_filler_depth;
136 delete noise_mount_height;
137 delete noise_ridge_uwater;
138 delete noise_mountain;
139 delete noise_ridge;
140
141 delete noise_heat;
142 delete noise_humidity;
143
144 delete[] ridge_heightmap;
145 delete[] heightmap;
146 delete[] biomemap;
147 }
148
149
MapgenV7Params()150 MapgenV7Params::MapgenV7Params() {
151 spflags = MGV7_MOUNTAINS | MGV7_RIDGES;
152
153 np_terrain_base = NoiseParams(4, 70, v3f(300, 300, 300), 82341, 6, 0.7);
154 np_terrain_alt = NoiseParams(4, 25, v3f(600, 600, 600), 5934, 5, 0.6);
155 np_terrain_persist = NoiseParams(0.6, 0.1, v3f(500, 500, 500), 539, 3, 0.6);
156 np_height_select = NoiseParams(-0.5, 1, v3f(250, 250, 250), 4213, 5, 0.69);
157 np_filler_depth = NoiseParams(0, 1.2, v3f(150, 150, 150), 261, 4, 0.7);
158 np_mount_height = NoiseParams(100, 30, v3f(500, 500, 500), 72449, 4, 0.6);
159 np_ridge_uwater = NoiseParams(0, 1, v3f(500, 500, 500), 85039, 4, 0.6);
160 np_mountain = NoiseParams(0, 1, v3f(250, 350, 250), 5333, 5, 0.68);
161 np_ridge = NoiseParams(0, 1, v3f(100, 100, 100), 6467, 4, 0.75);
162
163 float_islands = 500;
164 np_float_islands1 = NoiseParams(0, 1, v3f(256, 256, 256), 3683, 6, 0.6, false, 1, 1.5);
165 np_float_islands2 = NoiseParams(0, 1, v3f(8, 8, 8 ), 9292, 2, 0.5, false, 1, 1.5);
166 np_float_islands3 = NoiseParams(0, 1, v3f(256, 256, 256), 6412, 2, 0.5, false, 1, 0.5);
167 np_layers = NoiseParams(500, 500, v3f(100, 50, 100), 3663, 5, 0.6, false, 1, 5, 0.5);
168 }
169
170
readParams(Settings * settings)171 void MapgenV7Params::readParams(Settings *settings) {
172 settings->getFlagStrNoEx("mgv7_spflags", spflags, flagdesc_mapgen_v7);
173
174 settings->getNoiseParams("mgv7_np_terrain_base", np_terrain_base);
175 settings->getNoiseParams("mgv7_np_terrain_alt", np_terrain_alt);
176 settings->getNoiseParams("mgv7_np_terrain_persist", np_terrain_persist);
177 settings->getNoiseParams("mgv7_np_height_select", np_height_select);
178 settings->getNoiseParams("mgv7_np_filler_depth", np_filler_depth);
179 settings->getNoiseParams("mgv7_np_mount_height", np_mount_height);
180 settings->getNoiseParams("mgv7_np_ridge_uwater", np_ridge_uwater);
181 settings->getNoiseParams("mgv7_np_mountain", np_mountain);
182 settings->getNoiseParams("mgv7_np_ridge", np_ridge);
183
184 settings->getS16NoEx("mg_float_islands", float_islands);
185 settings->getNoiseIndevParams("mg_np_float_islands1", np_float_islands1);
186 settings->getNoiseIndevParams("mg_np_float_islands2", np_float_islands2);
187 settings->getNoiseIndevParams("mg_np_float_islands3", np_float_islands3);
188 settings->getNoiseIndevParams("mg_np_layers", np_layers);
189 paramsj = settings->getJson("mg_params", paramsj);
190 }
191
192
writeParams(Settings * settings)193 void MapgenV7Params::writeParams(Settings *settings) {
194 settings->setFlagStr("mgv7_spflags", spflags, flagdesc_mapgen_v7, (u32)-1);
195
196 settings->setNoiseParams("mgv7_np_terrain_base", np_terrain_base);
197 settings->setNoiseParams("mgv7_np_terrain_alt", np_terrain_alt);
198 settings->setNoiseParams("mgv7_np_terrain_persist", np_terrain_persist);
199 settings->setNoiseParams("mgv7_np_height_select", np_height_select);
200 settings->setNoiseParams("mgv7_np_filler_depth", np_filler_depth);
201 settings->setNoiseParams("mgv7_np_mount_height", np_mount_height);
202 settings->setNoiseParams("mgv7_np_ridge_uwater", np_ridge_uwater);
203 settings->setNoiseParams("mgv7_np_mountain", np_mountain);
204 settings->setNoiseParams("mgv7_np_ridge", np_ridge);
205
206 settings->setS16("mg_float_islands", float_islands);
207 settings->setNoiseIndevParams("mg_np_float_islands1", np_float_islands1);
208 settings->setNoiseIndevParams("mg_np_float_islands2", np_float_islands2);
209 settings->setNoiseIndevParams("mg_np_float_islands3", np_float_islands3);
210 settings->setNoiseIndevParams("mg_np_layers", np_layers);
211
212 settings->setJson("mg_params", paramsj);
213 }
214
215
216 ///////////////////////////////////////
217
218
getGroundLevelAtPoint(v2s16 p)219 int MapgenV7::getGroundLevelAtPoint(v2s16 p) {
220 // Base terrain calculation
221 s16 y = baseTerrainLevelAtPoint(p.X, p.Y);
222
223 // Ridge/river terrain calculation
224 float width = 0.3;
225 float uwatern = NoisePerlin2DNoTxfm(noise_ridge_uwater->np, p.X, p.Y, seed) * 2;
226 // actually computing the depth of the ridge is much more expensive;
227 // if inside a river, simply guess
228 if (uwatern >= -width && uwatern <= width)
229 return water_level - 10;
230
231 // Mountain terrain calculation
232 int iters = 128; // don't even bother iterating more than 128 times..
233 while (iters--) {
234 //current point would have been air
235 if (!getMountainTerrainAtPoint(p.X, y, p.Y))
236 return y;
237
238 y++;
239 }
240
241 return y;
242 }
243
244
makeChunk(BlockMakeData * data)245 void MapgenV7::makeChunk(BlockMakeData *data) {
246 assert(data->vmanip);
247 assert(data->nodedef);
248 assert(data->blockpos_requested.X >= data->blockpos_min.X &&
249 data->blockpos_requested.Y >= data->blockpos_min.Y &&
250 data->blockpos_requested.Z >= data->blockpos_min.Z);
251 assert(data->blockpos_requested.X <= data->blockpos_max.X &&
252 data->blockpos_requested.Y <= data->blockpos_max.Y &&
253 data->blockpos_requested.Z <= data->blockpos_max.Z);
254
255 this->generating = true;
256 this->vm = data->vmanip;
257 this->ndef = data->nodedef;
258 //TimeTaker t("makeChunk");
259
260 v3s16 blockpos_min = data->blockpos_min;
261 v3s16 blockpos_max = data->blockpos_max;
262 node_min = blockpos_min * MAP_BLOCKSIZE;
263 node_max = (blockpos_max + v3s16(1, 1, 1)) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
264 full_node_min = (blockpos_min - 1) * MAP_BLOCKSIZE;
265 full_node_max = (blockpos_max + 2) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
266
267 blockseed = emerge->getBlockSeed(full_node_min); //////use getBlockSeed2()!
268
269 // Make some noise
270 calculateNoise();
271
272 if (float_islands && node_max.Y >= float_islands) {
273 float_islands_prepare(node_min, node_max, float_islands);
274 }
275
276 layers_prepare(node_min, node_max);
277
278
279 // Generate base terrain, mountains, and ridges with initial heightmaps
280 s16 stone_surface_max_y = generateTerrain();
281
282 updateHeightmap(node_min, node_max);
283
284 // Calculate biomes
285 bmgr->calcBiomes(csize.X, csize.Z, noise_heat->result,
286 noise_humidity->result, heightmap, biomemap);
287
288 // Actually place the biome-specific nodes and what not
289 generateBiomes();
290
291 generateExperimental();
292
293 if (flags & MG_CAVES)
294 generateCaves(stone_surface_max_y);
295
296 if (flags & MG_DUNGEONS) {
297 DungeonGen dgen(this, NULL);
298 dgen.generate(blockseed, full_node_min, full_node_max);
299 }
300
301 // Generate the registered decorations
302 emerge->decomgr->placeAllDecos(this, blockseed, node_min, node_max);
303
304 // Generate the registered ores
305 emerge->oremgr->placeAllOres(this, blockseed, node_min, node_max);
306
307 // Sprinkle some dust on top after everything else was generated
308 dustTopNodes();
309
310 //printf("makeChunk: %dms\n", t.stop());
311
312 updateLiquid(full_node_min, full_node_max);
313
314 if (flags & MG_LIGHT)
315 calcLighting(node_min - v3s16(1, 0, 1) * MAP_BLOCKSIZE,
316 node_max + v3s16(1, 0, 1) * MAP_BLOCKSIZE);
317 //setLighting(node_min - v3s16(1, 0, 1) * MAP_BLOCKSIZE,
318 // node_max + v3s16(1, 0, 1) * MAP_BLOCKSIZE, 0xFF);
319
320 this->generating = false;
321 }
322
323
calculateNoise()324 void MapgenV7::calculateNoise() {
325 //TimeTaker t("calculateNoise", NULL, PRECISION_MICRO);
326 int x = node_min.X;
327 int y = node_min.Y;
328 int z = node_min.Z;
329
330 noise_height_select->perlinMap2D(x, z);
331 noise_height_select->transformNoiseMap();
332
333 noise_terrain_persist->perlinMap2D(x, z);
334 noise_terrain_persist->transformNoiseMap();
335 float *persistmap = noise_terrain_persist->result;
336 for (int i = 0; i != csize.X * csize.Z; i++)
337 persistmap[i] = rangelim(persistmap[i], 0.4, 0.9);
338
339 noise_terrain_base->perlinMap2DModulated(x, z, persistmap);
340 noise_terrain_base->transformNoiseMap();
341
342 noise_terrain_alt->perlinMap2DModulated(x, z, persistmap);
343 noise_terrain_alt->transformNoiseMap();
344
345 noise_filler_depth->perlinMap2D(x, z);
346
347 if (spflags & MGV7_MOUNTAINS) {
348 noise_mountain->perlinMap3D(x, y, z);
349 noise_mount_height->perlinMap2D(x, z);
350 noise_mount_height->transformNoiseMap();
351 }
352
353 if (spflags & MGV7_RIDGES) {
354 noise_ridge->perlinMap3D(x, y, z);
355 noise_ridge_uwater->perlinMap2D(x, z);
356 }
357
358 noise_heat->perlinMap2D(x, z);
359 noise_humidity->perlinMap2D(x, z);
360
361 //printf("calculateNoise: %dus\n", t.stop());
362 }
363
364
getBiomeAtPoint(v3s16 p)365 Biome *MapgenV7::getBiomeAtPoint(v3s16 p) {
366 float heat = NoisePerlin2D(bmgr->np_heat, p.X, p.Z, seed);
367 float humidity = NoisePerlin2D(bmgr->np_humidity, p.X, p.Z, seed);
368 s16 groundlevel = baseTerrainLevelAtPoint(p.X, p.Z);
369
370 return bmgr->getBiome(heat, humidity, groundlevel);
371 }
372
373 //needs to be updated
baseTerrainLevelAtPoint(int x,int z)374 float MapgenV7::baseTerrainLevelAtPoint(int x, int z) {
375 float hselect = NoisePerlin2D(noise_height_select->np, x, z, seed);
376 hselect = rangelim(hselect, 0.0, 1.0);
377
378 float persist = NoisePerlin2D(noise_terrain_persist->np, x, z, seed);
379 persist = rangelim(persist, 0.4, 0.9);
380
381 noise_terrain_base->np->persist = persist;
382 float height_base = NoisePerlin2D(noise_terrain_base->np, x, z, seed);
383
384 noise_terrain_alt->np->persist = persist;
385 float height_alt = NoisePerlin2D(noise_terrain_alt->np, x, z, seed);
386
387 if (height_alt > height_base)
388 return height_alt;
389
390 return (height_base * hselect) + (height_alt * (1.0 - hselect));
391 }
392
393
baseTerrainLevelFromMap(int index)394 float MapgenV7::baseTerrainLevelFromMap(int index) {
395 float hselect = rangelim(noise_height_select->result[index], 0.0, 1.0);
396 float height_base = noise_terrain_base->result[index];
397 float height_alt = noise_terrain_alt->result[index];
398
399 if (height_alt > height_base)
400 return height_alt;
401
402 return (height_base * hselect) + (height_alt * (1.0 - hselect));
403 }
404
405
getMountainTerrainAtPoint(int x,int y,int z)406 bool MapgenV7::getMountainTerrainAtPoint(int x, int y, int z) {
407 float mnt_h_n = NoisePerlin2D(noise_mount_height->np, x, z, seed);
408 float height_modifier = -((float)y / rangelim(mnt_h_n, 80.0, 150.0));
409 float mnt_n = NoisePerlin3D(noise_mountain->np, x, y, z, seed);
410
411 return mnt_n + height_modifier >= 0.6;
412 }
413
414
getMountainTerrainFromMap(int idx_xyz,int idx_xz,int y)415 bool MapgenV7::getMountainTerrainFromMap(int idx_xyz, int idx_xz, int y) {
416 float mounthn = noise_mount_height->result[idx_xz];
417 float height_modifier = -((float)y / rangelim(mounthn, 80.0, 150.0));
418 return (noise_mountain->result[idx_xyz] + height_modifier >= 0.6);
419 }
420
421
422 #if 0
423 void MapgenV7::carveRivers() {
424 MapNode n_air(CONTENT_AIR), n_water_source(c_water_source);
425 MapNode n_stone(c_stone);
426 u32 index = 0;
427
428 int river_depth = 4;
429
430 for (s16 z = node_min.Z; z <= node_max.Z; z++)
431 for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
432 float terrain_mod = noise_terrain_mod->result[index];
433 NoiseParams *np = noise_terrain_river->np;
434 np->persist = noise_terrain_persist->result[index];
435 float terrain_river = NoisePerlin2DNoTxfm(np, x, z, seed);
436 float height = terrain_river * (1 - abs(terrain_mod)) *
437 noise_terrain_river->np->scale;
438 height = log(height * height); //log(h^3) is pretty interesting for terrain
439
440 s16 y = heightmap[index];
441 if (height < 1.0 && y > river_depth &&
442 y - river_depth >= node_min.Y && y <= node_max.Y) {
443
444 for (s16 ry = y; ry != y - river_depth; ry--) {
445 u32 vi = vm->m_area.index(x, ry, z);
446 vm->m_data[vi] = n_air;
447 }
448
449 u32 vi = vm->m_area.index(x, y - river_depth, z);
450 vm->m_data[vi] = n_water_source;
451 }
452 }
453 }
454 #endif
455
456
generateTerrain()457 int MapgenV7::generateTerrain() {
458 int ymax = generateBaseTerrain();
459
460 if (spflags & MGV7_MOUNTAINS)
461 generateMountainTerrain();
462
463 if (spflags & MGV7_RIDGES)
464 generateRidgeTerrain();
465
466 return ymax;
467 }
468
469
generateBaseTerrain()470 int MapgenV7::generateBaseTerrain() {
471 MapNode n_air(CONTENT_AIR);
472 MapNode n_stone(c_stone);
473 MapNode n_water(c_water_source);
474 MapNode n_ice(c_ice);
475
476 int stone_surface_max_y = -MAP_GENERATION_LIMIT;
477 v3s16 em = vm->m_area.getExtent();
478 u32 index = 0;
479
480 for (s16 z = node_min.Z; z <= node_max.Z; z++)
481 for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
482 float surface_height = baseTerrainLevelFromMap(index);
483 s16 surface_y = (s16)surface_height;
484
485 heightmap[index] = surface_y;
486 ridge_heightmap[index] = surface_y;
487
488 if (surface_y > stone_surface_max_y)
489 stone_surface_max_y = surface_y;
490
491 s16 heat = emerge->env->m_use_weather ? emerge->env->getServerMap().updateBlockHeat(emerge->env, v3POS(x,node_max.Y,z), nullptr, &heat_cache) : 0;
492
493 u32 i = vm->m_area.index(x, node_min.Y, z);
494 for (s16 y = node_min.Y; y <= node_max.Y; y++) {
495
496 if (vm->m_data[i].getContent() == CONTENT_IGNORE) {
497 if (y <= surface_y) {
498
499 int index3 = (z - node_min.Z) * zstride +
500 (y - node_min.Y) * ystride +
501 (x - node_min.X);
502
503 vm->m_data[i] = layers_get(index3);
504 }
505 else if (y <= water_level)
506 {
507 vm->m_data[i] = (heat < 0 && y > heat/3) ? n_ice : n_water;
508 }
509 else
510 vm->m_data[i] = n_air;
511 }
512 vm->m_area.add_y(em, i, 1);
513 }
514 }
515
516 return stone_surface_max_y;
517 }
518
519
generateMountainTerrain()520 void MapgenV7::generateMountainTerrain() {
521 if (node_max.Y <= water_level)
522 return;
523
524 MapNode n_stone(c_stone);
525 u32 j = 0;
526
527 for (s16 z = node_min.Z; z <= node_max.Z; z++)
528 for (s16 y = node_min.Y; y <= node_max.Y; y++) {
529 u32 vi = vm->m_area.index(node_min.X, y, z);
530 for (s16 x = node_min.X; x <= node_max.X; x++) {
531 int index = (z - node_min.Z) * csize.X + (x - node_min.X);
532
533 if (getMountainTerrainFromMap(j, index, y))
534 vm->m_data[vi] = n_stone;
535
536 vi++;
537 j++;
538 }
539 }
540 }
541
542
generateRidgeTerrain()543 void MapgenV7::generateRidgeTerrain() {
544 MapNode n_water(c_water_source);
545 MapNode n_ice(c_ice);
546 MapNode n_air(CONTENT_AIR);
547 u32 index = 0;
548
549 for (s16 z = node_min.Z; z <= node_max.Z; z++)
550 for (s16 y = node_min.Y; y <= node_max.Y; y++) {
551 u32 vi = vm->m_area.index(node_min.X, y, z);
552 for (s16 x = node_min.X; x <= node_max.X; x++, index++, vi++) {
553 int j = (z - node_min.Z) * csize.X + (x - node_min.X);
554
555 if (heightmap[j] < water_level - 4)
556 continue;
557
558 float widthn = (noise_terrain_persist->result[j] - 0.6) / 0.1;
559 //widthn = rangelim(widthn, -0.05, 0.5);
560
561 float width = 0.3; // TODO: figure out acceptable perlin noise values
562 float uwatern = noise_ridge_uwater->result[j] * 2;
563 if (uwatern < -width || uwatern > width)
564 continue;
565
566 float height_mod = (float)(y + 17) / 2.5;
567 float width_mod = (width - fabs(uwatern));
568 float nridge = noise_ridge->result[index] * (float)y / 7.0;
569
570 if (y < water_level)
571 nridge = -fabs(nridge) * 3.0 * widthn * 0.3;
572
573 if (nridge + width_mod * height_mod < 0.6)
574 continue;
575
576 if (y < ridge_heightmap[j])
577 ridge_heightmap[j] = y - 1;
578
579 s16 heat = emerge->env->m_use_weather ? emerge->env->getServerMap().updateBlockHeat(emerge->env, v3POS(x,node_max.Y,z), NULL, &heat_cache) : 0;
580 MapNode n_water_or_ice = (heat < 0 && y > water_level + heat/4) ? n_ice : n_water;
581
582 vm->m_data[vi] = (y > water_level) ? n_air : n_water_or_ice;
583 }
584 }
585 }
586
587
generateBiomes()588 void MapgenV7::generateBiomes() {
589 if (node_max.Y < water_level)
590 return;
591
592 MapNode n_air(CONTENT_AIR);
593 MapNode n_stone(c_stone);
594 MapNode n_water(c_water_source);
595
596 v3s16 em = vm->m_area.getExtent();
597 u32 index = 0;
598
599 for (s16 z = node_min.Z; z <= node_max.Z; z++)
600 for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
601 Biome *biome = (Biome *)bmgr->get(biomemap[index]);
602 s16 dfiller = biome->depth_filler + noise_filler_depth->result[index];
603 s16 y0_top = biome->depth_top;
604 s16 y0_filler = biome->depth_filler + biome->depth_top + dfiller;
605
606 s16 nplaced = 0;
607 u32 i = vm->m_area.index(x, node_max.Y, z);
608
609 content_t c_above = vm->m_data[i + em.X].getContent();
610 bool have_air = c_above == CONTENT_AIR;
611
612 s16 heat = emerge->env->m_use_weather ? emerge->env->getServerMap().updateBlockHeat(emerge->env, v3POS(x,node_max.Y,z), NULL, &heat_cache) : 0;
613
614 for (s16 y = node_max.Y; y >= node_min.Y; y--) {
615 content_t c = vm->m_data[i].getContent();
616
617 // It could be the case that the elevation is equal to the chunk
618 // boundary, but the chunk above has not been generated yet
619 if (y == node_max.Y && c_above == CONTENT_IGNORE &&
620 y == heightmap[index] && c == c_stone) {
621 int j = (z - node_min.Z) * zstride +
622 (y - node_min.Y) * ystride +
623 (x - node_min.X);
624 have_air = !getMountainTerrainFromMap(j, index, y);
625 }
626
627 if (c != CONTENT_AIR && c != c_water_source && have_air) {
628 content_t c_below = vm->m_data[i - em.X].getContent();
629
630 if (c_below != CONTENT_AIR) {
631 if (nplaced < y0_top) {
632 // A hack to prevent dirt_with_grass from being
633 // placed below water. TODO: fix later
634 content_t c_place = ((y < water_level) &&
635 (biome->c_top == c_dirt_with_grass)) ?
636 c_dirt : heat < -3 ? biome->c_top_cold : biome->c_top;
637 vm->m_data[i] = MapNode(c_place);
638 nplaced++;
639 } else if (nplaced < y0_filler && nplaced >= y0_top) {
640 vm->m_data[i] = MapNode(biome->c_filler);
641 nplaced++;
642 } else {
643 have_air = false;
644 nplaced = 0;
645 }
646 }
647 } else if (c == c_water_source) {
648 have_air = true;
649 nplaced = 0;
650 vm->m_data[i] = MapNode((heat < 0 && y > water_level + heat/4) ? biome->c_ice : biome->c_water);
651 } else if (c == CONTENT_AIR) {
652 have_air = true;
653 nplaced = 0;
654 }
655
656 vm->m_area.add_y(em, i, -1);
657 }
658 }
659 }
660
661
dustTopNodes()662 void MapgenV7::dustTopNodes() {
663 v3s16 em = vm->m_area.getExtent();
664 u32 index = 0;
665
666 if (water_level > node_max.Y)
667 return;
668
669 for (s16 z = node_min.Z; z <= node_max.Z; z++)
670 for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
671 Biome *biome = (Biome *)bmgr->get(biomemap[index]);
672
673 if (biome->c_dust == CONTENT_IGNORE)
674 continue;
675
676 s16 y = node_max.Y;
677 u32 vi = vm->m_area.index(x, y, z);
678 for (; y >= node_min.Y; y--) {
679 if (vm->m_data[vi].getContent() != CONTENT_AIR)
680 break;
681
682 vm->m_area.add_y(em, vi, -1);
683 }
684
685 content_t c = vm->m_data[vi].getContent();
686 if (c == biome->c_water && biome->c_dust_water != CONTENT_IGNORE) {
687 if (y < node_min.Y)
688 continue;
689
690 vm->m_data[vi] = MapNode(biome->c_dust_water);
691 } else if (!ndef->get(c).buildable_to && c != CONTENT_IGNORE) {
692 if (y == node_max.Y)
693 continue;
694
695 vm->m_area.add_y(em, vi, 1);
696 vm->m_data[vi] = MapNode(biome->c_dust);
697 }
698 }
699 }
700
701
702 #if 0
703 void MapgenV7::addTopNodes() {
704 v3s16 em = vm->m_area.getExtent();
705 s16 ntopnodes;
706 u32 index = 0;
707
708 for (s16 z = node_min.Z; z <= node_max.Z; z++)
709 for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
710 Biome *biome = bmgr->biomes[biomemap[index]];
711
712 //////////////////// First, add top nodes below the ridge
713 s16 y = ridge_heightmap[index];
714
715 // This cutoff is good enough, but not perfect.
716 // It will cut off potentially placed top nodes at chunk boundaries
717 if (y < node_min.Y)
718 continue;
719 if (y > node_max.Y) {
720 y = node_max.Y; // Let's see if we can still go downward anyway
721 u32 vi = vm->m_area.index(x, y, z);
722 content_t c = vm->m_data[vi].getContent();
723 if (ndef->get(c).walkable)
724 continue;
725 }
726
727 // N.B. It is necessary to search downward since ridge_heightmap[i]
728 // might not be the actual height, just the lowest part in the chunk
729 // where a ridge had been carved
730 u32 i = vm->m_area.index(x, y, z);
731 for (; y >= node_min.Y; y--) {
732 content_t c = vm->m_data[i].getContent();
733 if (ndef->get(c).walkable)
734 break;
735 vm->m_area.add_y(em, i, -1);
736 }
737
738 if (y != node_min.Y - 1 && y >= water_level) {
739 ridge_heightmap[index] = y; //update ridgeheight
740 ntopnodes = biome->top_depth;
741 for (; y <= node_max.Y && ntopnodes; y++) {
742 ntopnodes--;
743 vm->m_data[i] = MapNode(biome->c_top);
744 vm->m_area.add_y(em, i, 1);
745 }
746 // If dirt, grow grass on it.
747 if (y > water_level - 10 &&
748 vm->m_data[i].getContent() == CONTENT_AIR) {
749 vm->m_area.add_y(em, i, -1);
750 if (vm->m_data[i].getContent() == c_dirt)
751 vm->m_data[i] = MapNode(c_dirt_with_grass);
752 }
753 }
754
755 //////////////////// Now, add top nodes on top of the ridge
756 y = heightmap[index];
757 if (y > node_max.Y) {
758 y = node_max.Y; // Let's see if we can still go downward anyway
759 u32 vi = vm->m_area.index(x, y, z);
760 content_t c = vm->m_data[vi].getContent();
761 if (ndef->get(c).walkable)
762 continue;
763 }
764
765 i = vm->m_area.index(x, y, z);
766 for (; y >= node_min.Y; y--) {
767 content_t c = vm->m_data[i].getContent();
768 if (ndef->get(c).walkable)
769 break;
770 vm->m_area.add_y(em, i, -1);
771 }
772
773 if (y != node_min.Y - 1) {
774 ntopnodes = biome->top_depth;
775 // Let's see if we've already added it...
776 if (y == ridge_heightmap[index] + ntopnodes - 1)
777 continue;
778
779 for (; y <= node_max.Y && ntopnodes; y++) {
780 ntopnodes--;
781 vm->m_data[i] = MapNode(biome->c_top);
782 vm->m_area.add_y(em, i, 1);
783 }
784 // If dirt, grow grass on it.
785 if (y > water_level - 10 &&
786 vm->m_data[i].getContent() == CONTENT_AIR) {
787 vm->m_area.add_y(em, i, -1);
788 if (vm->m_data[i].getContent() == c_dirt)
789 vm->m_data[i] = MapNode(c_dirt_with_grass);
790 }
791 }
792 }
793 }
794 #endif
795
796
797 NoiseParams nparams_v7_def_cave(6, 6.0, v3f(250.0, 250.0, 250.0), 34329, 3, 0.50);
798
generateCaves(int max_stone_y)799 void MapgenV7::generateCaves(int max_stone_y) {
800 PseudoRandom ps(blockseed + 21343);
801
802 int volume_nodes = (node_max.X - node_min.X + 1) *
803 (node_max.Y - node_min.Y + 1) *
804 (node_max.Z - node_min.Z + 1);
805 float cave_amount = NoisePerlin2D(&nparams_v7_def_cave,
806 node_min.X, node_min.Y, seed);
807
808 u32 caves_count = MYMAX(0.0, cave_amount) * volume_nodes / 250000;
809 for (u32 i = 0; i < caves_count; i++) {
810 CaveV7 cave(this, &ps, false);
811 cave.makeCave(node_min, node_max, max_stone_y);
812 }
813
814 u32 bruises_count = (ps.range(1, 8) == 1) ? ps.range(0, ps.range(0, 2)) : 1;
815 for (u32 i = 0; i < bruises_count; i++) {
816 CaveV7 cave(this, &ps, true);
817 cave.makeCave(node_min, node_max, max_stone_y);
818 }
819 }
820
821
generateExperimental()822 void MapgenV7::generateExperimental() {
823 if (float_islands)
824 if (float_islands_generate(node_min, node_max, float_islands, vm))
825 dustTopNodes();
826 }
827