2011-06-25 17:12:41 +02:00
|
|
|
/*
|
2013-02-24 18:40:43 +01:00
|
|
|
Minetest
|
2018-01-15 03:26:15 +01:00
|
|
|
Copyright (C) 2010-2018 celeron55, Perttu Ahola <celeron55@gmail.com>
|
|
|
|
Copyright (C) 2013-2018 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
|
|
|
|
Copyright (C) 2015-2018 paramat
|
2011-06-25 17:12:41 +02:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
2012-06-05 16:56:56 +02:00
|
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
2011-06-25 17:12:41 +02:00
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2012-06-05 16:56:56 +02:00
|
|
|
GNU Lesser General Public License for more details.
|
2011-06-25 17:12:41 +02:00
|
|
|
|
2012-06-05 16:56:56 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
2011-06-25 17:12:41 +02:00
|
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
2017-08-17 22:19:39 +02:00
|
|
|
#pragma once
|
2011-06-25 17:12:41 +02:00
|
|
|
|
2014-12-09 06:37:48 +01:00
|
|
|
#include "noise.h"
|
2013-07-08 21:19:22 +02:00
|
|
|
#include "nodedef.h"
|
2014-11-13 05:01:13 +01:00
|
|
|
#include "util/string.h"
|
|
|
|
#include "util/container.h"
|
2013-01-06 20:40:24 +01:00
|
|
|
|
2016-12-01 22:53:43 +01:00
|
|
|
#define MAPGEN_DEFAULT MAPGEN_V7
|
|
|
|
#define MAPGEN_DEFAULT_NAME "v7"
|
2014-02-04 04:42:10 +01:00
|
|
|
|
2013-01-06 20:40:24 +01:00
|
|
|
/////////////////// Mapgen flags
|
2016-07-29 04:44:58 +02:00
|
|
|
#define MG_TREES 0x01 // Deprecated. Moved into mgv6 flags
|
2015-11-15 12:55:45 +01:00
|
|
|
#define MG_CAVES 0x02
|
|
|
|
#define MG_DUNGEONS 0x04
|
2016-07-29 04:44:58 +02:00
|
|
|
#define MG_FLAT 0x08 // Deprecated. Moved into mgv6 flags
|
2015-11-15 12:55:45 +01:00
|
|
|
#define MG_LIGHT 0x10
|
|
|
|
#define MG_DECORATIONS 0x20
|
2018-06-09 00:24:36 +02:00
|
|
|
#define MG_BIOMES 0x40
|
2013-01-06 20:40:24 +01:00
|
|
|
|
2016-06-04 09:00:45 +02:00
|
|
|
typedef u8 biome_t; // copy from mg_biome.h to avoid an unnecessary include
|
|
|
|
|
2014-11-13 05:01:13 +01:00
|
|
|
class Settings;
|
2015-01-05 08:42:27 +01:00
|
|
|
class MMVManip;
|
2018-02-10 21:04:16 +01:00
|
|
|
class NodeDefManager;
|
2013-12-14 07:52:06 +01:00
|
|
|
|
2013-02-14 04:43:15 +01:00
|
|
|
extern FlagDesc flagdesc_mapgen[];
|
2013-12-14 07:52:06 +01:00
|
|
|
extern FlagDesc flagdesc_gennotify[];
|
2013-02-14 04:43:15 +01:00
|
|
|
|
2012-11-26 03:16:48 +01:00
|
|
|
class Biome;
|
2016-04-28 09:43:09 +02:00
|
|
|
class BiomeGen;
|
|
|
|
struct BiomeParams;
|
2016-05-02 08:24:57 +02:00
|
|
|
class BiomeManager;
|
2013-01-23 04:32:30 +01:00
|
|
|
class EmergeManager;
|
2011-06-25 17:12:41 +02:00
|
|
|
class MapBlock;
|
2012-12-22 06:34:35 +01:00
|
|
|
class VoxelManipulator;
|
2013-03-23 07:24:31 +01:00
|
|
|
struct BlockMakeData;
|
2013-03-16 03:43:35 +01:00
|
|
|
class VoxelArea;
|
2013-06-22 06:29:44 +02:00
|
|
|
class Map;
|
2012-11-26 03:16:48 +01:00
|
|
|
|
2013-12-14 07:52:06 +01:00
|
|
|
enum MapgenObject {
|
|
|
|
MGOBJ_VMANIP,
|
|
|
|
MGOBJ_HEIGHTMAP,
|
|
|
|
MGOBJ_BIOMEMAP,
|
|
|
|
MGOBJ_HEATMAP,
|
|
|
|
MGOBJ_HUMIDMAP,
|
|
|
|
MGOBJ_GENNOTIFY
|
|
|
|
};
|
|
|
|
|
2014-12-06 10:18:04 +01:00
|
|
|
enum GenNotifyType {
|
2013-12-14 07:52:06 +01:00
|
|
|
GENNOTIFY_DUNGEON,
|
|
|
|
GENNOTIFY_TEMPLE,
|
|
|
|
GENNOTIFY_CAVE_BEGIN,
|
|
|
|
GENNOTIFY_CAVE_END,
|
|
|
|
GENNOTIFY_LARGECAVE_BEGIN,
|
2014-12-06 10:18:04 +01:00
|
|
|
GENNOTIFY_LARGECAVE_END,
|
|
|
|
GENNOTIFY_DECORATION,
|
|
|
|
NUM_GENNOTIFY_TYPES
|
|
|
|
};
|
|
|
|
|
|
|
|
struct GenNotifyEvent {
|
|
|
|
GenNotifyType type;
|
|
|
|
v3s16 pos;
|
|
|
|
u32 id;
|
|
|
|
};
|
|
|
|
|
|
|
|
class GenerateNotifier {
|
|
|
|
public:
|
2017-08-19 09:12:54 +02:00
|
|
|
GenerateNotifier() = default;
|
2014-12-06 10:18:04 +01:00
|
|
|
GenerateNotifier(u32 notify_on, std::set<u32> *notify_on_deco_ids);
|
|
|
|
|
|
|
|
void setNotifyOn(u32 notify_on);
|
|
|
|
void setNotifyOnDecoIds(std::set<u32> *notify_on_deco_ids);
|
|
|
|
|
|
|
|
bool addEvent(GenNotifyType type, v3s16 pos, u32 id=0);
|
2018-03-02 14:39:39 +01:00
|
|
|
void getEvents(std::map<std::string, std::vector<v3s16> > &event_map);
|
|
|
|
void clearEvents();
|
2014-12-06 10:18:04 +01:00
|
|
|
|
|
|
|
private:
|
2017-06-17 19:11:28 +02:00
|
|
|
u32 m_notify_on = 0;
|
2014-12-06 10:18:04 +01:00
|
|
|
std::set<u32> *m_notify_on_deco_ids;
|
2015-03-20 23:40:18 +01:00
|
|
|
std::list<GenNotifyEvent> m_notify_events;
|
2013-12-14 07:52:06 +01:00
|
|
|
};
|
|
|
|
|
2016-06-14 06:10:55 +02:00
|
|
|
enum MapgenType {
|
|
|
|
MAPGEN_V5,
|
|
|
|
MAPGEN_V6,
|
|
|
|
MAPGEN_V7,
|
|
|
|
MAPGEN_FLAT,
|
|
|
|
MAPGEN_FRACTAL,
|
|
|
|
MAPGEN_VALLEYS,
|
|
|
|
MAPGEN_SINGLENODE,
|
2017-07-06 13:53:56 +02:00
|
|
|
MAPGEN_CARPATHIAN,
|
2016-06-14 06:10:55 +02:00
|
|
|
MAPGEN_INVALID,
|
|
|
|
};
|
|
|
|
|
2015-03-11 01:45:42 +01:00
|
|
|
struct MapgenParams {
|
2017-08-18 18:18:25 +02:00
|
|
|
MapgenParams() = default;
|
2016-04-28 09:43:09 +02:00
|
|
|
virtual ~MapgenParams();
|
2015-01-26 12:44:49 +01:00
|
|
|
|
2017-06-17 19:11:28 +02:00
|
|
|
MapgenType mgtype = MAPGEN_DEFAULT;
|
|
|
|
s16 chunksize = 5;
|
|
|
|
u64 seed = 0;
|
|
|
|
s16 water_level = 1;
|
|
|
|
s16 mapgen_limit = MAX_MAP_GENERATION_LIMIT;
|
2018-06-09 00:24:36 +02:00
|
|
|
u32 flags = MG_CAVES | MG_LIGHT | MG_DECORATIONS | MG_BIOMES;
|
2017-06-17 19:11:28 +02:00
|
|
|
|
|
|
|
BiomeParams *bparams = nullptr;
|
|
|
|
|
|
|
|
s16 mapgen_edge_min = -MAX_MAP_GENERATION_LIMIT;
|
|
|
|
s16 mapgen_edge_max = MAX_MAP_GENERATION_LIMIT;
|
|
|
|
|
2016-06-25 00:15:56 +02:00
|
|
|
virtual void readParams(const Settings *settings);
|
|
|
|
virtual void writeParams(Settings *settings) const;
|
2017-06-03 19:57:02 +02:00
|
|
|
|
2017-06-04 23:28:32 +02:00
|
|
|
s32 getSpawnRangeMax();
|
|
|
|
|
2017-06-03 19:57:02 +02:00
|
|
|
private:
|
|
|
|
void calcMapgenEdges();
|
2017-06-17 19:11:28 +02:00
|
|
|
bool m_mapgen_edges_calculated = false;
|
2012-12-26 09:15:16 +01:00
|
|
|
};
|
|
|
|
|
2016-05-02 08:24:57 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
Generic interface for map generators. All mapgens must inherit this class.
|
|
|
|
If a feature exposed by a public member pointer is not supported by a
|
|
|
|
certain mapgen, it must be set to NULL.
|
|
|
|
|
|
|
|
Apart from makeChunk, getGroundLevelAtPoint, and getSpawnLevelAtPoint, all
|
|
|
|
methods can be used by constructing a Mapgen base class and setting the
|
|
|
|
appropriate public members (e.g. vm, ndef, and so on).
|
|
|
|
*/
|
2012-11-26 03:16:48 +01:00
|
|
|
class Mapgen {
|
2012-12-22 06:34:35 +01:00
|
|
|
public:
|
2017-06-17 19:11:28 +02:00
|
|
|
s32 seed = 0;
|
|
|
|
int water_level = 0;
|
|
|
|
int mapgen_limit = 0;
|
|
|
|
u32 flags = 0;
|
|
|
|
bool generating = false;
|
|
|
|
int id = -1;
|
2014-12-30 03:44:52 +01:00
|
|
|
|
2017-06-17 19:11:28 +02:00
|
|
|
MMVManip *vm = nullptr;
|
2018-02-10 21:04:16 +01:00
|
|
|
const NodeDefManager *ndef = nullptr;
|
2013-12-08 05:43:46 +01:00
|
|
|
|
2014-12-30 03:44:52 +01:00
|
|
|
u32 blockseed;
|
2017-06-17 19:11:28 +02:00
|
|
|
s16 *heightmap = nullptr;
|
|
|
|
biome_t *biomemap = nullptr;
|
2013-06-26 23:19:39 +02:00
|
|
|
v3s16 csize;
|
2013-03-12 02:32:52 +01:00
|
|
|
|
2017-06-17 19:11:28 +02:00
|
|
|
BiomeGen *biomegen = nullptr;
|
2014-12-06 10:18:04 +01:00
|
|
|
GenerateNotifier gennotify;
|
2013-12-14 07:52:06 +01:00
|
|
|
|
2017-08-19 09:12:54 +02:00
|
|
|
Mapgen() = default;
|
2014-12-06 10:18:04 +01:00
|
|
|
Mapgen(int mapgenid, MapgenParams *params, EmergeManager *emerge);
|
2017-08-19 09:12:54 +02:00
|
|
|
virtual ~Mapgen() = default;
|
2017-06-10 13:49:15 +02:00
|
|
|
DISABLE_CLASS_COPY(Mapgen);
|
2013-05-19 05:26:27 +02:00
|
|
|
|
2016-06-14 06:10:55 +02:00
|
|
|
virtual MapgenType getType() const { return MAPGEN_INVALID; }
|
|
|
|
|
2016-06-04 07:35:37 +02:00
|
|
|
static u32 getBlockSeed(v3s16 p, s32 seed);
|
|
|
|
static u32 getBlockSeed2(v3s16 p, s32 seed);
|
2013-06-16 04:23:06 +02:00
|
|
|
s16 findGroundLevelFull(v2s16 p2d);
|
|
|
|
s16 findGroundLevel(v2s16 p2d, s16 ymin, s16 ymax);
|
2015-10-21 09:51:59 +02:00
|
|
|
s16 findLiquidSurface(v2s16 p2d, s16 ymin, s16 ymax);
|
2013-06-16 04:23:06 +02:00
|
|
|
void updateHeightmap(v3s16 nmin, v3s16 nmax);
|
2017-10-11 02:06:40 +02:00
|
|
|
void getSurfaces(v2s16 p2d, s16 ymin, s16 ymax,
|
2017-12-10 09:07:24 +01:00
|
|
|
std::vector<s16> &floors, std::vector<s16> &ceilings);
|
2017-10-11 02:06:40 +02:00
|
|
|
|
2013-03-12 02:32:52 +01:00
|
|
|
void updateLiquid(UniqueQueue<v3s16> *trans_liquid, v3s16 nmin, v3s16 nmax);
|
2015-01-05 07:18:53 +01:00
|
|
|
|
|
|
|
void setLighting(u8 light, v3s16 nmin, v3s16 nmax);
|
2013-03-16 03:43:35 +01:00
|
|
|
void lightSpread(VoxelArea &a, v3s16 p, u8 light);
|
2015-12-02 04:28:03 +01:00
|
|
|
void calcLighting(v3s16 nmin, v3s16 nmax, v3s16 full_nmin, v3s16 full_nmax,
|
|
|
|
bool propagate_shadow = true);
|
|
|
|
void propagateSunlight(v3s16 nmin, v3s16 nmax, bool propagate_shadow);
|
2015-01-04 08:34:33 +01:00
|
|
|
void spreadLight(v3s16 nmin, v3s16 nmax);
|
|
|
|
|
2013-06-25 17:02:02 +02:00
|
|
|
virtual void makeChunk(BlockMakeData *data) {}
|
|
|
|
virtual int getGroundLevelAtPoint(v2s16 p) { return 0; }
|
2015-10-27 07:51:43 +01:00
|
|
|
|
2016-02-04 02:03:31 +01:00
|
|
|
// getSpawnLevelAtPoint() is a function within each mapgen that returns a
|
|
|
|
// suitable y co-ordinate for player spawn ('suitable' usually meaning
|
|
|
|
// within 16 nodes of water_level). If a suitable spawn level cannot be
|
|
|
|
// found at the specified (X, Z) 'MAX_MAP_GENERATION_LIMIT' is returned to
|
|
|
|
// signify this and to cause Server::findSpawnPos() to try another (X, Z).
|
|
|
|
virtual int getSpawnLevelAtPoint(v2s16 p) { return 0; }
|
|
|
|
|
2016-06-14 06:10:55 +02:00
|
|
|
// Mapgen management functions
|
|
|
|
static MapgenType getMapgenType(const std::string &mgname);
|
|
|
|
static const char *getMapgenName(MapgenType mgtype);
|
|
|
|
static Mapgen *createMapgen(MapgenType mgtype, int mgid,
|
|
|
|
MapgenParams *params, EmergeManager *emerge);
|
2016-06-25 00:15:56 +02:00
|
|
|
static MapgenParams *createMapgenParams(MapgenType mgtype);
|
2016-06-14 06:10:55 +02:00
|
|
|
static void getMapgenNames(std::vector<const char *> *mgnames, bool include_hidden);
|
|
|
|
|
2015-10-27 07:51:43 +01:00
|
|
|
private:
|
2016-06-05 01:30:36 +02:00
|
|
|
// isLiquidHorizontallyFlowable() is a helper function for updateLiquid()
|
|
|
|
// that checks whether there are floodable nodes without liquid beneath
|
|
|
|
// the node at index vi.
|
|
|
|
inline bool isLiquidHorizontallyFlowable(u32 vi, v3s16 em);
|
2012-12-22 06:34:35 +01:00
|
|
|
};
|
|
|
|
|
2016-05-02 08:24:57 +02:00
|
|
|
/*
|
|
|
|
MapgenBasic is a Mapgen implementation that handles basic functionality
|
|
|
|
the majority of conventional mapgens will probably want to use, but isn't
|
|
|
|
generic enough to be included as part of the base Mapgen class (such as
|
|
|
|
generating biome terrain over terrain node skeletons, generating caves,
|
|
|
|
dungeons, etc.)
|
|
|
|
|
|
|
|
Inherit MapgenBasic instead of Mapgen to add this basic functionality to
|
|
|
|
your mapgen without having to reimplement it. Feel free to override any of
|
|
|
|
these methods if you desire different or more advanced behavior.
|
|
|
|
|
|
|
|
Note that you must still create your own generateTerrain implementation when
|
|
|
|
inheriting MapgenBasic.
|
|
|
|
*/
|
|
|
|
class MapgenBasic : public Mapgen {
|
|
|
|
public:
|
2016-05-22 08:17:19 +02:00
|
|
|
MapgenBasic(int mapgenid, MapgenParams *params, EmergeManager *emerge);
|
|
|
|
virtual ~MapgenBasic();
|
|
|
|
|
2018-04-07 23:09:54 +02:00
|
|
|
virtual void generateBiomes();
|
2016-05-22 08:17:19 +02:00
|
|
|
virtual void dustTopNodes();
|
2018-04-29 08:20:46 +02:00
|
|
|
virtual void generateCavesNoiseIntersection(s16 max_stone_y);
|
|
|
|
virtual void generateCavesRandomWalk(s16 max_stone_y, s16 large_cave_depth);
|
|
|
|
virtual bool generateCavernsNoise(s16 max_stone_y);
|
|
|
|
virtual void generateDungeons(s16 max_stone_y);
|
2016-05-22 08:17:19 +02:00
|
|
|
|
|
|
|
protected:
|
2016-05-02 08:24:57 +02:00
|
|
|
EmergeManager *m_emerge;
|
2016-05-22 08:17:19 +02:00
|
|
|
BiomeManager *m_bmgr;
|
2016-05-02 08:24:57 +02:00
|
|
|
|
|
|
|
Noise *noise_filler_depth;
|
|
|
|
|
|
|
|
v3s16 node_min;
|
|
|
|
v3s16 node_max;
|
|
|
|
v3s16 full_node_min;
|
|
|
|
v3s16 full_node_max;
|
|
|
|
|
2016-05-22 22:27:31 +02:00
|
|
|
// Content required for generateBiomes
|
2016-05-02 08:24:57 +02:00
|
|
|
content_t c_stone;
|
|
|
|
content_t c_desert_stone;
|
|
|
|
content_t c_sandstone;
|
2017-04-04 07:51:58 +02:00
|
|
|
content_t c_water_source;
|
|
|
|
content_t c_river_water_source;
|
|
|
|
content_t c_lava_source;
|
2016-05-02 08:24:57 +02:00
|
|
|
|
2016-05-22 22:27:31 +02:00
|
|
|
// Content required for generateDungeons
|
|
|
|
content_t c_cobble;
|
|
|
|
content_t c_stair_cobble;
|
|
|
|
content_t c_mossycobble;
|
2017-01-23 09:07:34 +01:00
|
|
|
content_t c_stair_desert_stone;
|
2016-05-22 22:27:31 +02:00
|
|
|
content_t c_sandstonebrick;
|
2017-03-04 06:10:10 +01:00
|
|
|
content_t c_stair_sandstone_block;
|
2016-05-22 22:27:31 +02:00
|
|
|
|
2016-05-02 08:24:57 +02:00
|
|
|
int ystride;
|
2016-05-22 08:17:19 +02:00
|
|
|
int zstride;
|
|
|
|
int zstride_1d;
|
|
|
|
int zstride_1u1d;
|
|
|
|
|
|
|
|
u32 spflags;
|
|
|
|
|
2016-05-19 09:40:22 +02:00
|
|
|
NoiseParams np_cave1;
|
|
|
|
NoiseParams np_cave2;
|
2017-03-12 14:26:09 +01:00
|
|
|
NoiseParams np_cavern;
|
2016-05-02 08:24:57 +02:00
|
|
|
float cave_width;
|
2017-03-12 14:26:09 +01:00
|
|
|
float cavern_limit;
|
|
|
|
float cavern_taper;
|
|
|
|
float cavern_threshold;
|
2017-06-21 05:20:18 +02:00
|
|
|
int lava_depth;
|
2016-05-02 08:24:57 +02:00
|
|
|
};
|