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 "log.h"
  23
  24 /////////////////// Mapgen Indev perlin noise default values
  25
  26 NoiseIndevParams nparams_indev_def_terrain_base
  27         (-AVERAGE_MUD_AMOUNT, 20.0, v3f(250.0, 250.0, 250.0), 82341, 5, 0.6, 1);
  28 NoiseIndevParams nparams_indev_def_terrain_higher
  29         (20.0, 16.0, v3f(500.0, 500.0, 500.0), 85039, 5, 0.6, 1);
  30 NoiseIndevParams nparams_indev_def_steepness
  31         (0.85, 0.5, v3f(125.0, 125.0, 125.0), -932, 5, 0.7, 1);
  32 NoiseIndevParams nparams_indev_def_mud
  33         (AVERAGE_MUD_AMOUNT, 2.0, v3f(200.0, 200.0, 200.0), 91013, 3, 0.55, 1);
  34
  35 ///////////////////////////////////////////////////////////////////////////////
  36
  37 void NoiseIndev::init(NoiseIndevParams *np, int seed, int sx, int sy, int sz) {
  38         Noise::init((NoiseParams*)np, seed, sx, sy, sz);
  39         this->npindev   = np;
  40 }
  41
  42
  43 NoiseIndev::NoiseIndev(NoiseIndevParams *np, int seed, int sx, int sy) : Noise(np, seed, sx, sy) {
  44         init(np, seed, sx, sy, 1);
  45 }
  46
  47
  48 NoiseIndev::NoiseIndev(NoiseIndevParams *np, int seed, int sx, int sy, int sz) : Noise(np, seed, sx, sy, sz) {
  49         init(np, seed, sx, sy, sz);
  50 }
  51
  52
  53 float farscale(float scale, float x, float y, float z) {
  54         return ( 1 + ( 1 - (MAP_GENERATION_LIMIT * 3 - (fabs(x) + fabs(y) + fabs(z)) ) / (MAP_GENERATION_LIMIT * 3) ) * (scale - 1) );
  55 }
  56
  57 void NoiseIndev::transformNoiseMapFarScale(float xx, float yy, float zz) {
  58         // more correct use distantion from 0,0,0 via pow, but + is faster
  59         //float farscale = ( 1 + ( 1 - (MAP_GENERATION_LIMIT * 3 - (fabs(xx) + fabs(yy) + fabs(zz)) ) / (MAP_GENERATION_LIMIT * 3) ) * ((npindev)->farscale - 1) );
  60         // dstream << "TNM rs="  << farscale << " from=" << (npindev)->farscale << " x=" << xx << " y=" << yy <<" z=" << zz << std::endl;
  61         int i = 0;
  62         for (int z = 0; z != sz; z++) {
  63                 for (int y = 0; y != sy; y++) {
  64                         for (int x = 0; x != sx; x++) {
  65                                 //result[i] = result[i] * npindev->scale * farscale + npindev->offset;
  66                                 result[i] = result[i] * npindev->scale * farscale(npindev->farscale,xx,yy,zz) + npindev->offset;
  67                                 i++;
  68                         }
  69                 }
  70         }
  71 }
  72
  73 MapgenIndev::MapgenIndev(int mapgenid, MapgenIndevParams *params) : MapgenV6(mapgenid, params) {
  74         noiseindev_terrain_base   = new NoiseIndev(params->npindev_terrain_base,   seed, csize.X, csize.Y);
  75         noiseindev_terrain_higher = new NoiseIndev(params->npindev_terrain_higher, seed, csize.X, csize.Y);
  76         noiseindev_steepness      = new NoiseIndev(params->npindev_steepness,      seed, csize.X, csize.Y);
  77 //        noise_height_select  = new Noise(params->np_height_select,  seed, csize.X, csize.Y);
  78 //        noise_trees          = new Noise(params->np_trees,          seed, csize.X, csize.Y);
  79         noiseindev_mud            = new NoiseIndev(params->npindev_mud,            seed, csize.X, csize.Y);
  80 //        noise_beach          = new Noise(params->np_beach,          seed, csize.X, csize.Y);
  81 //        noise_biome          = new Noise(params->np_biome,          seed, csize.X, csize.Y);
  82 }
  83
  84 MapgenIndev::~MapgenIndev() {
  85         delete noiseindev_terrain_base;
  86         delete noiseindev_terrain_higher;
  87         delete noiseindev_steepness;
  88         //delete noise_height_select;
  89         //delete noise_trees;
  90         delete noiseindev_mud;
  91         //delete noise_beach;
  92         //delete noise_biome;
  93 }
  94
  95
  96 void MapgenIndev::calculateNoise() {
  97         int x = node_min.X;
  98         int y = node_min.Y;
  99         int z = node_min.Z;
 100         // Need to adjust for the original implementation's +.5 offset...
 101         if (!(flags & MG_FLAT)) {
 102                 noiseindev_terrain_base->perlinMap2D(
 103                         x + 0.5 * noiseindev_terrain_base->npindev->spread.X,
 104                         z + 0.5 * noiseindev_terrain_base->npindev->spread.Z);
 105                 noiseindev_terrain_base->transformNoiseMapFarScale(x, y, z);
 106                 //noise_terrain_base->transformNoiseMap();
 107
 108                 noiseindev_terrain_higher->perlinMap2D(
 109                         x + 0.5 * noiseindev_terrain_higher->npindev->spread.X,
 110                         z + 0.5 * noiseindev_terrain_higher->npindev->spread.Z);
 111                 noiseindev_terrain_higher->transformNoiseMapFarScale(x, y, z);
 112                 //noise_terrain_higher->transformNoiseMap();
 113
 114                 noiseindev_steepness->perlinMap2D(
 115                         x + 0.5 * noiseindev_steepness->npindev->spread.X,
 116                         z + 0.5 * noiseindev_steepness->npindev->spread.Z);
 117                 noiseindev_steepness->transformNoiseMapFarScale(x, y, z);
 118
 119                 noise_height_select->perlinMap2D(
 120                         x + 0.5 * noise_height_select->np->spread.X,
 121                         z + 0.5 * noise_height_select->np->spread.Z);
 122         }
 123
 124         if (!(flags & MG_FLAT)) {
 125                 noiseindev_mud->perlinMap2D(
 126                         x + 0.5 * noiseindev_mud->npindev->spread.X,
 127                         z + 0.5 * noiseindev_mud->npindev->spread.Z);
 128                 noiseindev_mud->transformNoiseMapFarScale(x, y, z);
 129         }
 130         noise_beach->perlinMap2D(
 131                 x + 0.2 * noise_beach->np->spread.X,
 132                 z + 0.7 * noise_beach->np->spread.Z);
 133
 134         noise_biome->perlinMap2D(
 135                 x + 0.6 * noise_biome->np->spread.X,
 136                 z + 0.2 * noise_biome->np->spread.Z);
 137 }
 138
 139 bool MapgenIndevParams::readParams(Settings *settings) {
 140         freq_desert = settings->getFloat("mgv6_freq_desert");
 141         freq_beach  = settings->getFloat("mgv6_freq_beach");
 142
 143         npindev_terrain_base   = settings->getNoiseIndevParams("mgindev_np_terrain_base");
 144         npindev_terrain_higher = settings->getNoiseIndevParams("mgindev_np_terrain_higher");
 145         npindev_steepness      = settings->getNoiseIndevParams("mgindev_np_steepness");
 146         np_height_select  = settings->getNoiseParams("mgv6_np_height_select");
 147         np_trees          = settings->getNoiseParams("mgv6_np_trees");
 148         npindev_mud            = settings->getNoiseIndevParams("mgindev_np_mud");
 149         np_beach          = settings->getNoiseParams("mgv6_np_beach");
 150         np_biome          = settings->getNoiseParams("mgv6_np_biome");
 151         np_cave           = settings->getNoiseParams("mgv6_np_cave");
 152
 153         bool success =
 154                 npindev_terrain_base  && npindev_terrain_higher && npindev_steepness &&
 155                 np_height_select && np_trees          && npindev_mud       &&
 156                 np_beach         && np_biome          && np_cave;
 157         return success;
 158 }
 159
 160
 161 void MapgenIndevParams::writeParams(Settings *settings) {
 162         settings->setFloat("mgv6_freq_desert", freq_desert);
 163         settings->setFloat("mgv6_freq_beach",  freq_beach);
 164
 165         settings->setNoiseIndevParams("mgindev_np_terrain_base",   npindev_terrain_base);
 166         settings->setNoiseIndevParams("mgindev_np_terrain_higher", npindev_terrain_higher);
 167         settings->setNoiseIndevParams("mgindev_np_steepness",      npindev_steepness);
 168         settings->setNoiseParams("mgv6_np_height_select",  np_height_select);
 169         settings->setNoiseParams("mgv6_np_trees",          np_trees);
 170         settings->setNoiseIndevParams("mgindev_np_mud",            npindev_mud);
 171         settings->setNoiseParams("mgv6_np_beach",          np_beach);
 172         settings->setNoiseParams("mgv6_np_biome",          np_biome);
 173         settings->setNoiseParams("mgv6_np_cave",           np_cave);
 174 }
 175
 176
 177 float MapgenIndev::baseTerrainLevelFromNoise(v2s16 p) {
 178         if (flags & MG_FLAT)
 179                 return water_level;
 180
 181         float terrain_base   = NoisePerlin2DPosOffset(noiseindev_terrain_base->npindev,
 182                                                         p.X, 0.5, p.Y, 0.5, seed);
 183         float terrain_higher = NoisePerlin2DPosOffset(noiseindev_terrain_higher->npindev,
 184                                                         p.X, 0.5, p.Y, 0.5, seed);
 185         float steepness      = NoisePerlin2DPosOffset(noiseindev_steepness->npindev,
 186                                                         p.X, 0.5, p.Y, 0.5, seed);
 187         float height_select  = NoisePerlin2DNoTxfmPosOffset(noise_height_select->np,
 188                                                         p.X, 0.5, p.Y, 0.5, seed);
 189
 190         return baseTerrainLevel(terrain_base, terrain_higher,
 191                                                         steepness,    height_select);
 192 }
 193
 194 float MapgenIndev::baseTerrainLevelFromMap(int index) {
 195         if (flags & MG_FLAT)
 196                 return water_level;
 197
 198         float terrain_base   = noiseindev_terrain_base->result[index];
 199         float terrain_higher = noiseindev_terrain_higher->result[index];
 200         float steepness      = noiseindev_steepness->result[index];
 201         float height_select  = noise_height_select->result[index];
 202
 203         return baseTerrainLevel(terrain_base, terrain_higher,
 204                                                         steepness,    height_select);
 205 }
 206
 207 float MapgenIndev::getMudAmount(int index)
 208 {
 209         if (flags & MG_FLAT)
 210                 return AVERAGE_MUD_AMOUNT;
 211
 212         /*return ((float)AVERAGE_MUD_AMOUNT + 2.0 * noise2d_perlin(
 213                         0.5+(float)p.X/200, 0.5+(float)p.Y/200,
 214                         seed+91013, 3, 0.55));*/
 215
 216         return noiseindev_mud->result[index];
 217 }
 218
 219 void MapgenIndev::defineCave(Cave & cave, PseudoRandom ps, v3s16 node_min, bool large_cave) {
 220         cave.min_tunnel_diameter = 2;
 221         cave.max_tunnel_diameter = ps.range(2,6);
 222         cave.dswitchint = ps.range(1,14);
 223         //cave.tunnel_routepoints = 0;
 224         //cave.part_max_length_rs = 0;
 225         cave.flooded = large_cave && ps.range(0,4);
 226         if(large_cave){
 227                 cave.part_max_length_rs = ps.range(2,4);
 228 //dstream<<"try:"<<farscale(0.2, node_min.X,node_min.Y,node_min.Z)*30<<std::endl;
 229                 if (node_min.Y < -500 && !ps.range(0, farscale(0.2, node_min.X,node_min.Y,node_min.Z)*30)) { //huge
 230                         cave.flooded = ps.range(0, 1);
 231 //dstream<<"HUGE:"<<cave.flooded<<std::endl;
 232                         cave.tunnel_routepoints = ps.range(5, 1522);
 233                         cave.min_tunnel_diameter = 30;
 234                         cave.max_tunnel_diameter = ps.range(30, ps.range(80,120));
 235                 } else {
 236 //dstream<<"large:"<<cave.flooded<<std::endl;
 237                         cave.tunnel_routepoints = ps.range(5, ps.range(15,30));
 238                         cave.min_tunnel_diameter = 5;
 239                         cave.max_tunnel_diameter = ps.range(7, ps.range(8,24));
 240                 }
 241         } else {
 242                 cave.part_max_length_rs = ps.range(2,9);
 243                 cave.tunnel_routepoints = ps.range(10, ps.range(15,30));
 244         }
 245         cave.large_cave_is_flat = (ps.range(0,1) == 0);
 246 };