src/cavegen.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "util/numeric.h"
  21 #include "map.h"
  22 #include "mapgen.h"
  23 #include "mapgen_v5.h"
  24 #include "mapgen_v6.h"
  25 #include "mapgen_v7.h"
  26 #include "cavegen.h"
  27
  28 NoiseParams nparams_caveliquids(0, 1, v3f(150.0, 150.0, 150.0), 776, 3, 0.6, 2.0);
  29
  30
  31 ///////////////////////////////////////// Caves V5
  32
  33
  34 CaveV5::CaveV5(Mapgen *mg, PseudoRandom *ps)
  35 {
  36         this->mg             = mg;
  37         this->vm             = mg->vm;
  38         this->ndef           = mg->ndef;
  39         this->water_level    = mg->water_level;
  40         this->ps             = ps;
  41         c_water_source       = ndef->getId("mapgen_water_source");
  42         c_lava_source        = ndef->getId("mapgen_lava_source");
  43         c_ice                = ndef->getId("mapgen_ice");
  44         this->np_caveliquids = &nparams_caveliquids;
  45         this->ystride        = mg->csize.X;
  46
  47         if (c_ice == CONTENT_IGNORE)
  48                 c_ice = CONTENT_AIR;
  49
  50         dswitchint = ps->range(1, 14);
  51         flooded    = ps->range(1, 2) == 2;
  52
  53         part_max_length_rs  = ps->range(2, 4);
  54         tunnel_routepoints  = ps->range(5, ps->range(15, 30));
  55         min_tunnel_diameter = 5;
  56         max_tunnel_diameter = ps->range(7, ps->range(8, 24));
  57
  58         large_cave_is_flat = (ps->range(0, 1) == 0);
  59 }
  60
  61
  62 void CaveV5::makeCave(v3s16 nmin, v3s16 nmax, int max_stone_height)
  63 {
  64         node_min = nmin;
  65         node_max = nmax;
  66         main_direction = v3f(0, 0, 0);
  67
  68         // Allowed route area size in nodes
  69         ar = node_max - node_min + v3s16(1, 1, 1);
  70         // Area starting point in nodes
  71         of = node_min;
  72
  73         // Allow a bit more
  74         //(this should be more than the maximum radius of the tunnel)
  75         s16 insure = 10;
  76         s16 more = MYMAX(MAP_BLOCKSIZE - max_tunnel_diameter / 2 - insure, 1);
  77         ar += v3s16(1,0,1) * more * 2;
  78         of -= v3s16(1,0,1) * more;
  79
  80         route_y_min = 0;
  81         // Allow half a diameter + 7 over stone surface
  82         route_y_max = -of.Y + max_stone_y + max_tunnel_diameter / 2 + 7;
  83
  84         // Limit maximum to area
  85         route_y_max = rangelim(route_y_max, 0, ar.Y - 1);
  86
  87         s16 min = 0;
  88                 if (node_min.Y < water_level && node_max.Y > water_level) {
  89                         min = water_level - max_tunnel_diameter/3 - of.Y;
  90                         route_y_max = water_level + max_tunnel_diameter/3 - of.Y;
  91                 }
  92         route_y_min = ps->range(min, min + max_tunnel_diameter);
  93         route_y_min = rangelim(route_y_min, 0, route_y_max);
  94
  95         s16 route_start_y_min = route_y_min;
  96         s16 route_start_y_max = route_y_max;
  97
  98         route_start_y_min = rangelim(route_start_y_min, 0, ar.Y - 1);
  99         route_start_y_max = rangelim(route_start_y_max, route_start_y_min, ar.Y - 1);
 100
 101         // Randomize starting position
 102         orp = v3f(
 103                 (float)(ps->next() % ar.X) + 0.5,
 104                 (float)(ps->range(route_start_y_min, route_start_y_max)) + 0.5,
 105                 (float)(ps->next() % ar.Z) + 0.5
 106         );
 107
 108         // Add generation notify begin event
 109         v3s16 abs_pos(of.X + orp.X, of.Y + orp.Y, of.Z + orp.Z);
 110         GenNotifyType notifytype = GENNOTIFY_LARGECAVE_BEGIN;
 111         mg->gennotify.addEvent(notifytype, abs_pos);
 112
 113         // Generate some tunnel starting from orp
 114         for (u16 j = 0; j < tunnel_routepoints; j++)
 115                 makeTunnel(j % dswitchint == 0);
 116
 117         // Add generation notify end event
 118         abs_pos = v3s16(of.X + orp.X, of.Y + orp.Y, of.Z + orp.Z);
 119         notifytype = GENNOTIFY_LARGECAVE_END;
 120         mg->gennotify.addEvent(notifytype, abs_pos);
 121 }
 122
 123
 124 void CaveV5::makeTunnel(bool dirswitch)
 125 {
 126         // Randomize size
 127         s16 min_d = min_tunnel_diameter;
 128         s16 max_d = max_tunnel_diameter;
 129         rs = ps->range(min_d, max_d);
 130         s16 rs_part_max_length_rs = rs * part_max_length_rs;
 131
 132         v3s16 maxlen;
 133         maxlen = v3s16(
 134                 rs_part_max_length_rs,
 135                 rs_part_max_length_rs / 2,
 136                 rs_part_max_length_rs
 137         );
 138
 139         v3f vec;
 140         // Jump downward sometimes
 141         vec = v3f(
 142                 (float)(ps->next() % maxlen.X) - (float)maxlen.X / 2,
 143                 (float)(ps->next() % maxlen.Y) - (float)maxlen.Y / 2,
 144                 (float)(ps->next() % maxlen.Z) - (float)maxlen.Z / 2
 145         );
 146
 147         // Do not make caves that are above ground.
 148         // It is only necessary to check the startpoint and endpoint.
 149         v3s16 orpi(orp.X, orp.Y, orp.Z);
 150         v3s16 veci(vec.X, vec.Y, vec.Z);
 151         v3s16 p;
 152
 153         p = orpi + veci + of + rs / 2;
 154         if (p.Z >= node_min.Z && p.Z <= node_max.Z &&
 155                         p.X >= node_min.X && p.X <= node_max.X) {
 156                 u32 index = (p.Z - node_min.Z) * ystride + (p.X - node_min.X);
 157                 s16 h = mg->heightmap[index];
 158                 if (h < p.Y)
 159                         return;
 160         } else if (p.Y > water_level) {
 161                 return; // If it's not in our heightmap, use a simple heuristic
 162         }
 163
 164         p = orpi + of + rs / 2;
 165         if (p.Z >= node_min.Z && p.Z <= node_max.Z &&
 166                         p.X >= node_min.X && p.X <= node_max.X) {
 167                 u32 index = (p.Z - node_min.Z) * ystride + (p.X - node_min.X);
 168                 s16 h = mg->heightmap[index];
 169                 if (h < p.Y)
 170                         return;
 171         } else if (p.Y > water_level) {
 172                 return;
 173         }
 174
 175         vec += main_direction;
 176
 177         v3f rp = orp + vec;
 178         if (rp.X < 0)
 179                 rp.X = 0;
 180         else if (rp.X >= ar.X)
 181                 rp.X = ar.X - 1;
 182
 183         if (rp.Y < route_y_min)
 184                 rp.Y = route_y_min;
 185         else if (rp.Y >= route_y_max)
 186                 rp.Y = route_y_max - 1;
 187
 188         if (rp.Z < 0)
 189                 rp.Z = 0;
 190         else if (rp.Z >= ar.Z)
 191                 rp.Z = ar.Z - 1;
 192
 193         vec = rp - orp;
 194
 195         float veclen = vec.getLength();
 196         if (veclen < 0.05)
 197                 veclen = 1.0;
 198
 199         // Every second section is rough
 200         bool randomize_xz = (ps->range(1, 2) == 1);
 201
 202         // Carve routes
 203         for (float f = 0; f < 1.0; f += 1.0 / veclen)
 204                 carveRoute(vec, f, randomize_xz);
 205
 206         orp = rp;
 207 }
 208
 209
 210 void CaveV5::carveRoute(v3f vec, float f, bool randomize_xz)
 211 {
 212         MapNode airnode(CONTENT_AIR);
 213         MapNode waternode(c_water_source);
 214         MapNode lavanode(c_lava_source);
 215
 216         v3s16 startp(orp.X, orp.Y, orp.Z);
 217         startp += of;
 218
 219         float nval = NoisePerlin3D(np_caveliquids, startp.X,
 220                 startp.Y, startp.Z, mg->seed);
 221         MapNode liquidnode = (nval < 0.40 && node_max.Y < MGV5_LAVA_DEPTH) ?
 222                 lavanode : waternode;
 223
 224         v3f fp = orp + vec * f;
 225         fp.X += 0.1 * ps->range(-10, 10);
 226         fp.Z += 0.1 * ps->range(-10, 10);
 227         v3s16 cp(fp.X, fp.Y, fp.Z);
 228
 229         s16 d0 = -rs/2;
 230         s16 d1 = d0 + rs;
 231         if (randomize_xz) {
 232                 d0 += ps->range(-1, 1);
 233                 d1 += ps->range(-1, 1);
 234         }
 235
 236         for (s16 z0 = d0; z0 <= d1; z0++) {
 237                 s16 si = rs / 2 - MYMAX(0, abs(z0) - rs / 7 - 1);
 238                 for (s16 x0 = -si - ps->range(0,1); x0 <= si - 1 + ps->range(0,1); x0++) {
 239                         s16 maxabsxz = MYMAX(abs(x0), abs(z0));
 240
 241                         s16 si2 = rs / 2 - MYMAX(0, maxabsxz - rs / 7 - 1);
 242
 243                         for (s16 y0 = -si2; y0 <= si2; y0++) {
 244                                 if (large_cave_is_flat) {
 245                                         // Make large caves not so tall
 246                                         if (rs > 7 && abs(y0) >= rs / 3)
 247                                                 continue;
 248                                 }
 249
 250                                 v3s16 p(cp.X + x0, cp.Y + y0, cp.Z + z0);
 251                                 p += of;
 252
 253                                 if (vm->m_area.contains(p) == false)
 254                                         continue;
 255
 256                                 u32 i = vm->m_area.index(p);
 257                                 content_t c = vm->m_data[i].getContent();
 258                                 if (!ndef->get(c).is_ground_content)
 259                                         continue;
 260
 261                                 int full_ymin = node_min.Y - MAP_BLOCKSIZE;
 262                                 int full_ymax = node_max.Y + MAP_BLOCKSIZE;
 263
 264                                 if (flooded && full_ymin < water_level &&
 265                                                 full_ymax > water_level)
 266                                         vm->m_data[i] = (p.Y <= water_level) ?
 267                                                 waternode : airnode;
 268                                 else if (flooded && full_ymax < water_level)
 269                                         vm->m_data[i] = (p.Y < startp.Y - 4) ?
 270                                                 liquidnode : airnode;
 271                                 else
 272                                         vm->m_data[i] = airnode;
 273                         }
 274                 }
 275         }
 276 }
 277
 278
 279 ///////////////////////////////////////// Caves V6
 280
 281
 282 CaveV6::CaveV6(MapgenV6 *mg, PseudoRandom *ps, PseudoRandom *ps2, bool is_large_cave)
 283 {
 284         this->mg             = mg;
 285         this->vm             = mg->vm;
 286         this->ndef           = mg->ndef;
 287         this->water_level    = mg->water_level;
 288         this->large_cave     = is_large_cave;
 289         this->ps             = ps;
 290         this->ps2            = ps2;
 291         this->c_water_source = mg->c_water_source;
 292         this->c_lava_source  = mg->c_lava_source;
 293
 294         min_tunnel_diameter = 2;
 295         max_tunnel_diameter = ps->range(2, 6);
 296         dswitchint          = ps->range(1, 14);
 297         flooded             = true;
 298
 299         if (large_cave) {
 300                 part_max_length_rs  = ps->range(2,4);
 301                 tunnel_routepoints  = ps->range(5, ps->range(15,30));
 302                 min_tunnel_diameter = 5;
 303                 max_tunnel_diameter = ps->range(7, ps->range(8,24));
 304         } else {
 305                 part_max_length_rs = ps->range(2,9);
 306                 tunnel_routepoints = ps->range(10, ps->range(15,30));
 307         }
 308
 309         large_cave_is_flat = (ps->range(0,1) == 0);
 310 }
 311
 312
 313 void CaveV6::makeCave(v3s16 nmin, v3s16 nmax, int max_stone_height)
 314 {
 315         node_min = nmin;
 316         node_max = nmax;
 317         max_stone_y = max_stone_height;
 318         main_direction = v3f(0, 0, 0);
 319
 320         // Allowed route area size in nodes
 321         ar = node_max - node_min + v3s16(1, 1, 1);
 322         // Area starting point in nodes
 323         of = node_min;
 324
 325         // Allow a bit more
 326         //(this should be more than the maximum radius of the tunnel)
 327         const s16 max_spread_amount = MAP_BLOCKSIZE;
 328         s16 insure = 10;
 329         s16 more = MYMAX(max_spread_amount - max_tunnel_diameter / 2 - insure, 1);
 330         ar += v3s16(1,0,1) * more * 2;
 331         of -= v3s16(1,0,1) * more;
 332
 333         route_y_min = 0;
 334         // Allow half a diameter + 7 over stone surface
 335         route_y_max = -of.Y + max_stone_y + max_tunnel_diameter / 2 + 7;
 336
 337         // Limit maximum to area
 338         route_y_max = rangelim(route_y_max, 0, ar.Y - 1);
 339
 340         if (large_cave) {
 341                 s16 min = 0;
 342                 if (node_min.Y < water_level && node_max.Y > water_level) {
 343                         min = water_level - max_tunnel_diameter/3 - of.Y;
 344                         route_y_max = water_level + max_tunnel_diameter/3 - of.Y;
 345                 }
 346                 route_y_min = ps->range(min, min + max_tunnel_diameter);
 347                 route_y_min = rangelim(route_y_min, 0, route_y_max);
 348         }
 349
 350         s16 route_start_y_min = route_y_min;
 351         s16 route_start_y_max = route_y_max;
 352
 353         route_start_y_min = rangelim(route_start_y_min, 0, ar.Y-1);
 354         route_start_y_max = rangelim(route_start_y_max, route_start_y_min, ar.Y-1);
 355
 356         // Randomize starting position
 357         orp = v3f(
 358                 (float)(ps->next() % ar.X) + 0.5,
 359                 (float)(ps->range(route_start_y_min, route_start_y_max)) + 0.5,
 360                 (float)(ps->next() % ar.Z) + 0.5
 361         );
 362
 363         // Add generation notify begin event
 364         v3s16 abs_pos(of.X + orp.X, of.Y + orp.Y, of.Z + orp.Z);
 365         GenNotifyType notifytype = large_cave ?
 366                 GENNOTIFY_LARGECAVE_BEGIN : GENNOTIFY_CAVE_BEGIN;
 367         mg->gennotify.addEvent(notifytype, abs_pos);
 368
 369         // Generate some tunnel starting from orp
 370         for (u16 j = 0; j < tunnel_routepoints; j++)
 371                 makeTunnel(j % dswitchint == 0);
 372
 373         // Add generation notify end event
 374         abs_pos = v3s16(of.X + orp.X, of.Y + orp.Y, of.Z + orp.Z);
 375         notifytype = large_cave ?
 376                 GENNOTIFY_LARGECAVE_END : GENNOTIFY_CAVE_END;
 377         mg->gennotify.addEvent(notifytype, abs_pos);
 378 }
 379
 380
 381 void CaveV6::makeTunnel(bool dirswitch)
 382 {
 383         if (dirswitch && !large_cave) {
 384                 main_direction = v3f(
 385                         ((float)(ps->next() % 20) - (float)10) / 10,
 386                         ((float)(ps->next() % 20) - (float)10) / 30,
 387                         ((float)(ps->next() % 20) - (float)10) / 10
 388                 );
 389                 main_direction *= (float)ps->range(0, 10) / 10;
 390         }
 391
 392         // Randomize size
 393         s16 min_d = min_tunnel_diameter;
 394         s16 max_d = max_tunnel_diameter;
 395         rs = ps->range(min_d, max_d);
 396         s16 rs_part_max_length_rs = rs * part_max_length_rs;
 397
 398         v3s16 maxlen;
 399         if (large_cave) {
 400                 maxlen = v3s16(
 401                         rs_part_max_length_rs,
 402                         rs_part_max_length_rs / 2,
 403                         rs_part_max_length_rs
 404                 );
 405         } else {
 406                 maxlen = v3s16(
 407                         rs_part_max_length_rs,
 408                         ps->range(1, rs_part_max_length_rs),
 409                         rs_part_max_length_rs
 410                 );
 411         }
 412
 413         v3f vec(
 414                 (float)(ps->next() % maxlen.X) - (float)maxlen.X / 2,
 415                 (float)(ps->next() % maxlen.Y) - (float)maxlen.Y / 2,
 416                 (float)(ps->next() % maxlen.Z) - (float)maxlen.Z / 2
 417         );
 418
 419         // Jump downward sometimes
 420         if (!large_cave && ps->range(0, 12) == 0) {
 421                 vec = v3f(
 422                         (float)(ps->next() % maxlen.X) - (float)maxlen.X / 2,
 423                         (float)(ps->next() % (maxlen.Y * 2)) - (float)maxlen.Y,
 424                         (float)(ps->next() % maxlen.Z) - (float)maxlen.Z / 2
 425                 );
 426         }
 427
 428         // Do not make caves that are entirely above ground, to fix
 429         // shadow bugs caused by overgenerated large caves.
 430         // It is only necessary to check the startpoint and endpoint.
 431         v3s16 orpi(orp.X, orp.Y, orp.Z);
 432         v3s16 veci(vec.X, vec.Y, vec.Z);
 433         s16 h1;
 434         s16 h2;
 435
 436         v3s16 p1 = orpi + veci + of + rs / 2;
 437         if (p1.Z >= node_min.Z && p1.Z <= node_max.Z &&
 438                         p1.X >= node_min.X && p1.X <= node_max.X) {
 439                 u32 index1 = (p1.Z - node_min.Z) * mg->ystride +
 440                         (p1.X - node_min.X);
 441                 h1 = mg->heightmap[index1];
 442         } else {
 443                 h1 = water_level; // If not in heightmap
 444         }
 445
 446         v3s16 p2 = orpi + of + rs / 2;
 447         if (p2.Z >= node_min.Z && p2.Z <= node_max.Z &&
 448                         p2.X >= node_min.X && p2.X <= node_max.X) {
 449                 u32 index2 = (p2.Z - node_min.Z) * mg->ystride +
 450                         (p2.X - node_min.X);
 451                 h2 = mg->heightmap[index2];
 452         } else {
 453                 h2 = water_level;
 454         }
 455
 456         // If startpoint and endpoint are above ground,
 457         // disable placing of nodes in carveRoute while
 458         // still running all pseudorandom calls to ensure
 459         // caves consistent with existing worlds.
 460         bool tunnel_above_ground = p1.Y > h1 && p2.Y > h2;
 461
 462         vec += main_direction;
 463
 464         v3f rp = orp + vec;
 465         if (rp.X < 0)
 466                 rp.X = 0;
 467         else if (rp.X >= ar.X)
 468                 rp.X = ar.X - 1;
 469
 470         if (rp.Y < route_y_min)
 471                 rp.Y = route_y_min;
 472         else if (rp.Y >= route_y_max)
 473                 rp.Y = route_y_max - 1;
 474
 475         if (rp.Z < 0)
 476                 rp.Z = 0;
 477         else if (rp.Z >= ar.Z)
 478                 rp.Z = ar.Z - 1;
 479
 480         vec = rp - orp;
 481
 482         float veclen = vec.getLength();
 483         // As odd as it sounds, veclen is *exactly* 0.0 sometimes, causing a FPE
 484         if (veclen < 0.05)
 485                 veclen = 1.0;
 486
 487         // Every second section is rough
 488         bool randomize_xz = (ps2->range(1, 2) == 1);
 489
 490         // Carve routes
 491         for (float f = 0; f < 1.0; f += 1.0 / veclen)
 492                 carveRoute(vec, f, randomize_xz, tunnel_above_ground);
 493
 494         orp = rp;
 495 }
 496
 497
 498 void CaveV6::carveRoute(v3f vec, float f, bool randomize_xz, bool tunnel_above_ground)
 499 {
 500         MapNode airnode(CONTENT_AIR);
 501         MapNode waternode(c_water_source);
 502         MapNode lavanode(c_lava_source);
 503
 504         v3s16 startp(orp.X, orp.Y, orp.Z);
 505         startp += of;
 506
 507         v3f fp = orp + vec * f;
 508         fp.X += 0.1 * ps->range(-10, 10);
 509         fp.Z += 0.1 * ps->range(-10, 10);
 510         v3s16 cp(fp.X, fp.Y, fp.Z);
 511
 512         s16 d0 = -rs/2;
 513         s16 d1 = d0 + rs;
 514         if (randomize_xz) {
 515                 d0 += ps->range(-1, 1);
 516                 d1 += ps->range(-1, 1);
 517         }
 518
 519         for (s16 z0 = d0; z0 <= d1; z0++) {
 520                 s16 si = rs / 2 - MYMAX(0, abs(z0) - rs / 7 - 1);
 521                 for (s16 x0 = -si - ps->range(0,1); x0 <= si - 1 + ps->range(0,1); x0++) {
 522                         if (tunnel_above_ground)
 523                                 continue;
 524
 525                         s16 maxabsxz = MYMAX(abs(x0), abs(z0));
 526                         s16 si2 = rs / 2 - MYMAX(0, maxabsxz - rs / 7 - 1);
 527                         for (s16 y0 = -si2; y0 <= si2; y0++) {
 528                                 if (large_cave_is_flat) {
 529                                         // Make large caves not so tall
 530                                         if (rs > 7 && abs(y0) >= rs / 3)
 531                                                 continue;
 532                                 }
 533
 534                                 v3s16 p(cp.X + x0, cp.Y + y0, cp.Z + z0);
 535                                 p += of;
 536
 537                                 if (vm->m_area.contains(p) == false)
 538                                         continue;
 539
 540                                 u32 i = vm->m_area.index(p);
 541                                 content_t c = vm->m_data[i].getContent();
 542                                 if (!ndef->get(c).is_ground_content)
 543                                         continue;
 544
 545                                 if (large_cave) {
 546                                         int full_ymin = node_min.Y - MAP_BLOCKSIZE;
 547                                         int full_ymax = node_max.Y + MAP_BLOCKSIZE;
 548
 549                                         if (flooded && full_ymin < water_level &&
 550                                                         full_ymax > water_level) {
 551                                                 vm->m_data[i] = (p.Y <= water_level) ?
 552                                                         waternode : airnode;
 553                                         } else if (flooded && full_ymax < water_level) {
 554                                                 vm->m_data[i] = (p.Y < startp.Y - 2) ?
 555                                                         lavanode : airnode;
 556                                         } else {
 557                                                 vm->m_data[i] = airnode;
 558                                         }
 559                                 } else {
 560                                         if (c == CONTENT_IGNORE || c == CONTENT_AIR)
 561                                                 continue;
 562
 563                                         vm->m_data[i] = airnode;
 564                                         vm->m_flags[i] |= VMANIP_FLAG_CAVE;
 565                                 }
 566                         }
 567                 }
 568         }
 569 }
 570
 571
 572 ///////////////////////////////////////// Caves V7
 573
 574
 575 CaveV7::CaveV7(MapgenV7 *mg, PseudoRandom *ps)
 576 {
 577         this->mg             = mg;
 578         this->vm             = mg->vm;
 579         this->ndef           = mg->ndef;
 580         this->water_level    = mg->water_level;
 581         this->ps             = ps;
 582         this->c_water_source = mg->c_water_source;
 583         this->c_lava_source  = mg->c_lava_source;
 584         this->c_ice          = mg->c_ice;
 585         this->np_caveliquids = &nparams_caveliquids;
 586
 587         dswitchint = ps->range(1, 14);
 588         flooded    = ps->range(1, 2) == 2;
 589
 590         part_max_length_rs  = ps->range(2, 4);
 591         tunnel_routepoints  = ps->range(5, ps->range(15, 30));
 592         min_tunnel_diameter = 5;
 593         max_tunnel_diameter = ps->range(7, ps->range(8, 24));
 594
 595         large_cave_is_flat = (ps->range(0, 1) == 0);
 596 }
 597
 598
 599 void CaveV7::makeCave(v3s16 nmin, v3s16 nmax, int max_stone_height)
 600 {
 601         node_min = nmin;
 602         node_max = nmax;
 603         max_stone_y = max_stone_height;
 604         main_direction = v3f(0, 0, 0);
 605
 606         // Allowed route area size in nodes
 607         ar = node_max - node_min + v3s16(1, 1, 1);
 608         // Area starting point in nodes
 609         of = node_min;
 610
 611         // Allow a bit more
 612         //(this should be more than the maximum radius of the tunnel)
 613         s16 insure = 10;
 614         s16 more = MYMAX(MAP_BLOCKSIZE - max_tunnel_diameter / 2 - insure, 1);
 615         ar += v3s16(1,0,1) * more * 2;
 616         of -= v3s16(1,0,1) * more;
 617
 618         route_y_min = 0;
 619         // Allow half a diameter + 7 over stone surface
 620         route_y_max = -of.Y + max_stone_y + max_tunnel_diameter / 2 + 7;
 621
 622         // Limit maximum to area
 623         route_y_max = rangelim(route_y_max, 0, ar.Y - 1);
 624
 625         s16 min = 0;
 626         if (node_min.Y < water_level && node_max.Y > water_level) {
 627                 min = water_level - max_tunnel_diameter/3 - of.Y;
 628                 route_y_max = water_level + max_tunnel_diameter/3 - of.Y;
 629         }
 630         route_y_min = ps->range(min, min + max_tunnel_diameter);
 631         route_y_min = rangelim(route_y_min, 0, route_y_max);
 632
 633         s16 route_start_y_min = route_y_min;
 634         s16 route_start_y_max = route_y_max;
 635
 636         route_start_y_min = rangelim(route_start_y_min, 0, ar.Y - 1);
 637         route_start_y_max = rangelim(route_start_y_max, route_start_y_min, ar.Y - 1);
 638
 639         // Randomize starting position
 640         orp = v3f(
 641                 (float)(ps->next() % ar.X) + 0.5,
 642                 (float)(ps->range(route_start_y_min, route_start_y_max)) + 0.5,
 643                 (float)(ps->next() % ar.Z) + 0.5
 644         );
 645
 646         // Add generation notify begin event
 647         v3s16 abs_pos(of.X + orp.X, of.Y + orp.Y, of.Z + orp.Z);
 648         GenNotifyType notifytype = GENNOTIFY_LARGECAVE_BEGIN;
 649         mg->gennotify.addEvent(notifytype, abs_pos);
 650
 651         // Generate some tunnel starting from orp
 652         for (u16 j = 0; j < tunnel_routepoints; j++)
 653                 makeTunnel(j % dswitchint == 0);
 654
 655         // Add generation notify end event
 656         abs_pos = v3s16(of.X + orp.X, of.Y + orp.Y, of.Z + orp.Z);
 657         notifytype = GENNOTIFY_LARGECAVE_END;
 658         mg->gennotify.addEvent(notifytype, abs_pos);
 659 }
 660
 661
 662 void CaveV7::makeTunnel(bool dirswitch)
 663 {
 664         // Randomize size
 665         s16 min_d = min_tunnel_diameter;
 666         s16 max_d = max_tunnel_diameter;
 667         rs = ps->range(min_d, max_d);
 668         s16 rs_part_max_length_rs = rs * part_max_length_rs;
 669
 670         v3s16 maxlen;
 671         maxlen = v3s16(
 672                 rs_part_max_length_rs,
 673                 rs_part_max_length_rs / 2,
 674                 rs_part_max_length_rs
 675         );
 676
 677         v3f vec;
 678         // Jump downward sometimes
 679         vec = v3f(
 680                 (float)(ps->next() % maxlen.X) - (float)maxlen.X / 2,
 681                 (float)(ps->next() % maxlen.Y) - (float)maxlen.Y / 2,
 682                 (float)(ps->next() % maxlen.Z) - (float)maxlen.Z / 2
 683         );
 684
 685         // Do not make caves that are above ground.
 686         // It is only necessary to check the startpoint and endpoint.
 687         v3s16 orpi(orp.X, orp.Y, orp.Z);
 688         v3s16 veci(vec.X, vec.Y, vec.Z);
 689         v3s16 p;
 690
 691         p = orpi + veci + of + rs / 2;
 692         if (p.Z >= node_min.Z && p.Z <= node_max.Z &&
 693                         p.X >= node_min.X && p.X <= node_max.X) {
 694                 u32 index = (p.Z - node_min.Z) * mg->ystride + (p.X - node_min.X);
 695                 s16 h = mg->ridge_heightmap[index];
 696                 if (h < p.Y)
 697                         return;
 698         } else if (p.Y > water_level) {
 699                 return; // If it's not in our heightmap, use a simple heuristic
 700         }
 701
 702         p = orpi + of + rs / 2;
 703         if (p.Z >= node_min.Z && p.Z <= node_max.Z &&
 704                         p.X >= node_min.X && p.X <= node_max.X) {
 705                 u32 index = (p.Z - node_min.Z) * mg->ystride + (p.X - node_min.X);
 706                 s16 h = mg->ridge_heightmap[index];
 707                 if (h < p.Y)
 708                         return;
 709         } else if (p.Y > water_level) {
 710                 return;
 711         }
 712
 713         vec += main_direction;
 714
 715         v3f rp = orp + vec;
 716         if (rp.X < 0)
 717                 rp.X = 0;
 718         else if (rp.X >= ar.X)
 719                 rp.X = ar.X - 1;
 720
 721         if (rp.Y < route_y_min)
 722                 rp.Y = route_y_min;
 723         else if (rp.Y >= route_y_max)
 724                 rp.Y = route_y_max - 1;
 725
 726         if (rp.Z < 0)
 727                 rp.Z = 0;
 728         else if (rp.Z >= ar.Z)
 729                 rp.Z = ar.Z - 1;
 730
 731         vec = rp - orp;
 732
 733         float veclen = vec.getLength();
 734         if (veclen < 0.05)
 735                 veclen = 1.0;
 736
 737         // Every second section is rough
 738         bool randomize_xz = (ps->range(1, 2) == 1);
 739
 740         // Carve routes
 741         for (float f = 0; f < 1.0; f += 1.0 / veclen)
 742                 carveRoute(vec, f, randomize_xz);
 743
 744         orp = rp;
 745 }
 746
 747
 748 void CaveV7::carveRoute(v3f vec, float f, bool randomize_xz)
 749 {
 750         MapNode airnode(CONTENT_AIR);
 751         MapNode waternode(c_water_source);
 752         MapNode lavanode(c_lava_source);
 753
 754         v3s16 startp(orp.X, orp.Y, orp.Z);
 755         startp += of;
 756
 757         float nval = NoisePerlin3D(np_caveliquids, startp.X,
 758                 startp.Y, startp.Z, mg->seed);
 759         MapNode liquidnode = (nval < 0.40 && node_max.Y < MGV7_LAVA_DEPTH) ?
 760                 lavanode : waternode;
 761
 762         v3f fp = orp + vec * f;
 763         fp.X += 0.1 * ps->range(-10, 10);
 764         fp.Z += 0.1 * ps->range(-10, 10);
 765         v3s16 cp(fp.X, fp.Y, fp.Z);
 766
 767         s16 d0 = -rs/2;
 768         s16 d1 = d0 + rs;
 769         if (randomize_xz) {
 770                 d0 += ps->range(-1, 1);
 771                 d1 += ps->range(-1, 1);
 772         }
 773
 774         for (s16 z0 = d0; z0 <= d1; z0++) {
 775                 s16 si = rs / 2 - MYMAX(0, abs(z0) - rs / 7 - 1);
 776                 for (s16 x0 = -si - ps->range(0,1); x0 <= si - 1 + ps->range(0,1); x0++) {
 777                         s16 maxabsxz = MYMAX(abs(x0), abs(z0));
 778
 779                         s16 si2 = rs / 2 - MYMAX(0, maxabsxz - rs / 7 - 1);
 780
 781                         for (s16 y0 = -si2; y0 <= si2; y0++) {
 782                                 if (large_cave_is_flat) {
 783                                         // Make large caves not so tall
 784                                         if (rs > 7 && abs(y0) >= rs / 3)
 785                                                 continue;
 786                                 }
 787
 788                                 v3s16 p(cp.X + x0, cp.Y + y0, cp.Z + z0);
 789                                 p += of;
 790
 791                                 if (vm->m_area.contains(p) == false)
 792                                         continue;
 793
 794                                 u32 i = vm->m_area.index(p);
 795                                 content_t c = vm->m_data[i].getContent();
 796                                 if (!ndef->get(c).is_ground_content)
 797                                         continue;
 798
 799                                 int full_ymin = node_min.Y - MAP_BLOCKSIZE;
 800                                 int full_ymax = node_max.Y + MAP_BLOCKSIZE;
 801
 802                                 if (flooded && full_ymin < water_level &&
 803                                                 full_ymax > water_level)
 804                                         vm->m_data[i] = (p.Y <= water_level) ?
 805                                                 waternode : airnode;
 806                                 else if (flooded && full_ymax < water_level)
 807                                         vm->m_data[i] = (p.Y < startp.Y - 4) ?
 808                                                 liquidnode : airnode;
 809                                 else
 810                                         vm->m_data[i] = airnode;
 811                         }
 812                 }
 813         }
 814 }