src/mapgen.h

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2015 celeron55, Perttu Ahola <celeron55@gmail.com>
   4 Copyright (C) 2013-2016 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
   5 Copyright (C) 2015-2017 paramat
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU Lesser General Public License as published by
   9 the Free Software Foundation; either version 2.1 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU Lesser General Public License for more details.
  16
  17 You should have received a copy of the GNU Lesser General Public License along
  18 with this program; if not, write to the Free Software Foundation, Inc.,
  19 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20 */
  21
  22 #ifndef MAPGEN_HEADER
  23 #define MAPGEN_HEADER
  24
  25 #include "noise.h"
  26 #include "nodedef.h"
  27 #include "mapnode.h"
  28 #include "util/string.h"
  29 #include "util/container.h"
  30
  31 #define MAPGEN_DEFAULT MAPGEN_V7
  32 #define MAPGEN_DEFAULT_NAME "v7"
  33
  34 /////////////////// Mapgen flags
  35 #define MG_TREES       0x01  // Deprecated. Moved into mgv6 flags
  36 #define MG_CAVES       0x02
  37 #define MG_DUNGEONS    0x04
  38 #define MG_FLAT        0x08  // Deprecated. Moved into mgv6 flags
  39 #define MG_LIGHT       0x10
  40 #define MG_DECORATIONS 0x20
  41
  42 typedef u8 biome_t;  // copy from mg_biome.h to avoid an unnecessary include
  43
  44 class Settings;
  45 class MMVManip;
  46 class INodeDefManager;
  47
  48 extern FlagDesc flagdesc_mapgen[];
  49 extern FlagDesc flagdesc_gennotify[];
  50
  51 class Biome;
  52 class BiomeGen;
  53 struct BiomeParams;
  54 class BiomeManager;
  55 class EmergeManager;
  56 class MapBlock;
  57 class VoxelManipulator;
  58 struct BlockMakeData;
  59 class VoxelArea;
  60 class Map;
  61
  62 enum MapgenObject {
  63         MGOBJ_VMANIP,
  64         MGOBJ_HEIGHTMAP,
  65         MGOBJ_BIOMEMAP,
  66         MGOBJ_HEATMAP,
  67         MGOBJ_HUMIDMAP,
  68         MGOBJ_GENNOTIFY
  69 };
  70
  71 enum GenNotifyType {
  72         GENNOTIFY_DUNGEON,
  73         GENNOTIFY_TEMPLE,
  74         GENNOTIFY_CAVE_BEGIN,
  75         GENNOTIFY_CAVE_END,
  76         GENNOTIFY_LARGECAVE_BEGIN,
  77         GENNOTIFY_LARGECAVE_END,
  78         GENNOTIFY_DECORATION,
  79         NUM_GENNOTIFY_TYPES
  80 };
  81
  82 // TODO(hmmmm/paramat): make stone type selection dynamic
  83 enum MgStoneType {
  84         MGSTONE_STONE,
  85         MGSTONE_DESERT_STONE,
  86         MGSTONE_SANDSTONE,
  87 };
  88
  89 struct GenNotifyEvent {
  90         GenNotifyType type;
  91         v3s16 pos;
  92         u32 id;
  93 };
  94
  95 class GenerateNotifier {
  96 public:
  97         GenerateNotifier();
  98         GenerateNotifier(u32 notify_on, std::set<u32> *notify_on_deco_ids);
  99
 100         void setNotifyOn(u32 notify_on);
 101         void setNotifyOnDecoIds(std::set<u32> *notify_on_deco_ids);
 102
 103         bool addEvent(GenNotifyType type, v3s16 pos, u32 id=0);
 104         void getEvents(std::map<std::string, std::vector<v3s16> > &event_map,
 105                 bool peek_events=false);
 106
 107 private:
 108         u32 m_notify_on;
 109         std::set<u32> *m_notify_on_deco_ids;
 110         std::list<GenNotifyEvent> m_notify_events;
 111 };
 112
 113 enum MapgenType {
 114         MAPGEN_V5,
 115         MAPGEN_V6,
 116         MAPGEN_V7,
 117         MAPGEN_FLAT,
 118         MAPGEN_FRACTAL,
 119         MAPGEN_VALLEYS,
 120         MAPGEN_SINGLENODE,
 121         MAPGEN_INVALID,
 122 };
 123
 124 struct MapgenParams {
 125         MapgenType mgtype;
 126         s16 chunksize;
 127         u64 seed;
 128         s16 water_level;
 129         s16 mapgen_limit;
 130         u32 flags;
 131
 132         BiomeParams *bparams;
 133
 134         MapgenParams() :
 135                 mgtype(MAPGEN_DEFAULT),
 136                 chunksize(5),
 137                 seed(0),
 138                 water_level(1),
 139                 mapgen_limit(MAX_MAP_GENERATION_LIMIT),
 140                 flags(MG_CAVES | MG_LIGHT | MG_DECORATIONS),
 141                 bparams(NULL)
 142         {
 143         }
 144
 145         virtual ~MapgenParams();
 146
 147         virtual void readParams(const Settings *settings);
 148         virtual void writeParams(Settings *settings) const;
 149 };
 150
 151
 152 /*
 153         Generic interface for map generators.  All mapgens must inherit this class.
 154         If a feature exposed by a public member pointer is not supported by a
 155         certain mapgen, it must be set to NULL.
 156
 157         Apart from makeChunk, getGroundLevelAtPoint, and getSpawnLevelAtPoint, all
 158         methods can be used by constructing a Mapgen base class and setting the
 159         appropriate public members (e.g. vm, ndef, and so on).
 160 */
 161 class Mapgen {
 162 public:
 163         s32 seed;
 164         int water_level;
 165         int mapgen_limit;
 166         u32 flags;
 167         bool generating;
 168         int id;
 169
 170         MMVManip *vm;
 171         INodeDefManager *ndef;
 172
 173         u32 blockseed;
 174         s16 *heightmap;
 175         biome_t *biomemap;
 176         v3s16 csize;
 177
 178         BiomeGen *biomegen;
 179         GenerateNotifier gennotify;
 180
 181         Mapgen();
 182         Mapgen(int mapgenid, MapgenParams *params, EmergeManager *emerge);
 183         virtual ~Mapgen();
 184
 185         virtual MapgenType getType() const { return MAPGEN_INVALID; }
 186
 187         static u32 getBlockSeed(v3s16 p, s32 seed);
 188         static u32 getBlockSeed2(v3s16 p, s32 seed);
 189         s16 findGroundLevelFull(v2s16 p2d);
 190         s16 findGroundLevel(v2s16 p2d, s16 ymin, s16 ymax);
 191         s16 findLiquidSurface(v2s16 p2d, s16 ymin, s16 ymax);
 192         void updateHeightmap(v3s16 nmin, v3s16 nmax);
 193         void updateLiquid(UniqueQueue<v3s16> *trans_liquid, v3s16 nmin, v3s16 nmax);
 194
 195         void setLighting(u8 light, v3s16 nmin, v3s16 nmax);
 196         void lightSpread(VoxelArea &a, v3s16 p, u8 light);
 197         void calcLighting(v3s16 nmin, v3s16 nmax, v3s16 full_nmin, v3s16 full_nmax,
 198                 bool propagate_shadow = true);
 199         void propagateSunlight(v3s16 nmin, v3s16 nmax, bool propagate_shadow);
 200         void spreadLight(v3s16 nmin, v3s16 nmax);
 201
 202         virtual void makeChunk(BlockMakeData *data) {}
 203         virtual int getGroundLevelAtPoint(v2s16 p) { return 0; }
 204
 205         // getSpawnLevelAtPoint() is a function within each mapgen that returns a
 206         // suitable y co-ordinate for player spawn ('suitable' usually meaning
 207         // within 16 nodes of water_level). If a suitable spawn level cannot be
 208         // found at the specified (X, Z) 'MAX_MAP_GENERATION_LIMIT' is returned to
 209         // signify this and to cause Server::findSpawnPos() to try another (X, Z).
 210         virtual int getSpawnLevelAtPoint(v2s16 p) { return 0; }
 211
 212         // Mapgen management functions
 213         static MapgenType getMapgenType(const std::string &mgname);
 214         static const char *getMapgenName(MapgenType mgtype);
 215         static Mapgen *createMapgen(MapgenType mgtype, int mgid,
 216                 MapgenParams *params, EmergeManager *emerge);
 217         static MapgenParams *createMapgenParams(MapgenType mgtype);
 218         static void getMapgenNames(std::vector<const char *> *mgnames, bool include_hidden);
 219
 220 private:
 221         // isLiquidHorizontallyFlowable() is a helper function for updateLiquid()
 222         // that checks whether there are floodable nodes without liquid beneath
 223         // the node at index vi.
 224         inline bool isLiquidHorizontallyFlowable(u32 vi, v3s16 em);
 225         DISABLE_CLASS_COPY(Mapgen);
 226 };
 227
 228 /*
 229         MapgenBasic is a Mapgen implementation that handles basic functionality
 230         the majority of conventional mapgens will probably want to use, but isn't
 231         generic enough to be included as part of the base Mapgen class (such as
 232         generating biome terrain over terrain node skeletons, generating caves,
 233         dungeons, etc.)
 234
 235         Inherit MapgenBasic instead of Mapgen to add this basic functionality to
 236         your mapgen without having to reimplement it.  Feel free to override any of
 237         these methods if you desire different or more advanced behavior.
 238
 239         Note that you must still create your own generateTerrain implementation when
 240         inheriting MapgenBasic.
 241 */
 242 class MapgenBasic : public Mapgen {
 243 public:
 244         MapgenBasic(int mapgenid, MapgenParams *params, EmergeManager *emerge);
 245         virtual ~MapgenBasic();
 246
 247         virtual void generateCaves(s16 max_stone_y, s16 large_cave_depth);
 248         virtual bool generateCaverns(s16 max_stone_y);
 249         virtual void generateDungeons(s16 max_stone_y, MgStoneType stone_type);
 250         virtual MgStoneType generateBiomes();
 251         virtual void dustTopNodes();
 252
 253 protected:
 254         EmergeManager *m_emerge;
 255         BiomeManager *m_bmgr;
 256
 257         Noise *noise_filler_depth;
 258
 259         v3s16 node_min;
 260         v3s16 node_max;
 261         v3s16 full_node_min;
 262         v3s16 full_node_max;
 263
 264         // Content required for generateBiomes
 265         content_t c_stone;
 266         content_t c_desert_stone;
 267         content_t c_sandstone;
 268         content_t c_water_source;
 269         content_t c_river_water_source;
 270         content_t c_lava_source;
 271
 272         // Content required for generateDungeons
 273         content_t c_cobble;
 274         content_t c_stair_cobble;
 275         content_t c_mossycobble;
 276         content_t c_stair_desert_stone;
 277         content_t c_sandstonebrick;
 278         content_t c_stair_sandstone_block;
 279
 280         int ystride;
 281         int zstride;
 282         int zstride_1d;
 283         int zstride_1u1d;
 284
 285         u32 spflags;
 286
 287         NoiseParams np_cave1;
 288         NoiseParams np_cave2;
 289         NoiseParams np_cavern;
 290         float cave_width;
 291         float cavern_limit;
 292         float cavern_taper;
 293         float cavern_threshold;
 294 };
 295
 296 #endif