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