src/mapgen/mapgen.h

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