2011-06-25 08:12:41 -07:00
|
|
|
/*
|
2013-02-24 09:40:43 -08:00
|
|
|
Minetest
|
2020-05-20 14:16:14 -07:00
|
|
|
Copyright (C) 2010-2020 celeron55, Perttu Ahola <celeron55@gmail.com>
|
|
|
|
Copyright (C) 2015-2020 paramat
|
|
|
|
Copyright (C) 2013-2016 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
|
2011-06-25 08:12:41 -07:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
2012-06-05 07:56:56 -07:00
|
|
|
it under the terms of the GNU Lesser General Public License as published by
|
2020-08-28 09:27:49 -07:00
|
|
|
the Free Software Foundation; either version 3.0 of the License, or
|
2011-06-25 08:12:41 -07: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 07:56:56 -07:00
|
|
|
GNU Lesser General Public License for more details.
|
2011-06-25 08:12:41 -07:00
|
|
|
|
2012-06-05 07:56:56 -07:00
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
2011-06-25 08:12:41 -07: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 13:19:39 -07:00
|
|
|
#pragma once
|
2011-06-25 08:12:41 -07:00
|
|
|
|
2014-12-08 21:37:48 -08:00
|
|
|
#include "noise.h"
|
2013-07-08 12:19:22 -07:00
|
|
|
#include "nodedef.h"
|
2014-11-12 20:01:13 -08:00
|
|
|
#include "util/string.h"
|
|
|
|
#include "util/container.h"
|
2013-01-06 11:40:24 -08:00
|
|
|
|
2020-03-05 02:06:11 -08:00
|
|
|
#define MAPGEN_DEFAULT MAPGEN_V7P
|
|
|
|
#define MAPGEN_DEFAULT_NAME "v7p"
|
2014-02-03 19:42:10 -08:00
|
|
|
|
2013-01-06 11:40:24 -08:00
|
|
|
/////////////////// Mapgen flags
|
2019-10-29 11:23:12 -07:00
|
|
|
#define MG_TREES 0x01 // Obsolete. Moved into mgv6 flags
|
2015-11-15 03:55:45 -08:00
|
|
|
#define MG_CAVES 0x02
|
|
|
|
#define MG_DUNGEONS 0x04
|
2019-10-29 11:23:12 -07:00
|
|
|
#define MG_FLAT 0x08 // Obsolete. Moved into mgv6 flags
|
2015-11-15 03:55:45 -08:00
|
|
|
#define MG_LIGHT 0x10
|
|
|
|
#define MG_DECORATIONS 0x20
|
2018-06-08 15:24:36 -07:00
|
|
|
#define MG_BIOMES 0x40
|
2013-01-06 11:40:24 -08:00
|
|
|
|
2020-05-20 14:16:14 -07:00
|
|
|
typedef u16 biome_t; // copy from mg_biome.h to avoid an unnecessary include
|
2016-06-04 00:00:45 -07:00
|
|
|
|
2014-11-12 20:01:13 -08:00
|
|
|
class Settings;
|
2015-01-04 23:42:27 -08:00
|
|
|
class MMVManip;
|
2018-02-10 12:04:16 -08:00
|
|
|
class NodeDefManager;
|
2013-12-13 22:52:06 -08:00
|
|
|
|
2013-02-13 19:43:15 -08:00
|
|
|
extern FlagDesc flagdesc_mapgen[];
|
2013-12-13 22:52:06 -08:00
|
|
|
extern FlagDesc flagdesc_gennotify[];
|
2013-02-13 19:43:15 -08:00
|
|
|
|
2012-11-25 18:16:48 -08:00
|
|
|
class Biome;
|
2016-04-28 00:43:09 -07:00
|
|
|
class BiomeGen;
|
|
|
|
struct BiomeParams;
|
2016-05-01 23:24:57 -07:00
|
|
|
class BiomeManager;
|
2020-04-09 17:05:20 -07:00
|
|
|
class EmergeParams;
|
2013-01-22 19:32:30 -08:00
|
|
|
class EmergeManager;
|
2011-06-25 08:12:41 -07:00
|
|
|
class MapBlock;
|
2012-12-21 21:34:35 -08:00
|
|
|
class VoxelManipulator;
|
2013-03-22 23:24:31 -07:00
|
|
|
struct BlockMakeData;
|
2013-03-15 19:43:35 -07:00
|
|
|
class VoxelArea;
|
2013-06-21 21:29:44 -07:00
|
|
|
class Map;
|
2012-11-25 18:16:48 -08:00
|
|
|
|
2013-12-13 22:52:06 -08:00
|
|
|
enum MapgenObject {
|
|
|
|
MGOBJ_VMANIP,
|
|
|
|
MGOBJ_HEIGHTMAP,
|
|
|
|
MGOBJ_BIOMEMAP,
|
|
|
|
MGOBJ_HEATMAP,
|
|
|
|
MGOBJ_HUMIDMAP,
|
|
|
|
MGOBJ_GENNOTIFY
|
|
|
|
};
|
|
|
|
|
2014-12-06 01:18:04 -08:00
|
|
|
enum GenNotifyType {
|
2013-12-13 22:52:06 -08:00
|
|
|
GENNOTIFY_DUNGEON,
|
|
|
|
GENNOTIFY_TEMPLE,
|
|
|
|
GENNOTIFY_CAVE_BEGIN,
|
|
|
|
GENNOTIFY_CAVE_END,
|
|
|
|
GENNOTIFY_LARGECAVE_BEGIN,
|
2014-12-06 01:18:04 -08:00
|
|
|
GENNOTIFY_LARGECAVE_END,
|
|
|
|
GENNOTIFY_DECORATION,
|
|
|
|
NUM_GENNOTIFY_TYPES
|
|
|
|
};
|
|
|
|
|
|
|
|
struct GenNotifyEvent {
|
|
|
|
GenNotifyType type;
|
|
|
|
v3s16 pos;
|
|
|
|
u32 id;
|
|
|
|
};
|
|
|
|
|
|
|
|
class GenerateNotifier {
|
|
|
|
public:
|
2017-08-19 00:12:54 -07:00
|
|
|
GenerateNotifier() = default;
|
2020-04-09 17:05:20 -07:00
|
|
|
GenerateNotifier(u32 notify_on, const std::set<u32> *notify_on_deco_ids);
|
2014-12-06 01:18:04 -08:00
|
|
|
|
|
|
|
void setNotifyOn(u32 notify_on);
|
2020-04-09 17:05:20 -07:00
|
|
|
void setNotifyOnDecoIds(const std::set<u32> *notify_on_deco_ids);
|
2014-12-06 01:18:04 -08:00
|
|
|
|
|
|
|
bool addEvent(GenNotifyType type, v3s16 pos, u32 id=0);
|
2018-03-02 05:39:39 -08:00
|
|
|
void getEvents(std::map<std::string, std::vector<v3s16> > &event_map);
|
|
|
|
void clearEvents();
|
2014-12-06 01:18:04 -08:00
|
|
|
|
|
|
|
private:
|
2017-06-17 10:11:28 -07:00
|
|
|
u32 m_notify_on = 0;
|
2020-04-09 17:05:20 -07:00
|
|
|
const std::set<u32> *m_notify_on_deco_ids;
|
2015-03-20 15:40:18 -07:00
|
|
|
std::list<GenNotifyEvent> m_notify_events;
|
2013-12-13 22:52:06 -08:00
|
|
|
};
|
|
|
|
|
2019-07-25 12:46:28 -07:00
|
|
|
// Order must match the order of 'static MapgenDesc g_reg_mapgens[]' in mapgen.cpp
|
2016-06-13 21:10:55 -07:00
|
|
|
enum MapgenType {
|
2020-03-05 02:06:11 -08:00
|
|
|
MAPGEN_V7P,
|
2016-06-13 21:10:55 -07:00
|
|
|
MAPGEN_V7,
|
2019-07-25 12:46:28 -07:00
|
|
|
MAPGEN_VALLEYS,
|
|
|
|
MAPGEN_CARPATHIAN,
|
|
|
|
MAPGEN_V5,
|
2016-06-13 21:10:55 -07:00
|
|
|
MAPGEN_FLAT,
|
|
|
|
MAPGEN_FRACTAL,
|
|
|
|
MAPGEN_SINGLENODE,
|
2019-07-25 12:46:28 -07:00
|
|
|
MAPGEN_V6,
|
2016-06-13 21:10:55 -07:00
|
|
|
MAPGEN_INVALID,
|
|
|
|
};
|
|
|
|
|
2015-03-10 17:45:42 -07:00
|
|
|
struct MapgenParams {
|
2017-08-18 09:18:25 -07:00
|
|
|
MapgenParams() = default;
|
2016-04-28 00:43:09 -07:00
|
|
|
virtual ~MapgenParams();
|
2015-01-26 03:44:49 -08:00
|
|
|
|
2017-06-17 10:11:28 -07:00
|
|
|
MapgenType mgtype = MAPGEN_DEFAULT;
|
|
|
|
s16 chunksize = 5;
|
|
|
|
u64 seed = 0;
|
|
|
|
s16 water_level = 1;
|
|
|
|
s16 mapgen_limit = MAX_MAP_GENERATION_LIMIT;
|
2020-01-25 07:56:54 -08:00
|
|
|
// Flags set in readParams
|
|
|
|
u32 flags = 0;
|
|
|
|
u32 spflags = 0;
|
2017-06-17 10:11:28 -07:00
|
|
|
|
|
|
|
BiomeParams *bparams = nullptr;
|
|
|
|
|
|
|
|
s16 mapgen_edge_min = -MAX_MAP_GENERATION_LIMIT;
|
|
|
|
s16 mapgen_edge_max = MAX_MAP_GENERATION_LIMIT;
|
|
|
|
|
2016-06-24 15:15:56 -07:00
|
|
|
virtual void readParams(const Settings *settings);
|
|
|
|
virtual void writeParams(Settings *settings) const;
|
2020-01-25 07:56:54 -08:00
|
|
|
// Default settings for g_settings such as flags
|
|
|
|
virtual void setDefaultSettings(Settings *settings) {};
|
2017-06-03 10:57:02 -07:00
|
|
|
|
2017-06-04 14:28:32 -07:00
|
|
|
s32 getSpawnRangeMax();
|
|
|
|
|
2017-06-03 10:57:02 -07:00
|
|
|
private:
|
|
|
|
void calcMapgenEdges();
|
2017-06-17 10:11:28 -07:00
|
|
|
bool m_mapgen_edges_calculated = false;
|
2012-12-26 00:15:16 -08:00
|
|
|
};
|
|
|
|
|
2016-05-01 23:24:57 -07: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-25 18:16:48 -08:00
|
|
|
class Mapgen {
|
2012-12-21 21:34:35 -08:00
|
|
|
public:
|
2017-06-17 10:11:28 -07:00
|
|
|
s32 seed = 0;
|
|
|
|
int water_level = 0;
|
|
|
|
int mapgen_limit = 0;
|
|
|
|
u32 flags = 0;
|
|
|
|
bool generating = false;
|
|
|
|
int id = -1;
|
2014-12-29 18:44:52 -08:00
|
|
|
|
2017-06-17 10:11:28 -07:00
|
|
|
MMVManip *vm = nullptr;
|
2018-02-10 12:04:16 -08:00
|
|
|
const NodeDefManager *ndef = nullptr;
|
2013-12-07 20:43:46 -08:00
|
|
|
|
2014-12-29 18:44:52 -08:00
|
|
|
u32 blockseed;
|
2017-06-17 10:11:28 -07:00
|
|
|
s16 *heightmap = nullptr;
|
|
|
|
biome_t *biomemap = nullptr;
|
2013-06-26 14:19:39 -07:00
|
|
|
v3s16 csize;
|
2013-03-11 18:32:52 -07:00
|
|
|
|
2017-06-17 10:11:28 -07:00
|
|
|
BiomeGen *biomegen = nullptr;
|
2014-12-06 01:18:04 -08:00
|
|
|
GenerateNotifier gennotify;
|
2013-12-13 22:52:06 -08:00
|
|
|
|
2017-08-19 00:12:54 -07:00
|
|
|
Mapgen() = default;
|
2020-04-09 17:05:20 -07:00
|
|
|
Mapgen(int mapgenid, MapgenParams *params, EmergeParams *emerge);
|
2017-08-19 00:12:54 -07:00
|
|
|
virtual ~Mapgen() = default;
|
2017-06-10 04:49:15 -07:00
|
|
|
DISABLE_CLASS_COPY(Mapgen);
|
2013-05-18 20:26:27 -07:00
|
|
|
|
2016-06-13 21:10:55 -07:00
|
|
|
virtual MapgenType getType() const { return MAPGEN_INVALID; }
|
|
|
|
|
2016-06-03 22:35:37 -07:00
|
|
|
static u32 getBlockSeed(v3s16 p, s32 seed);
|
|
|
|
static u32 getBlockSeed2(v3s16 p, s32 seed);
|
2013-06-15 19:23:06 -07:00
|
|
|
s16 findGroundLevelFull(v2s16 p2d);
|
|
|
|
s16 findGroundLevel(v2s16 p2d, s16 ymin, s16 ymax);
|
2015-10-21 00:51:59 -07:00
|
|
|
s16 findLiquidSurface(v2s16 p2d, s16 ymin, s16 ymax);
|
2013-06-15 19:23:06 -07:00
|
|
|
void updateHeightmap(v3s16 nmin, v3s16 nmax);
|
2017-10-10 17:06:40 -07:00
|
|
|
void getSurfaces(v2s16 p2d, s16 ymin, s16 ymax,
|
2017-12-10 00:07:24 -08:00
|
|
|
std::vector<s16> &floors, std::vector<s16> &ceilings);
|
2017-10-10 17:06:40 -07:00
|
|
|
|
2013-03-11 18:32:52 -07:00
|
|
|
void updateLiquid(UniqueQueue<v3s16> *trans_liquid, v3s16 nmin, v3s16 nmax);
|
2015-01-04 22:18:53 -08:00
|
|
|
|
|
|
|
void setLighting(u8 light, v3s16 nmin, v3s16 nmax);
|
2019-08-23 13:16:50 -07:00
|
|
|
void lightSpread(VoxelArea &a, std::queue<std::pair<v3s16, u8>> &queue,
|
|
|
|
const v3s16 &p, u8 light);
|
2015-12-01 19:28:03 -08: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);
|
2019-08-23 13:16:50 -07:00
|
|
|
void spreadLight(const v3s16 &nmin, const v3s16 &nmax);
|
2015-01-03 23:34:33 -08:00
|
|
|
|
2013-06-25 08:02:02 -07:00
|
|
|
virtual void makeChunk(BlockMakeData *data) {}
|
|
|
|
virtual int getGroundLevelAtPoint(v2s16 p) { return 0; }
|
2015-10-26 23:51:43 -07:00
|
|
|
|
2016-02-03 17:03:31 -08: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-13 21:10:55 -07:00
|
|
|
// Mapgen management functions
|
|
|
|
static MapgenType getMapgenType(const std::string &mgname);
|
|
|
|
static const char *getMapgenName(MapgenType mgtype);
|
2019-03-31 10:30:20 -07:00
|
|
|
static Mapgen *createMapgen(MapgenType mgtype, MapgenParams *params,
|
2020-04-09 17:05:20 -07:00
|
|
|
EmergeParams *emerge);
|
2016-06-24 15:15:56 -07:00
|
|
|
static MapgenParams *createMapgenParams(MapgenType mgtype);
|
2016-06-13 21:10:55 -07:00
|
|
|
static void getMapgenNames(std::vector<const char *> *mgnames, bool include_hidden);
|
2020-01-25 07:56:54 -08:00
|
|
|
static void setDefaultSettings(Settings *settings);
|
2016-06-13 21:10:55 -07:00
|
|
|
|
2015-10-26 23:51:43 -07:00
|
|
|
private:
|
2016-06-04 16:30:36 -07: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-21 21:34:35 -08:00
|
|
|
};
|
|
|
|
|
2016-05-01 23:24:57 -07: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:
|
2020-04-09 17:05:20 -07:00
|
|
|
MapgenBasic(int mapgenid, MapgenParams *params, EmergeParams *emerge);
|
2016-05-21 23:17:19 -07:00
|
|
|
virtual ~MapgenBasic();
|
|
|
|
|
2018-04-07 14:09:54 -07:00
|
|
|
virtual void generateBiomes();
|
2016-05-21 23:17:19 -07:00
|
|
|
virtual void dustTopNodes();
|
2018-04-28 23:20:46 -07:00
|
|
|
virtual void generateCavesNoiseIntersection(s16 max_stone_y);
|
2019-11-22 12:37:43 -08:00
|
|
|
virtual void generateCavesRandomWalk(s16 max_stone_y, s16 large_cave_ymax);
|
2018-04-28 23:20:46 -07:00
|
|
|
virtual bool generateCavernsNoise(s16 max_stone_y);
|
|
|
|
virtual void generateDungeons(s16 max_stone_y);
|
2016-05-21 23:17:19 -07:00
|
|
|
|
|
|
|
protected:
|
2020-04-09 17:05:20 -07:00
|
|
|
EmergeParams *m_emerge;
|
2016-05-21 23:17:19 -07:00
|
|
|
BiomeManager *m_bmgr;
|
2016-05-01 23:24:57 -07:00
|
|
|
|
|
|
|
Noise *noise_filler_depth;
|
|
|
|
|
|
|
|
v3s16 node_min;
|
|
|
|
v3s16 node_max;
|
|
|
|
v3s16 full_node_min;
|
|
|
|
v3s16 full_node_max;
|
|
|
|
|
|
|
|
content_t c_stone;
|
2017-04-03 22:51:58 -07:00
|
|
|
content_t c_water_source;
|
|
|
|
content_t c_river_water_source;
|
|
|
|
content_t c_lava_source;
|
2016-05-22 13:27:31 -07:00
|
|
|
content_t c_cobble;
|
|
|
|
|
2016-05-01 23:24:57 -07:00
|
|
|
int ystride;
|
2016-05-21 23:17:19 -07:00
|
|
|
int zstride;
|
|
|
|
int zstride_1d;
|
|
|
|
int zstride_1u1d;
|
|
|
|
|
|
|
|
u32 spflags;
|
|
|
|
|
2016-05-19 00:40:22 -07:00
|
|
|
NoiseParams np_cave1;
|
|
|
|
NoiseParams np_cave2;
|
2017-03-12 06:26:09 -07:00
|
|
|
NoiseParams np_cavern;
|
2019-06-01 12:50:43 -07:00
|
|
|
NoiseParams np_dungeons;
|
2016-05-01 23:24:57 -07:00
|
|
|
float cave_width;
|
2017-03-12 06:26:09 -07:00
|
|
|
float cavern_limit;
|
|
|
|
float cavern_taper;
|
|
|
|
float cavern_threshold;
|
2019-11-07 19:09:43 -08:00
|
|
|
int small_cave_num_min;
|
|
|
|
int small_cave_num_max;
|
|
|
|
int large_cave_num_min;
|
|
|
|
int large_cave_num_max;
|
|
|
|
float large_cave_flooded;
|
2019-11-19 11:59:17 -08:00
|
|
|
s16 large_cave_depth;
|
|
|
|
s16 dungeon_ymin;
|
|
|
|
s16 dungeon_ymax;
|
2016-05-01 23:24:57 -07:00
|
|
|
};
|