src/mapgen.h

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