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 enum MgStoneType {
  83         MGSTONE_STONE,
  84         MGSTONE_DESERT_STONE,
  85         MGSTONE_SANDSTONE,
  86         MGSTONE_OTHER,
  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 = 0;
 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_CARPATHIAN,
 122         MAPGEN_INVALID,
 123 };
 124
 125 struct MapgenParams {
 126         MapgenParams() {}
 127         virtual ~MapgenParams();
 128
 129         MapgenType mgtype = MAPGEN_DEFAULT;
 130         s16 chunksize = 5;
 131         u64 seed = 0;
 132         s16 water_level = 1;
 133         s16 mapgen_limit = MAX_MAP_GENERATION_LIMIT;
 134         u32 flags = MG_CAVES | MG_LIGHT | MG_DECORATIONS;
 135
 136         BiomeParams *bparams = nullptr;
 137
 138         s16 mapgen_edge_min = -MAX_MAP_GENERATION_LIMIT;
 139         s16 mapgen_edge_max = MAX_MAP_GENERATION_LIMIT;
 140
 141         virtual void readParams(const Settings *settings);
 142         virtual void writeParams(Settings *settings) const;
 143
 144         bool saoPosOverLimit(const v3f &p);
 145         s32 getSpawnRangeMax();
 146
 147 private:
 148         void calcMapgenEdges();
 149
 150         float m_sao_limit_min = -MAX_MAP_GENERATION_LIMIT * BS;
 151         float m_sao_limit_max = MAX_MAP_GENERATION_LIMIT * BS;
 152         bool m_mapgen_edges_calculated = false;
 153 };
 154
 155
 156 /*
 157         Generic interface for map generators.  All mapgens must inherit this class.
 158         If a feature exposed by a public member pointer is not supported by a
 159         certain mapgen, it must be set to NULL.
 160
 161         Apart from makeChunk, getGroundLevelAtPoint, and getSpawnLevelAtPoint, all
 162         methods can be used by constructing a Mapgen base class and setting the
 163         appropriate public members (e.g. vm, ndef, and so on).
 164 */
 165 class Mapgen {
 166 public:
 167         s32 seed = 0;
 168         int water_level = 0;
 169         int mapgen_limit = 0;
 170         u32 flags = 0;
 171         bool generating = false;
 172         int id = -1;
 173
 174         MMVManip *vm = nullptr;
 175         INodeDefManager *ndef = nullptr;
 176
 177         u32 blockseed;
 178         s16 *heightmap = nullptr;
 179         biome_t *biomemap = nullptr;
 180         v3s16 csize;
 181
 182         BiomeGen *biomegen = nullptr;
 183         GenerateNotifier gennotify;
 184
 185         Mapgen();
 186         Mapgen(int mapgenid, MapgenParams *params, EmergeManager *emerge);
 187         virtual ~Mapgen();
 188         DISABLE_CLASS_COPY(Mapgen);
 189
 190         virtual MapgenType getType() const { return MAPGEN_INVALID; }
 191
 192         static u32 getBlockSeed(v3s16 p, s32 seed);
 193         static u32 getBlockSeed2(v3s16 p, s32 seed);
 194         s16 findGroundLevelFull(v2s16 p2d);
 195         s16 findGroundLevel(v2s16 p2d, s16 ymin, s16 ymax);
 196         s16 findLiquidSurface(v2s16 p2d, s16 ymin, s16 ymax);
 197         void updateHeightmap(v3s16 nmin, v3s16 nmax);
 198         void updateLiquid(UniqueQueue<v3s16> *trans_liquid, v3s16 nmin, v3s16 nmax);
 199
 200         void setLighting(u8 light, v3s16 nmin, v3s16 nmax);
 201         void lightSpread(VoxelArea &a, v3s16 p, u8 light);
 202         void calcLighting(v3s16 nmin, v3s16 nmax, v3s16 full_nmin, v3s16 full_nmax,
 203                 bool propagate_shadow = true);
 204         void propagateSunlight(v3s16 nmin, v3s16 nmax, bool propagate_shadow);
 205         void spreadLight(v3s16 nmin, v3s16 nmax);
 206
 207         virtual void makeChunk(BlockMakeData *data) {}
 208         virtual int getGroundLevelAtPoint(v2s16 p) { return 0; }
 209
 210         // getSpawnLevelAtPoint() is a function within each mapgen that returns a
 211         // suitable y co-ordinate for player spawn ('suitable' usually meaning
 212         // within 16 nodes of water_level). If a suitable spawn level cannot be
 213         // found at the specified (X, Z) 'MAX_MAP_GENERATION_LIMIT' is returned to
 214         // signify this and to cause Server::findSpawnPos() to try another (X, Z).
 215         virtual int getSpawnLevelAtPoint(v2s16 p) { return 0; }
 216
 217         // Mapgen management functions
 218         static MapgenType getMapgenType(const std::string &mgname);
 219         static const char *getMapgenName(MapgenType mgtype);
 220         static Mapgen *createMapgen(MapgenType mgtype, int mgid,
 221                 MapgenParams *params, EmergeManager *emerge);
 222         static MapgenParams *createMapgenParams(MapgenType mgtype);
 223         static void getMapgenNames(std::vector<const char *> *mgnames, bool include_hidden);
 224
 225 private:
 226         // isLiquidHorizontallyFlowable() is a helper function for updateLiquid()
 227         // that checks whether there are floodable nodes without liquid beneath
 228         // the node at index vi.
 229         inline bool isLiquidHorizontallyFlowable(u32 vi, v3s16 em);
 230 };
 231
 232 /*
 233         MapgenBasic is a Mapgen implementation that handles basic functionality
 234         the majority of conventional mapgens will probably want to use, but isn't
 235         generic enough to be included as part of the base Mapgen class (such as
 236         generating biome terrain over terrain node skeletons, generating caves,
 237         dungeons, etc.)
 238
 239         Inherit MapgenBasic instead of Mapgen to add this basic functionality to
 240         your mapgen without having to reimplement it.  Feel free to override any of
 241         these methods if you desire different or more advanced behavior.
 242
 243         Note that you must still create your own generateTerrain implementation when
 244         inheriting MapgenBasic.
 245 */
 246 class MapgenBasic : public Mapgen {
 247 public:
 248         MapgenBasic(int mapgenid, MapgenParams *params, EmergeManager *emerge);
 249         virtual ~MapgenBasic();
 250
 251         virtual void generateCaves(s16 max_stone_y, s16 large_cave_depth);
 252         virtual bool generateCaverns(s16 max_stone_y);
 253         virtual void generateDungeons(s16 max_stone_y,
 254                 MgStoneType stone_type, content_t biome_stone);
 255         virtual void generateBiomes(MgStoneType *mgstone_type,
 256                 content_t *biome_stone, s16 biome_zero_level);
 257         virtual void dustTopNodes();
 258
 259 protected:
 260         EmergeManager *m_emerge;
 261         BiomeManager *m_bmgr;
 262
 263         Noise *noise_filler_depth;
 264
 265         v3s16 node_min;
 266         v3s16 node_max;
 267         v3s16 full_node_min;
 268         v3s16 full_node_max;
 269
 270         // Content required for generateBiomes
 271         content_t c_stone;
 272         content_t c_desert_stone;
 273         content_t c_sandstone;
 274         content_t c_water_source;
 275         content_t c_river_water_source;
 276         content_t c_lava_source;
 277
 278         // Content required for generateDungeons
 279         content_t c_cobble;
 280         content_t c_stair_cobble;
 281         content_t c_mossycobble;
 282         content_t c_stair_desert_stone;
 283         content_t c_sandstonebrick;
 284         content_t c_stair_sandstone_block;
 285
 286         int ystride;
 287         int zstride;
 288         int zstride_1d;
 289         int zstride_1u1d;
 290
 291         u32 spflags;
 292
 293         NoiseParams np_cave1;
 294         NoiseParams np_cave2;
 295         NoiseParams np_cavern;
 296         float cave_width;
 297         float cavern_limit;
 298         float cavern_taper;
 299         float cavern_threshold;
 300         int lava_depth;
 301 };
 302
 303 #endif