src/mapgen_indev.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 "mapgen_indev.h"
  21 #include "constants.h"
  22 #include "map.h"
  23 #include "main.h"
  24 #include "log.h"
  25
  26 /////////////////// Mapgen Indev perlin noise (default values - not used, from config or defaultsettings)
  27
  28 NoiseIndevParams nparams_indev_def;
  29
  30 /*
  31 NoiseIndevParams nparams_indev_def_terrain_base;
  32 //      (-AVERAGE_MUD_AMOUNT, 20.0, v3f(250.0, 250.0, 250.0), 82341, 5, 0.6, 1);
  33 NoiseIndevParams nparams_indev_def_terrain_higher;
  34 //      (20.0, 16.0, v3f(500.0, 500.0, 500.0), 85039, 5, 0.6, 1);
  35 NoiseIndevParams nparams_indev_def_steepness;
  36 //      (0.85, 0.5, v3f(125.0, 125.0, 125.0), -932, 5, 0.7, 1);
  37 NoiseIndevParams nparams_indev_def_mud;
  38 //      (AVERAGE_MUD_AMOUNT, 2.0, v3f(200.0, 200.0, 200.0), 91013, 3, 0.55, 1);
  39 NoiseIndevParams nparams_indev_def_float_islands;
  40 //      (1, 10.0, v3f(500.0, 500.0, 500.0), 32451, 5, 0.6, 1);
  41 NoiseIndevParams nparams_indev_def_biome;
  42 */
  43
  44 ///////////////////////////////////////////////////////////////////////////////
  45
  46 void NoiseIndev::init(NoiseIndevParams *np, int seed, int sx, int sy, int sz) {
  47         Noise::init((NoiseParams*)np, seed, sx, sy, sz);
  48         this->npindev   = np;
  49 }
  50
  51 NoiseIndev::NoiseIndev(NoiseIndevParams *np, int seed, int sx, int sy) : Noise(np, seed, sx, sy) {
  52         init(np, seed, sx, sy, 1);
  53 }
  54
  55 NoiseIndev::NoiseIndev(NoiseIndevParams *np, int seed, int sx, int sy, int sz) : Noise(np, seed, sx, sy, sz) {
  56         init(np, seed, sx, sy, sz);
  57 }
  58
  59 float farscale(float scale, float z) {
  60         return ( 1 + ( 1 - (MAP_GENERATION_LIMIT * 1 - (fabs(z))                     ) / (MAP_GENERATION_LIMIT * 1) ) * (scale - 1) );
  61 }
  62
  63 float farscale(float scale, float x, float z) {
  64         return ( 1 + ( 1 - (MAP_GENERATION_LIMIT * 2 - (fabs(x) + fabs(z))           ) / (MAP_GENERATION_LIMIT * 2) ) * (scale - 1) );
  65 }
  66
  67 float farscale(float scale, float x, float y, float z) {
  68         return ( 1 + ( 1 - (MAP_GENERATION_LIMIT * 3 - (fabs(x) + fabs(y) + fabs(z)) ) / (MAP_GENERATION_LIMIT * 3) ) * (scale - 1) );
  69 }
  70
  71 void NoiseIndev::transformNoiseMapFarScale(float xx, float yy, float zz) {
  72         int i = 0;
  73         for (int z = 0; z != sz; z++) {
  74                 for (int y = 0; y != sy; y++) {
  75                         for (int x = 0; x != sx; x++) {
  76                                 result[i] = result[i] * npindev->scale * farscale(npindev->farscale, xx, yy, zz) + npindev->offset;
  77                                 i++;
  78                         }
  79                 }
  80         }
  81 }
  82
  83 MapgenIndev::MapgenIndev(int mapgenid, MapgenIndevParams *params, EmergeManager *emerge)
  84         : MapgenV6(mapgenid, params, emerge)
  85 {
  86         noiseindev_terrain_base   = new NoiseIndev(params->npindev_terrain_base,   seed, csize.X, csize.Z);
  87         noiseindev_terrain_higher = new NoiseIndev(params->npindev_terrain_higher, seed, csize.X, csize.Z);
  88         noiseindev_steepness      = new NoiseIndev(params->npindev_steepness,      seed, csize.X, csize.Z);
  89 //        noise_height_select  = new Noise(params->np_height_select,  seed, csize.X, csize.Y);
  90 //        noise_trees          = new Noise(params->np_trees,          seed, csize.X, csize.Y);
  91         noiseindev_mud            = new NoiseIndev(params->npindev_mud,            seed, csize.X, csize.Z);
  92 //        noise_beach          = new Noise(params->np_beach,          seed, csize.X, csize.Y);
  93         noiseindev_float_islands1  = new NoiseIndev(params->npindev_float_islands1,  seed, csize.X, csize.Y, csize.Z);
  94         noiseindev_float_islands2  = new NoiseIndev(params->npindev_float_islands2,  seed, csize.X, csize.Y, csize.Z);
  95         noiseindev_float_islands3  = new NoiseIndev(params->npindev_float_islands3,  seed, csize.X, csize.Z);
  96         noiseindev_biome          = new NoiseIndev(params->npindev_biome,          seed, csize.X, csize.Z);
  97 }
  98
  99 MapgenIndev::~MapgenIndev() {
 100         delete noiseindev_terrain_base;
 101         delete noiseindev_terrain_higher;
 102         delete noiseindev_steepness;
 103         //delete noise_height_select;
 104         //delete noise_trees;
 105         delete noiseindev_mud;
 106         //delete noise_beach;
 107         delete noiseindev_float_islands1;
 108         delete noiseindev_float_islands2;
 109         delete noiseindev_float_islands3;
 110         delete noiseindev_biome;
 111 }
 112
 113 void MapgenIndev::calculateNoise() {
 114         int x = node_min.X;
 115         int y = node_min.Y;
 116         int z = node_min.Z;
 117         // Need to adjust for the original implementation's +.5 offset...
 118         if (!(flags & MG_FLAT)) {
 119                 noiseindev_terrain_base->perlinMap2D(
 120                         x + 0.5 * noiseindev_terrain_base->npindev->spread.X * farscale(noiseindev_terrain_base->npindev->farspread, x, z),
 121                         z + 0.5 * noiseindev_terrain_base->npindev->spread.Z * farscale(noiseindev_terrain_base->npindev->farspread, x, z));
 122                 noiseindev_terrain_base->transformNoiseMapFarScale(x, y, z);
 123
 124                 noiseindev_terrain_higher->perlinMap2D(
 125                         x + 0.5 * noiseindev_terrain_higher->npindev->spread.X * farscale(noiseindev_terrain_higher->npindev->farspread, x, z),
 126                         z + 0.5 * noiseindev_terrain_higher->npindev->spread.Z * farscale(noiseindev_terrain_higher->npindev->farspread, x, z));
 127                 noiseindev_terrain_higher->transformNoiseMapFarScale(x, y, z);
 128
 129                 noiseindev_steepness->perlinMap2D(
 130                         x + 0.5 * noiseindev_steepness->npindev->spread.X * farscale(noiseindev_steepness->npindev->farspread, x, z),
 131                         z + 0.5 * noiseindev_steepness->npindev->spread.Z * farscale(noiseindev_steepness->npindev->farspread, x, z));
 132                 noiseindev_steepness->transformNoiseMapFarScale(x, y, z);
 133
 134                 noise_height_select->perlinMap2D(
 135                         x + 0.5 * noise_height_select->np->spread.X,
 136                         z + 0.5 * noise_height_select->np->spread.Z);
 137
 138                 noiseindev_float_islands1->perlinMap3D(
 139                         x + 0.33 * noiseindev_float_islands1->npindev->spread.X * farscale(noiseindev_float_islands1->npindev->farspread, x, y, z),
 140                         y + 0.33 * noiseindev_float_islands1->npindev->spread.Y * farscale(noiseindev_float_islands1->npindev->farspread, x, y, z),
 141                         z + 0.33 * noiseindev_float_islands1->npindev->spread.Z * farscale(noiseindev_float_islands1->npindev->farspread, x, y, z)
 142                 );
 143                 noiseindev_float_islands1->transformNoiseMapFarScale(x, y, z);
 144
 145                 noiseindev_float_islands2->perlinMap3D(
 146                         x + 0.33 * noiseindev_float_islands2->npindev->spread.X * farscale(noiseindev_float_islands2->npindev->farspread, x, y, z),
 147                         y + 0.33 * noiseindev_float_islands2->npindev->spread.Y * farscale(noiseindev_float_islands2->npindev->farspread, x, y, z),
 148                         z + 0.33 * noiseindev_float_islands2->npindev->spread.Z * farscale(noiseindev_float_islands2->npindev->farspread, x, y, z)
 149                 );
 150                 noiseindev_float_islands2->transformNoiseMapFarScale(x, y, z);
 151
 152                 noiseindev_float_islands3->perlinMap2D(
 153                         x + 0.5 * noiseindev_float_islands3->npindev->spread.X * farscale(noiseindev_float_islands3->npindev->farspread, x, z),
 154                         z + 0.5 * noiseindev_float_islands3->npindev->spread.Z * farscale(noiseindev_float_islands3->npindev->farspread, x, z));
 155                 noiseindev_float_islands3->transformNoiseMapFarScale(x, y, z);
 156
 157         }
 158
 159         if (!(flags & MG_FLAT)) {
 160                 noiseindev_mud->perlinMap2D(
 161                         x + 0.5 * noiseindev_mud->npindev->spread.X * farscale(noiseindev_mud->npindev->farspread, x, y, z),
 162                         z + 0.5 * noiseindev_mud->npindev->spread.Z * farscale(noiseindev_mud->npindev->farspread, x, y, z));
 163                 noiseindev_mud->transformNoiseMapFarScale(x, y, z);
 164         }
 165         noise_beach->perlinMap2D(
 166                 x + 0.2 * noise_beach->np->spread.X,
 167                 z + 0.7 * noise_beach->np->spread.Z);
 168
 169         noise_biome->perlinMap2D(
 170                 x + 0.6 * noiseindev_biome->npindev->spread.X * farscale(noiseindev_biome->npindev->farspread, x, z),
 171                 z + 0.2 * noiseindev_biome->npindev->spread.Z * farscale(noiseindev_biome->npindev->farspread, x, z));
 172 }
 173
 174 bool MapgenIndevParams::readParams(Settings *settings) {
 175         freq_desert = settings->getFloat("mgv6_freq_desert");
 176         freq_beach  = settings->getFloat("mgv6_freq_beach");
 177
 178         npindev_terrain_base   = settings->getNoiseIndevParams("mgindev_np_terrain_base");
 179         npindev_terrain_higher = settings->getNoiseIndevParams("mgindev_np_terrain_higher");
 180         npindev_steepness      = settings->getNoiseIndevParams("mgindev_np_steepness");
 181         np_height_select  = settings->getNoiseParams("mgv6_np_height_select");
 182         np_trees          = settings->getNoiseParams("mgv6_np_trees");
 183         npindev_mud            = settings->getNoiseIndevParams("mgindev_np_mud");
 184         np_beach          = settings->getNoiseParams("mgv6_np_beach");
 185         npindev_biome     = settings->getNoiseIndevParams("mgindev_np_biome");
 186         np_cave           = settings->getNoiseParams("mgv6_np_cave");
 187         npindev_float_islands1  = settings->getNoiseIndevParams("mgindev_np_float_islands1");
 188         npindev_float_islands2  = settings->getNoiseIndevParams("mgindev_np_float_islands2");
 189         npindev_float_islands3  = settings->getNoiseIndevParams("mgindev_np_float_islands3");
 190
 191         bool success =
 192                 npindev_terrain_base  && npindev_terrain_higher && npindev_steepness &&
 193                 np_height_select && np_trees          && npindev_mud       &&
 194                 np_beach         && np_biome          && np_cave &&
 195                 npindev_float_islands1 && npindev_float_islands2 && npindev_float_islands3;
 196         return success;
 197 }
 198
 199 void MapgenIndevParams::writeParams(Settings *settings) {
 200         settings->setFloat("mgv6_freq_desert", freq_desert);
 201         settings->setFloat("mgv6_freq_beach",  freq_beach);
 202
 203         settings->setNoiseIndevParams("mgindev_np_terrain_base",   npindev_terrain_base);
 204         settings->setNoiseIndevParams("mgindev_np_terrain_higher", npindev_terrain_higher);
 205         settings->setNoiseIndevParams("mgindev_np_steepness",      npindev_steepness);
 206         settings->setNoiseParams("mgv6_np_height_select",  np_height_select);
 207         settings->setNoiseParams("mgv6_np_trees",          np_trees);
 208         settings->setNoiseIndevParams("mgindev_np_mud",            npindev_mud);
 209         settings->setNoiseParams("mgv6_np_beach",          np_beach);
 210         settings->setNoiseIndevParams("mgindev_np_biome",          npindev_biome);
 211         settings->setNoiseParams("mgv6_np_cave",           np_cave);
 212         settings->setNoiseIndevParams("mgindev_np_float_islands1",  npindev_float_islands1);
 213         settings->setNoiseIndevParams("mgindev_np_float_islands2",  npindev_float_islands2);
 214         settings->setNoiseIndevParams("mgindev_np_float_islands3",  npindev_float_islands3);
 215 }
 216
 217
 218 float MapgenIndev::baseTerrainLevelFromNoise(v2s16 p) {
 219         if (flags & MG_FLAT)
 220                 return water_level;
 221
 222         float terrain_base   = NoisePerlin2DPosOffset(noiseindev_terrain_base->npindev,
 223                                                         p.X, 0.5, p.Y, 0.5, seed);
 224         float terrain_higher = NoisePerlin2DPosOffset(noiseindev_terrain_higher->npindev,
 225                                                         p.X, 0.5, p.Y, 0.5, seed);
 226         float steepness      = NoisePerlin2DPosOffset(noiseindev_steepness->npindev,
 227                                                         p.X, 0.5, p.Y, 0.5, seed);
 228         float height_select  = NoisePerlin2DNoTxfmPosOffset(noise_height_select->np,
 229                                                         p.X, 0.5, p.Y, 0.5, seed);
 230
 231         return baseTerrainLevel(terrain_base, terrain_higher,
 232                                                         steepness,    height_select);
 233 }
 234
 235 float MapgenIndev::baseTerrainLevelFromMap(int index) {
 236         if (flags & MG_FLAT)
 237                 return water_level;
 238
 239         float terrain_base   = noiseindev_terrain_base->result[index];
 240         float terrain_higher = noiseindev_terrain_higher->result[index];
 241         float steepness      = noiseindev_steepness->result[index];
 242         float height_select  = noise_height_select->result[index];
 243
 244         return baseTerrainLevel(terrain_base, terrain_higher,
 245                                                         steepness,    height_select);
 246 }
 247
 248 float MapgenIndev::getMudAmount(int index) {
 249         if (flags & MG_FLAT)
 250                 return AVERAGE_MUD_AMOUNT;
 251
 252         /*return ((float)AVERAGE_MUD_AMOUNT + 2.0 * noise2d_perlin(
 253                         0.5+(float)p.X/200, 0.5+(float)p.Y/200,
 254                         seed+91013, 3, 0.55));*/
 255
 256         return noiseindev_mud->result[index];
 257 }
 258
 259 void MapgenIndev::defineCave(Cave & cave, PseudoRandom ps, v3s16 node_min, bool large_cave) {
 260         cave.min_tunnel_diameter = 2;
 261         cave.max_tunnel_diameter = ps.range(2,6);
 262         cave.dswitchint = ps.range(1,14);
 263         cave.flooded = large_cave && ps.range(0,4);
 264         if(large_cave){
 265                 cave.part_max_length_rs = ps.range(2,4);
 266                 if (node_min.Y < -100 && !ps.range(0, farscale(0.2, node_min.X,node_min.Y,node_min.Z)*30)) { //huge
 267                         cave.flooded = !ps.range(0, 3);
 268                         cave.tunnel_routepoints = ps.range(5, 20);
 269                         cave.min_tunnel_diameter = 30;
 270                         cave.max_tunnel_diameter = ps.range(40, ps.range(80,120));
 271                 } else {
 272                         cave.tunnel_routepoints = ps.range(5, ps.range(15,30));
 273                         cave.min_tunnel_diameter = 5;
 274                         cave.max_tunnel_diameter = ps.range(7, ps.range(8,24));
 275                 }
 276         } else {
 277                 cave.part_max_length_rs = ps.range(2,9);
 278                 cave.tunnel_routepoints = ps.range(10, ps.range(15,30));
 279         }
 280         cave.large_cave_is_flat = (ps.range(0,1) == 0);
 281 }
 282
 283 /*
 284 // version with one perlin3d. use with good params like
 285 settings->setDefault("mgindev_np_float_islands1",  "-9.5, 10,  (20,  50,  50 ), 45123, 5, 0.6,  1.5, 5");
 286 void MapgenIndev::generateFloatIslands(int min_y) {
 287         if (node_min.Y < min_y) return;
 288         v3s16 p0(node_min.X, node_min.Y, node_min.Z);
 289         MapNode n1(c_stone), n2(c_desert_stone);
 290         int xl = node_max.X - node_min.X;
 291         int yl = node_max.Y - node_min.Y;
 292         int zl = node_max.Z - node_min.Z;
 293         u32 index = 0;
 294         for (int x1 = 0; x1 <= xl; x1++)
 295         {
 296                 //int x = x1 + node_min.Y;
 297                 for (int z1 = 0; z1 <= zl; z1++)
 298                 {
 299                         //int z = z1 + node_min.Z;
 300                         for (int y1 = 0; y1 <= yl; y1++, index++)
 301                         {
 302                                 //int y = y1 + node_min.Y;
 303                                 float noise = noiseindev_float_islands1->result[index];
 304                                 //dstream << " y1="<<y1<< " x1="<<x1<<" z1="<<z1<< " noise="<<noise << std::endl;
 305                                 if (noise > 0 ) {
 306                                         v3s16 p = p0 + v3s16(x1, y1, z1);
 307                                         u32 i = vm->m_area.index(p);
 308                                         if (!vm->m_area.contains(i))
 309                                                 continue;
 310                                         // Cancel if not  air
 311                                         if (vm->m_data[i].getContent() != CONTENT_AIR)
 312                                                 continue;
 313                                         vm->m_data[i] = noise > 1 ? n1 : n2;
 314                                 }
 315                         }
 316                 }
 317         }
 318 }
 319 */
 320
 321 void MapgenIndev::generateFloatIslands(int min_y) {
 322         if (node_min.Y < min_y) return;
 323         PseudoRandom pr(blockseed + 985);
 324         // originally from http://forum.minetest.net/viewtopic.php?id=4776
 325         float RAR = 0.8 * farscale(0.4, node_min.Y); // 0.4; // Island rarity in chunk layer. -0.4 = thick layer with holes, 0 = 50%, 0.4 = desert rarity, 0.7 = very rare.
 326         float AMPY = 24; // 24; // Amplitude of island centre y variation.
 327         float TGRAD = 24; // 24; // Noise gradient to create top surface. Tallness of island top.
 328         float BGRAD = 24; // 24; // Noise gradient to create bottom surface. Tallness of island bottom.
 329
 330         v3s16 p0(node_min.X, node_min.Y, node_min.Z);
 331         MapNode n1(c_stone);
 332
 333         float xl = node_max.X - node_min.X;
 334         float yl = node_max.Y - node_min.Y;
 335         float zl = node_max.Z - node_min.Z;
 336         float midy = node_min.Y + yl * 0.5;
 337         u32 index = 0, index2d = 0;
 338         for (int x1 = 0; x1 <= xl; ++x1)
 339         {
 340                 for (int z1 = 0; z1 <= zl; ++z1, ++index2d)
 341                 {
 342                         float noise3 = noiseindev_float_islands3->result[index2d];
 343                         float pmidy = midy + noise3 / 1.5 * AMPY;
 344                         for (int y1 = 0; y1 <= yl; ++y1, ++index)
 345                         {
 346                                 int y = y1 + node_min.Y;
 347                                 float noise1 = noiseindev_float_islands1->result[index];
 348                                 float offset = y > pmidy ? (y - pmidy) / TGRAD : (pmidy - y) / BGRAD;
 349                                 float noise1off = noise1 - offset - RAR;
 350                                 if (noise1off > 0 && noise1off < 0.7) {
 351                                         float noise2 = noiseindev_float_islands2->result[index];
 352                                         if (noise2 - noise1off > -0.7){
 353                                                 v3s16 p = p0 + v3s16(x1, y1, z1);
 354                                                 u32 i = vm->m_area.index(p);
 355                                                 if (!vm->m_area.contains(i))
 356                                                         continue;
 357                                                 // Cancel if not  air
 358                                                 if (vm->m_data[i].getContent() != CONTENT_AIR)
 359                                                         continue;
 360                                                 vm->m_data[i] = n1;
 361                                         }
 362                                 }
 363                         }
 364                 }
 365         }
 366 }
 367
 368 void MapgenIndev::generateSomething() {
 369         int float_islands = g_settings->getS16("mgindev_float_islands");
 370         if(float_islands) generateFloatIslands(float_islands);
 371 }