#include "log.h"
#include "nodedef.h"
#include "mg_biome.h"
-#include "mg_decoration.h"
#include "mg_ore.h"
+#include "mg_decoration.h"
+#include "mg_schematic.h"
#include "mapgen_v5.h"
#include "mapgen_v6.h"
#include "mapgen_v7.h"
registerMapgen("v7", new MapgenFactoryV7());
registerMapgen("singlenode", new MapgenFactorySinglenode());
- this->ndef = gamedef->getNodeDefManager();
- this->biomedef = new BiomeDefManager(gamedef->getNodeDefManager()->getResolver());
+ this->ndef = gamedef->getNodeDefManager();
+ this->biomemgr = new BiomeManager(gamedef);
+ this->oremgr = new OreManager(gamedef);
+ this->decomgr = new DecorationManager(gamedef);
+ this->schemmgr = new SchematicManager(gamedef);
this->gennotify = 0;
// Note that accesses to this variable are not synchronized.
emergethread.clear();
mapgen.clear();
- for (unsigned int i = 0; i < ores.size(); i++)
- delete ores[i];
- ores.clear();
-
- for (unsigned int i = 0; i < decorations.size(); i++)
- delete decorations[i];
- decorations.clear();
-
- for (std::map<std::string, MapgenFactory *>::iterator it = mglist.begin();
- it != mglist.end(); ++it) {
+ std::map<std::string, MapgenFactory *>::iterator it;
+ for (it = mglist.begin(); it != mglist.end(); ++it)
delete it->second;
- }
mglist.clear();
- delete biomedef;
+ delete biomemgr;
+ delete oremgr;
+ delete decomgr;
+ delete schemmgr;
if (params.sparams) {
delete params.sparams;
#include <map>
#include "irr_v3d.h"
#include "util/container.h"
-#include "map.h" // for ManualMapVoxelManipulator
#include "mapgen.h" // for MapgenParams
+#include "map.h"
#define MGPARAMS_SET_MGNAME 1
#define MGPARAMS_SET_SEED 2
#define BLOCK_EMERGE_ALLOWGEN (1<<0)
#define EMERGE_DBG_OUT(x) \
- { if (enable_mapgen_debug_info) \
- infostream << "EmergeThread: " x << std::endl; }
+ do { \
+ if (enable_mapgen_debug_info) \
+ infostream << "EmergeThread: " x << std::endl; \
+ } while (0)
class EmergeThread;
-class Biome;
-class BiomeDefManager;
-class Decoration;
-class Ore;
class INodeDefManager;
class Settings;
+//class ManualMapVoxelManipulator;
+
+class BiomeManager;
+class OreManager;
+class DecorationManager;
+class SchematicManager;
struct BlockMakeData {
ManualMapVoxelManipulator *vmanip;
u32 gennotify;
- //block emerge queue data structures
+ //// Block emerge queue data structures
JMutex queuemutex;
std::map<v3s16, BlockEmergeData *> blocks_enqueued;
std::map<u16, u16> peer_queue_count;
- //Mapgen-related structures
- BiomeDefManager *biomedef;
- std::vector<Ore *> ores;
- std::vector<Decoration *> decorations;
+ //// Managers of map generation-related components
+ BiomeManager *biomemgr;
+ OreManager *oremgr;
+ DecorationManager *decomgr;
+ SchematicManager *schemmgr;
+ //// Methods
EmergeManager(IGameDef *gamedef);
~EmergeManager();
void initMapgens();
Mapgen *getCurrentMapgen();
Mapgen *createMapgen(std::string mgname, int mgid,
- MapgenParams *mgparams);
+ MapgenParams *mgparams);
MapgenSpecificParams *createMapgenParams(std::string mgname);
void startThreads();
void stopThreads();
#include "filesys.h"
#include "log.h"
+const char *GenElementManager::ELEMENT_TITLE = "element";
FlagDesc flagdesc_mapgen[] = {
{"trees", MG_TREES},
{NULL, 0}
};
-///////////////////////////////////////////////////////////////////////////////
-
-
-
-
///////////////////////////////////////////////////////////////////////////////
-
Mapgen::Mapgen() {
seed = 0;
water_level = 0;
std::map<v3s16, u8> unlight_from;
voxalgo::clearLightAndCollectSources(*vm, a, bank, ndef,
- light_sources, unlight_from);
+ light_sources, unlight_from);
voxalgo::propagateSunlight(*vm, a, sunlight, light_sources, ndef);
vm->unspreadLight(bank, unlight_from, light_sources, ndef);
vm->spreadLight(bank, light_sources, ndef);
}
}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+GenElementManager::~GenElementManager()
+{
+ for (size_t i = 0; i != m_elements.size(); i++)
+ delete m_elements[i];
+}
+
+
+u32 GenElementManager::add(GenElement *elem)
+{
+ size_t nelem = m_elements.size();
+
+ for (size_t i = 0; i != nelem; i++) {
+ if (m_elements[i] == NULL) {
+ elem->id = i;
+ m_elements[i] = elem;
+ return i;
+ }
+ }
+
+ if (nelem >= this->ELEMENT_LIMIT)
+ return -1;
+
+ elem->id = nelem;
+ m_elements.push_back(elem);
+
+ verbosestream << "GenElementManager: added " << this->ELEMENT_TITLE
+ << " element '" << elem->name << "'" << std::endl;
+
+ return nelem;
+}
+
+
+GenElement *GenElementManager::get(u32 id)
+{
+ return (id < m_elements.size()) ? m_elements[id] : NULL;
+}
+
+
+GenElement *GenElementManager::getByName(const char *name)
+{
+ for (size_t i = 0; i != m_elements.size(); i++) {
+ GenElement *elem = m_elements[i];
+ if (elem && !strcmp(elem->name.c_str(), name))
+ return elem;
+ }
+
+ return NULL;
+}
+
+GenElement *GenElementManager::getByName(std::string &name)
+{
+ return getByName(name.c_str());
+}
+
+
+GenElement *GenElementManager::update(u32 id, GenElement *elem)
+{
+ if (id >= m_elements.size())
+ return false;
+
+ GenElement *old_elem = m_elements[id];
+ m_elements[id] = elem;
+ return old_elem;
+}
+
+
+GenElement *GenElementManager::remove(u32 id)
+{
+ return update(id, NULL);
+}
#ifndef MAPGEN_HEADER
#define MAPGEN_HEADER
-#include "irrlichttypes_bloated.h"
-#include "util/container.h" // UniqueQueue
-#include "gamedef.h"
#include "nodedef.h"
#include "mapnode.h"
-#include "noise.h"
-#include "settings.h"
+#include "util/string.h"
+#include "util/container.h"
#define DEFAULT_MAPGEN "v6"
#define NUM_GEN_NOTIFY 6
+class Settings;
+class ManualMapVoxelManipulator;
+class INodeDefManager;
extern FlagDesc flagdesc_mapgen[];
extern FlagDesc flagdesc_gennotify[];
-class BiomeDefManager;
class Biome;
class EmergeManager;
class MapBlock;
class VoxelArea;
class Map;
-
enum MapgenObject {
MGOBJ_VMANIP,
MGOBJ_HEIGHTMAP,
struct MapgenFactory {
virtual Mapgen *createMapgen(int mgid, MapgenParams *params,
- EmergeManager *emerge) = 0;
+ EmergeManager *emerge) = 0;
virtual MapgenSpecificParams *createMapgenParams() = 0;
virtual ~MapgenFactory() {}
};
-#endif
+class GenElement {
+public:
+ uint32_t id;
+ std::string name;
+};
+
+class GenElementManager {
+public:
+ static const char *ELEMENT_TITLE;
+ static const size_t ELEMENT_LIMIT = -1;
+ GenElementManager() {}
+ virtual ~GenElementManager();
+
+ virtual GenElement *create(int type) = 0;
+
+ virtual u32 add(GenElement *elem);
+ virtual GenElement *get(u32 id);
+ virtual GenElement *update(u32 id, GenElement *elem);
+ virtual GenElement *remove(u32 id);
+
+ virtual GenElement *getByName(const char *name);
+ virtual GenElement *getByName(std::string &name);
+
+protected:
+ std::vector<GenElement *> m_elements;
+};
+
+#endif
this->generating = false;
this->id = mapgenid;
this->emerge = emerge_;
- this->bmgr = emerge->biomedef;
+ this->bmgr = emerge->biomemgr;
this->seed = (int)params->seed;
this->water_level = params->water_level;
}
// Generate the registered decorations
- for (size_t i = 0; i != emerge->decorations.size(); i++) {
- Decoration *deco = emerge->decorations[i];
- deco->placeDeco(this, blockseed + i, node_min, node_max);
- }
+ emerge->decomgr->placeAllDecos(this, blockseed, node_min, node_max);
// Generate the registered ores
- for (unsigned int i = 0; i != emerge->ores.size(); i++) {
- Ore *ore = emerge->ores[i];
- ore->placeOre(this, blockseed + i, node_min, node_max);
- }
+ emerge->oremgr->placeAllOres(this, blockseed, node_min, node_max);
// Sprinkle some dust on top after everything else was generated
dustTopNodes();
for (s16 z = node_min.Z; z <= node_max.Z; z++)
for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
- Biome *biome = bmgr->biomes[biomemap[index]];
+ Biome *biome = (Biome *)bmgr->get(biomemap[index]);
s16 dfiller = biome->depth_filler + noise_filler_depth->result[index];
s16 y0_top = biome->depth_top;
s16 y0_filler = biome->depth_filler + biome->depth_top + dfiller;
for (s16 z = node_min.Z; z <= node_max.Z; z++)
for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
- Biome *biome = bmgr->biomes[biomemap[index]];
+ Biome *biome = (Biome *)bmgr->get(biomemap[index]);
if (biome->c_dust == CONTENT_IGNORE)
continue;
class MapgenV5 : public Mapgen {
public:
EmergeManager *emerge;
- BiomeDefManager *bmgr;
+ BiomeManager *bmgr;
int ystride;
int zstride;
placeTreesAndJungleGrass();
// Generate the registered decorations
- for (unsigned int i = 0; i != emerge->decorations.size(); i++) {
- Decoration *deco = emerge->decorations[i];
- deco->placeDeco(this, blockseed + i, node_min, node_max);
- }
+ emerge->decomgr->placeAllDecos(this, blockseed, node_min, node_max);
// Generate the registered ores
- for (unsigned int i = 0; i != emerge->ores.size(); i++) {
- Ore *ore = emerge->ores[i];
- ore->placeOre(this, blockseed + i, node_min, node_max);
- }
+ emerge->oremgr->placeAllOres(this, blockseed, node_min, node_max);
// Calculate lighting
if (flags & MG_LIGHT)
#define MAPGENV6_HEADER
#include "mapgen.h"
+#include "noise.h"
#define AVERAGE_MUD_AMOUNT 4
this->generating = false;
this->id = mapgenid;
this->emerge = emerge;
- this->bmgr = emerge->biomedef;
+ this->bmgr = emerge->biomemgr;
this->seed = (int)params->seed;
this->water_level = params->water_level;
dgen.generate(blockseed, full_node_min, full_node_max);
}
- for (size_t i = 0; i != emerge->decorations.size(); i++) {
- Decoration *deco = emerge->decorations[i];
- deco->placeDeco(this, blockseed + i, node_min, node_max);
- }
+ // Generate the registered decorations
+ emerge->decomgr->placeAllDecos(this, blockseed, node_min, node_max);
+
+ // Generate the registered ores
+ emerge->oremgr->placeAllOres(this, blockseed, node_min, node_max);
- for (size_t i = 0; i != emerge->ores.size(); i++) {
- Ore *ore = emerge->ores[i];
- ore->placeOre(this, blockseed + i, node_min, node_max);
- }
-
// Sprinkle some dust on top after everything else was generated
dustTopNodes();
for (s16 z = node_min.Z; z <= node_max.Z; z++)
for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
- Biome *biome = bmgr->biomes[biomemap[index]];
+ Biome *biome = (Biome *)bmgr->get(biomemap[index]);
s16 dfiller = biome->depth_filler + noise_filler_depth->result[index];
s16 y0_top = biome->depth_top;
s16 y0_filler = biome->depth_filler + biome->depth_top + dfiller;
-
+
s16 nplaced = 0;
u32 i = vm->m_area.index(x, node_max.Y, z);
for (s16 z = node_min.Z; z <= node_max.Z; z++)
for (s16 x = node_min.X; x <= node_max.X; x++, index++) {
- Biome *biome = bmgr->biomes[biomemap[index]];
+ Biome *biome = (Biome *)bmgr->get(biomemap[index]);
if (biome->c_dust == CONTENT_IGNORE)
continue;
#define MGV7_MOUNTAINS 0x01
#define MGV7_RIDGES 0x02
+class BiomeManager;
extern FlagDesc flagdesc_mapgen_v7[];
class MapgenV7 : public Mapgen {
public:
EmergeManager *emerge;
- BiomeDefManager *bmgr;
+ BiomeManager *bmgr;
int ystride;
int zstride;
*/
#include "mg_biome.h"
+#include "gamedef.h"
#include "nodedef.h"
#include "map.h" //for ManualMapVoxelManipulator
#include "log.h"
#include "util/mathconstants.h"
#include "porting.h"
+const char *BiomeManager::ELEMENT_TITLE = "biome";
+
NoiseParams nparams_biome_def_heat(50, 50, v3f(500.0, 500.0, 500.0), 5349, 3, 0.70);
NoiseParams nparams_biome_def_humidity(50, 50, v3f(500.0, 500.0, 500.0), 842, 3, 0.55);
-BiomeDefManager::BiomeDefManager(NodeResolver *resolver)
+///////////////////////////////////////////////////////////////////////////////
+
+
+BiomeManager::BiomeManager(IGameDef *gamedef)
{
- biome_registration_finished = false;
+ NodeResolver *resolver = gamedef->getNodeDefManager()->getResolver();
+
np_heat = &nparams_biome_def_heat;
np_humidity = &nparams_biome_def_humidity;
// Create default biome to be used in case none exist
Biome *b = new Biome;
-
+
b->id = 0;
b->name = "Default";
b->flags = 0;
resolver->addNode("air", "", CONTENT_AIR, &b->c_dust);
resolver->addNode("mapgen_water_source", "", CONTENT_AIR, &b->c_dust_water);
- biomes.push_back(b);
+ add(b);
}
-BiomeDefManager::~BiomeDefManager()
+
+BiomeManager::~BiomeManager()
{
//if (biomecache)
// delete[] biomecache;
-
- for (size_t i = 0; i != biomes.size(); i++)
- delete biomes[i];
}
-Biome *BiomeDefManager::createBiome(BiomeTerrainType btt)
-{
- /*switch (btt) {
- case BIOME_TERRAIN_NORMAL:
- return new Biome;
- case BIOME_TERRAIN_LIQUID:
- return new BiomeLiquid;
- case BIOME_TERRAIN_NETHER:
- return new BiomeHell;
- case BIOME_TERRAIN_AETHER:
- return new BiomeSky;
- case BIOME_TERRAIN_FLAT:
- return new BiomeSuperflat;
- }
- return NULL;*/
- return new Biome;
-}
-
// just a PoC, obviously needs optimization later on (precalculate this)
-void BiomeDefManager::calcBiomes(BiomeNoiseInput *input, u8 *biomeid_map)
+void BiomeManager::calcBiomes(BiomeNoiseInput *input, u8 *biomeid_map)
{
int i = 0;
for (int y = 0; y != input->mapsize.Y; y++) {
}
-bool BiomeDefManager::addBiome(Biome *b)
-{
- if (biome_registration_finished) {
- errorstream << "BiomeDefManager: biome registration already "
- "finished, dropping " << b->name << std::endl;
- return false;
- }
-
- size_t nbiomes = biomes.size();
- if (nbiomes >= 0xFF) {
- errorstream << "BiomeDefManager: too many biomes, dropping "
- << b->name << std::endl;
- return false;
- }
-
- b->id = (u8)nbiomes;
- biomes.push_back(b);
- verbosestream << "BiomeDefManager: added biome " << b->name << std::endl;
-
- return true;
-}
-
-
-Biome *BiomeDefManager::getBiome(float heat, float humidity, s16 y)
+Biome *BiomeManager::getBiome(float heat, float humidity, s16 y)
{
Biome *b, *biome_closest = NULL;
float dist_min = FLT_MAX;
- for (size_t i = 1; i < biomes.size(); i++) {
- b = biomes[i];
- if (y > b->height_max || y < b->height_min)
+ for (size_t i = 1; i < m_elements.size(); i++) {
+ b = (Biome *)m_elements[i];
+ if (!b || y > b->height_max || y < b->height_min) {
+ printf("not good - %p %d %d %d\n", b, y, b->height_max, b->height_min);
continue;
+ }
float d_heat = heat - b->heat_point;
float d_humidity = humidity - b->humidity_point;
}
}
- return biome_closest ? biome_closest : biomes[0];
-}
-
-
-u8 BiomeDefManager::getBiomeIdByName(const char *name)
-{
- for (size_t i = 0; i != biomes.size(); i++) {
- if (!strcasecmp(name, biomes[i]->name.c_str()))
- return i;
- }
-
- return 0;
+ return biome_closest ? biome_closest : (Biome *)m_elements[0];
}
#ifndef MG_BIOME_HEADER
#define MG_BIOME_HEADER
-#include <string>
-#include "nodedef.h"
-#include "gamedef.h"
-#include "mapnode.h"
-#include "noise.h"
#include "mapgen.h"
+#include "noise.h"
+
+//#include <string>
+//#include "nodedef.h"
+//#include "gamedef.h"
+//#include "mapnode.h"
enum BiomeTerrainType
{
extern NoiseParams nparams_biome_def_heat;
extern NoiseParams nparams_biome_def_humidity;
-class Biome {
+
+struct BiomeNoiseInput {
+ v2s16 mapsize;
+ float *heat_map;
+ float *humidity_map;
+ s16 *height_map;
+};
+
+class Biome : public GenElement {
public:
- u8 id;
- std::string name;
u32 flags;
content_t c_top;
float humidity_point;
};
-struct BiomeNoiseInput {
- v2s16 mapsize;
- float *heat_map;
- float *humidity_map;
- s16 *height_map;
-};
-
-class BiomeDefManager {
+class BiomeManager : public GenElementManager {
public:
- std::vector<Biome *> biomes;
+ static const char *ELEMENT_TITLE;
+ static const size_t ELEMENT_LIMIT = 0x100;
- bool biome_registration_finished;
NoiseParams *np_heat;
NoiseParams *np_humidity;
- BiomeDefManager(NodeResolver *resolver);
- ~BiomeDefManager();
+ BiomeManager(IGameDef *gamedef);
+ ~BiomeManager();
- Biome *createBiome(BiomeTerrainType btt);
- void calcBiomes(BiomeNoiseInput *input, u8 *biomeid_map);
- Biome *getBiome(float heat, float humidity, s16 y);
+ Biome *create(int btt)
+ {
+ return new Biome;
+ }
- bool addBiome(Biome *b);
- u8 getBiomeIdByName(const char *name);
-
- s16 calcBlockHeat(v3s16 p, u64 seed, float timeofday, float totaltime);
- s16 calcBlockHumidity(v3s16 p, u64 seed, float timeofday, float totaltime);
+ void calcBiomes(BiomeNoiseInput *input, u8 *biomeid_map);
+ Biome *getBiome(float heat, float humidity, s16 y);
};
#endif
#include "mg_decoration.h"
#include "mg_schematic.h"
#include "mapgen.h"
+#include "noise.h"
#include "map.h"
#include "log.h"
#include "util/numeric.h"
+const char *DecorationManager::ELEMENT_TITLE = "decoration";
+
+FlagDesc flagdesc_deco_schematic[] = {
+ {"place_center_x", DECO_PLACE_CENTER_X},
+ {"place_center_y", DECO_PLACE_CENTER_Y},
+ {"place_center_z", DECO_PLACE_CENTER_Z},
+ {NULL, 0}
+};
+
+
///////////////////////////////////////////////////////////////////////////////
-Decoration *createDecoration(DecorationType type)
+size_t DecorationManager::placeAllDecos(Mapgen *mg, u32 seed, v3s16 nmin, v3s16 nmax)
{
- switch (type) {
- case DECO_SIMPLE:
- return new DecoSimple;
- case DECO_SCHEMATIC:
- return new DecoSchematic;
- //case DECO_LSYSTEM:
- // return new DecoLSystem;
- default:
- return NULL;
+ size_t nplaced = 0;
+
+ for (size_t i = 0; i != m_elements.size(); i++) {
+ Decoration *deco = (Decoration *)m_elements[i];
+ if (!deco)
+ continue;
+
+ nplaced += deco->placeDeco(mg, seed, nmin, nmax);
+ seed++;
}
+
+ return nplaced;
}
+///////////////////////////////////////////////////////////////////////////////
+
+
Decoration::Decoration()
{
mapseed = 0;
}
-void Decoration::placeDeco(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
+size_t Decoration::placeDeco(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
{
PseudoRandom ps(blockseed + 53);
int carea_size = nmax.X - nmin.X + 1;
generate(mg, &ps, max_y, v3s16(x, y, z));
}
}
+
+ return 0;
}
///////////////////////////////////////////////////////////////////////////////
+
bool DecoSimple::canPlaceDecoration(ManualMapVoxelManipulator *vm, v3s16 p)
{
// Don't bother if there aren't any decorations to place
}
-std::string DecoSimple::getName()
+///////////////////////////////////////////////////////////////////////////////
+
+
+void DecoSchematic::generate(Mapgen *mg, PseudoRandom *pr, s16 max_y, v3s16 p)
+{
+ ManualMapVoxelManipulator *vm = mg->vm;
+
+ if (flags & DECO_PLACE_CENTER_X)
+ p.X -= (schematic->size.X + 1) / 2;
+ if (flags & DECO_PLACE_CENTER_Y)
+ p.Y -= (schematic->size.Y + 1) / 2;
+ if (flags & DECO_PLACE_CENTER_Z)
+ p.Z -= (schematic->size.Z + 1) / 2;
+
+ u32 vi = vm->m_area.index(p);
+ content_t c = vm->m_data[vi].getContent();
+ if (!CONTAINS(c_place_on, c))
+ return;
+
+ Rotation rot = (rotation == ROTATE_RAND) ?
+ (Rotation)pr->range(ROTATE_0, ROTATE_270) : rotation;
+
+ schematic->blitToVManip(p, vm, rot, false, mg->ndef);
+}
+
+
+int DecoSchematic::getHeight()
{
- return "";
+ return schematic->size.Y;
}
#define MG_DECORATION_HEADER
#include <set>
-#include "mapnode.h"
+#include "mapgen.h"
class NoiseParams;
class Mapgen;
class ManualMapVoxelManipulator;
class PseudoRandom;
+class Schematic;
enum DecorationType {
DECO_SIMPLE,
DECO_LSYSTEM
};
+#define DECO_PLACE_CENTER_X 0x01
+#define DECO_PLACE_CENTER_Y 0x02
+#define DECO_PLACE_CENTER_Z 0x04
+
+extern FlagDesc flagdesc_deco_schematic[];
+
+
#if 0
struct CutoffData {
VoxelArea a;
};
#endif
-class Decoration {
+class Decoration : public GenElement {
public:
INodeDefManager *ndef;
Decoration();
virtual ~Decoration();
- void placeDeco(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
- void placeCutoffs(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
+ size_t placeDeco(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
+ size_t placeCutoffs(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
virtual void generate(Mapgen *mg, PseudoRandom *pr, s16 max_y, v3s16 p) = 0;
virtual int getHeight() = 0;
- virtual std::string getName() = 0;
};
class DecoSimple : public Decoration {
bool canPlaceDecoration(ManualMapVoxelManipulator *vm, v3s16 p);
virtual void generate(Mapgen *mg, PseudoRandom *pr, s16 max_y, v3s16 p);
virtual int getHeight();
- virtual std::string getName();
};
+class DecoSchematic : public Decoration {
+public:
+ u32 flags;
+ Rotation rotation;
+ Schematic *schematic;
+ std::string filename;
+
+ ~DecoSchematic() {}
+
+ void generate(Mapgen *mg, PseudoRandom *pr, s16 max_y, v3s16 p);
+ virtual int getHeight();
+};
+
+
/*
class DecoLSystem : public Decoration {
public:
};
*/
-Decoration *createDecoration(DecorationType type);
+class DecorationManager : public GenElementManager {
+public:
+ static const char *ELEMENT_TITLE;
+ static const size_t ELEMENT_LIMIT = 0x10000;
+
+ DecorationManager(IGameDef *gamedef) {}
+ ~DecorationManager() {}
+
+ Decoration *create(int type)
+ {
+ switch (type) {
+ case DECO_SIMPLE:
+ return new DecoSimple;
+ case DECO_SCHEMATIC:
+ return new DecoSchematic;
+ //case DECO_LSYSTEM:
+ // return new DecoLSystem;
+ default:
+ return NULL;
+ }
+ }
+
+ size_t placeAllDecos(Mapgen *mg, u32 seed, v3s16 nmin, v3s16 nmax);
+};
#endif
#include "mg_ore.h"
#include "mapgen.h"
+#include "noise.h"
#include "util/numeric.h"
#include "map.h"
#include "log.h"
+const char *OreManager::ELEMENT_TITLE = "ore";
FlagDesc flagdesc_ore[] = {
{"absheight", OREFLAG_ABSHEIGHT},
{NULL, 0}
};
+
///////////////////////////////////////////////////////////////////////////////
-Ore *createOre(OreType type)
+size_t OreManager::placeAllOres(Mapgen *mg, u32 seed, v3s16 nmin, v3s16 nmax)
{
- switch (type) {
- case ORE_SCATTER:
- return new OreScatter;
- case ORE_SHEET:
- return new OreSheet;
- //case ORE_CLAYLIKE: //TODO: implement this!
- // return new OreClaylike;
- default:
- return NULL;
+ size_t nplaced = 0;
+
+ for (size_t i = 0; i != m_elements.size(); i++) {
+ Ore *ore = (Ore *)m_elements[i];
+ if (!ore)
+ continue;
+
+ nplaced += ore->placeOre(mg, seed, nmin, nmax);
+ seed++;
}
+
+ return nplaced;
}
+///////////////////////////////////////////////////////////////////////////////
+
+Ore::Ore()
+{
+ c_ore = CONTENT_IGNORE;
+ np = NULL;
+ noise = NULL;
+}
+
Ore::~Ore()
{
delete np;
}
-void Ore::placeOre(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
+std::string Ore::getName()
+{
+ return name;
+}
+
+
+size_t Ore::placeOre(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax)
{
int in_range = 0;
if (flags & OREFLAG_ABSHEIGHT)
in_range |= (nmin.Y >= -height_max && nmax.Y <= -height_min) << 1;
if (!in_range)
- return;
+ return 0;
int ymin, ymax;
if (in_range & ORE_RANGE_MIRROR) {
ymax = MYMIN(nmax.Y, height_max);
}
if (clust_size >= ymax - ymin + 1)
- return;
+ return 0;
nmin.Y = ymin;
nmax.Y = ymax;
generate(mg->vm, mg->seed, blockseed, nmin, nmax);
+
+ return 0;
}
#define MG_ORE_HEADER
#include "util/string.h"
-#include "mapnode.h"
+#include "mapgen.h"
class NoiseParams;
class Noise;
class ManualMapVoxelManipulator;
/////////////////// Ore generation flags
+
// Use absolute value of height to determine ore placement
#define OREFLAG_ABSHEIGHT 0x01
+
// Use 3d noise to get density of ore placement, instead of just the position
#define OREFLAG_DENSITY 0x02 // not yet implemented
+
// For claylike ore types, place ore if the number of surrounding
// nodes isn't the specified node
#define OREFLAG_NODEISNT 0x04 // not yet implemented
#define ORE_RANGE_ACTUAL 1
#define ORE_RANGE_MIRROR 2
-extern FlagDesc flagdesc_ore[];
enum OreType {
ORE_SCATTER,
ORE_CLAYLIKE
};
-class Ore {
+extern FlagDesc flagdesc_ore[];
+
+class Ore : public GenElement {
public:
content_t c_ore; // the node to place
std::vector<content_t> c_wherein; // the nodes to be placed in
NoiseParams *np; // noise for distribution of clusters (NULL for uniform scattering)
Noise *noise;
- Ore() {
- c_ore = CONTENT_IGNORE;
- np = NULL;
- noise = NULL;
- }
-
+ Ore();
virtual ~Ore();
- void placeOre(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
+ size_t placeOre(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
virtual void generate(ManualMapVoxelManipulator *vm, int seed,
u32 blockseed, v3s16 nmin, v3s16 nmax) = 0;
+ virtual std::string getName();
};
class OreScatter : public Ore {
- ~OreScatter() {}
+ virtual ~OreScatter() {}
virtual void generate(ManualMapVoxelManipulator *vm, int seed,
u32 blockseed, v3s16 nmin, v3s16 nmax);
};
class OreSheet : public Ore {
- ~OreSheet() {}
+ virtual ~OreSheet() {}
virtual void generate(ManualMapVoxelManipulator *vm, int seed,
u32 blockseed, v3s16 nmin, v3s16 nmax);
};
-Ore *createOre(OreType type);
+class OreManager : public GenElementManager {
+public:
+ static const char *ELEMENT_TITLE;
+ static const size_t ELEMENT_LIMIT = 0x10000;
+
+ OreManager(IGameDef *gamedef) {}
+ ~OreManager() {}
+
+ Ore *create(int type)
+ {
+ switch (type) {
+ case ORE_SCATTER:
+ return new OreScatter;
+ case ORE_SHEET:
+ return new OreSheet;
+ //case ORE_CLAYLIKE: //TODO: implement this!
+ // return new OreClaylike;
+ default:
+ return NULL;
+ }
+ }
+ size_t placeAllOres(Mapgen *mg, u32 seed, v3s16 nmin, v3s16 nmax);
+};
#endif
#include "serialization.h"
#include "filesys.h"
-FlagDesc flagdesc_deco_schematic[] = {
- {"place_center_x", DECO_PLACE_CENTER_X},
- {"place_center_y", DECO_PLACE_CENTER_Y},
- {"place_center_z", DECO_PLACE_CENTER_Z},
- {NULL, 0}
-};
+const char *SchematicManager::ELEMENT_TITLE = "schematic";
+
///////////////////////////////////////////////////////////////////////////////
-DecoSchematic::DecoSchematic()
+Schematic::Schematic()
{
- schematic = NULL;
+ schemdata = NULL;
slice_probs = NULL;
flags = 0;
size = v3s16(0, 0, 0);
}
-DecoSchematic::~DecoSchematic()
+Schematic::~Schematic()
{
- delete []schematic;
+ delete []schemdata;
delete []slice_probs;
}
-void DecoSchematic::updateContentIds()
+void Schematic::updateContentIds()
{
- if (flags & DECO_SCHEM_CIDS_UPDATED)
+ if (flags & SCHEM_CIDS_UPDATED)
return;
- flags |= DECO_SCHEM_CIDS_UPDATED;
+ flags |= SCHEM_CIDS_UPDATED;
for (int i = 0; i != size.X * size.Y * size.Z; i++)
- schematic[i].setContent(c_nodes[schematic[i].getContent()]);
+ schemdata[i].setContent(c_nodes[schemdata[i].getContent()]);
}
-void DecoSchematic::generate(Mapgen *mg, PseudoRandom *pr, s16 max_y, v3s16 p)
-{
- ManualMapVoxelManipulator *vm = mg->vm;
-
- if (flags & DECO_PLACE_CENTER_X)
- p.X -= (size.X + 1) / 2;
- if (flags & DECO_PLACE_CENTER_Y)
- p.Y -= (size.Y + 1) / 2;
- if (flags & DECO_PLACE_CENTER_Z)
- p.Z -= (size.Z + 1) / 2;
-
- u32 vi = vm->m_area.index(p);
- content_t c = vm->m_data[vi].getContent();
- if (!CONTAINS(c_place_on, c))
- return;
-
- Rotation rot = (rotation == ROTATE_RAND) ?
- (Rotation)pr->range(ROTATE_0, ROTATE_270) : rotation;
-
- blitToVManip(p, vm, rot, false);
-}
-
-
-int DecoSchematic::getHeight() {
- return size.Y;
-}
-
-
-std::string DecoSchematic::getName() {
- return filename;
-}
-
-
-void DecoSchematic::blitToVManip(v3s16 p, ManualMapVoxelManipulator *vm,
- Rotation rot, bool force_placement)
+void Schematic::blitToVManip(v3s16 p, ManualMapVoxelManipulator *vm,
+ Rotation rot, bool force_placement, INodeDefManager *ndef)
{
int xstride = 1;
int ystride = size.X;
if (!vm->m_area.contains(vi))
continue;
- if (schematic[i].getContent() == CONTENT_IGNORE)
+ if (schemdata[i].getContent() == CONTENT_IGNORE)
continue;
- if (schematic[i].param1 == MTSCHEM_PROB_NEVER)
+ if (schemdata[i].param1 == MTSCHEM_PROB_NEVER)
continue;
if (!force_placement) {
continue;
}
- if (schematic[i].param1 != MTSCHEM_PROB_ALWAYS &&
- myrand_range(1, 255) > schematic[i].param1)
+ if (schemdata[i].param1 != MTSCHEM_PROB_ALWAYS &&
+ myrand_range(1, 255) > schemdata[i].param1)
continue;
- vm->m_data[vi] = schematic[i];
+ vm->m_data[vi] = schemdata[i];
vm->m_data[vi].param1 = 0;
if (rot)
}
-void DecoSchematic::placeStructure(Map *map, v3s16 p, bool force_placement)
+void Schematic::placeStructure(Map *map, v3s16 p, u32 flags,
+ Rotation rot, bool force_placement, INodeDefManager *ndef)
{
- assert(schematic != NULL);
+ assert(schemdata != NULL);
ManualMapVoxelManipulator *vm = new ManualMapVoxelManipulator(map);
- Rotation rot = (rotation == ROTATE_RAND) ?
- (Rotation)myrand_range(ROTATE_0, ROTATE_270) : rotation;
+ if (rot == ROTATE_RAND)
+ rot = (Rotation)myrand_range(ROTATE_0, ROTATE_270);
v3s16 s = (rot == ROTATE_90 || rot == ROTATE_270) ?
v3s16(size.Z, size.Y, size.X) : size;
v3s16 bp2 = getNodeBlockPos(p + s - v3s16(1,1,1));
vm->initialEmerge(bp1, bp2);
- blitToVManip(p, vm, rot, force_placement);
+ blitToVManip(p, vm, rot, force_placement, ndef);
std::map<v3s16, MapBlock *> lighting_modified_blocks;
std::map<v3s16, MapBlock *> modified_blocks;
}
-bool DecoSchematic::loadSchematicFile(NodeResolver *resolver,
+bool Schematic::loadSchematicFromFile(const char *filename,
+ NodeResolver *resolver,
std::map<std::string, std::string> &replace_names)
{
content_t cignore = CONTENT_IGNORE;
bool have_cignore = false;
- std::ifstream is(filename.c_str(), std::ios_base::binary);
+ std::ifstream is(filename, std::ios_base::binary);
u32 signature = readU32(is);
if (signature != MTSCHEM_FILE_SIGNATURE) {
delete []slice_probs;
slice_probs = new u8[size.Y];
- if (version >= 3) {
- for (int y = 0; y != size.Y; y++)
- slice_probs[y] = readU8(is);
- } else {
- for (int y = 0; y != size.Y; y++)
- slice_probs[y] = MTSCHEM_PROB_ALWAYS;
- }
+ for (int y = 0; y != size.Y; y++)
+ slice_probs[y] = (version >= 3) ? readU8(is) : MTSCHEM_PROB_ALWAYS;
int nodecount = size.X * size.Y * size.Z;
}
std::map<std::string, std::string>::iterator it;
-
it = replace_names.find(name);
if (it != replace_names.end())
name = it->second;
resolver->addNodeList(name.c_str(), &c_nodes);
}
- delete []schematic;
- schematic = new MapNode[nodecount];
- MapNode::deSerializeBulk(is, SER_FMT_VER_HIGHEST_READ, schematic,
+ delete []schemdata;
+ schemdata = new MapNode[nodecount];
+ MapNode::deSerializeBulk(is, SER_FMT_VER_HIGHEST_READ, schemdata,
nodecount, 2, 2, true);
if (version == 1) { // fix up the probability values
for (int i = 0; i != nodecount; i++) {
- if (schematic[i].param1 == 0)
- schematic[i].param1 = MTSCHEM_PROB_ALWAYS;
- if (have_cignore && schematic[i].getContent() == cignore)
- schematic[i].param1 = MTSCHEM_PROB_NEVER;
+ if (schemdata[i].param1 == 0)
+ schemdata[i].param1 = MTSCHEM_PROB_ALWAYS;
+ if (have_cignore && schemdata[i].getContent() == cignore)
+ schemdata[i].param1 = MTSCHEM_PROB_NEVER;
}
}
2 - Fixed messy never/always place; 0 probability is now never, 0xFF is always
3 - Added y-slice probabilities; this allows for variable height structures
*/
-void DecoSchematic::saveSchematicFile(INodeDefManager *ndef)
+void Schematic::saveSchematicToFile(const char *filename, INodeDefManager *ndef)
{
std::ostringstream ss(std::ios_base::binary);
std::vector<content_t> usednodes;
int nodecount = size.X * size.Y * size.Z;
- build_nnlist_and_update_ids(schematic, nodecount, &usednodes);
+ build_nnlist_and_update_ids(schemdata, nodecount, &usednodes);
u16 numids = usednodes.size();
writeU16(ss, numids); // name count
ss << serializeString(ndef->get(usednodes[i]).name); // node names
// compressed bulk node data
- MapNode::serializeBulk(ss, SER_FMT_VER_HIGHEST_WRITE, schematic,
+ MapNode::serializeBulk(ss, SER_FMT_VER_HIGHEST_WRITE, schemdata,
nodecount, 2, 2, true);
fs::safeWriteToFile(filename, ss.str());
}
-bool DecoSchematic::getSchematicFromMap(Map *map, v3s16 p1, v3s16 p2)
+bool Schematic::getSchematicFromMap(Map *map, v3s16 p1, v3s16 p2)
{
ManualMapVoxelManipulator *vm = new ManualMapVoxelManipulator(map);
for (s16 y = 0; y != size.Y; y++)
slice_probs[y] = MTSCHEM_PROB_ALWAYS;
- schematic = new MapNode[size.X * size.Y * size.Z];
+ schemdata = new MapNode[size.X * size.Y * size.Z];
u32 i = 0;
for (s16 z = p1.Z; z <= p2.Z; z++)
for (s16 y = p1.Y; y <= p2.Y; y++) {
u32 vi = vm->m_area.index(p1.X, y, z);
for (s16 x = p1.X; x <= p2.X; x++, i++, vi++) {
- schematic[i] = vm->m_data[vi];
- schematic[i].param1 = MTSCHEM_PROB_ALWAYS;
+ schemdata[i] = vm->m_data[vi];
+ schemdata[i].param1 = MTSCHEM_PROB_ALWAYS;
}
}
}
-void DecoSchematic::applyProbabilities(v3s16 p0,
+void Schematic::applyProbabilities(v3s16 p0,
std::vector<std::pair<v3s16, u8> > *plist,
std::vector<std::pair<s16, u8> > *splist)
{
int index = p.Z * (size.Y * size.X) + p.Y * size.X + p.X;
if (index < size.Z * size.Y * size.X) {
u8 prob = (*plist)[i].second;
- schematic[index].param1 = prob;
+ schemdata[index].param1 = prob;
// trim unnecessary node names from schematic
if (prob == MTSCHEM_PROB_NEVER)
- schematic[index].setContent(CONTENT_AIR);
+ schemdata[index].setContent(CONTENT_AIR);
}
}
class PseudoRandom;
class NodeResolver;
-/////////////////// Decoration flags
-#define DECO_PLACE_CENTER_X 1
-#define DECO_PLACE_CENTER_Y 2
-#define DECO_PLACE_CENTER_Z 4
-#define DECO_SCHEM_CIDS_UPDATED 8
+/////////////////// Schematic flags
+#define SCHEM_CIDS_UPDATED 0x08
#define MTSCHEM_FILE_SIGNATURE 0x4d54534d // 'MTSM'
#define MTSCHEM_PROB_NEVER 0x00
#define MTSCHEM_PROB_ALWAYS 0xFF
-extern FlagDesc flagdesc_deco_schematic[];
-class DecoSchematic : public Decoration {
+class Schematic : public GenElement {
public:
- std::string filename;
-
std::vector<content_t> c_nodes;
u32 flags;
- Rotation rotation;
v3s16 size;
- MapNode *schematic;
+ MapNode *schemdata;
u8 *slice_probs;
- DecoSchematic();
- ~DecoSchematic();
+ Schematic();
+ ~Schematic();
void updateContentIds();
- virtual void generate(Mapgen *mg, PseudoRandom *pr, s16 max_y, v3s16 p);
- virtual int getHeight();
- virtual std::string getName();
void blitToVManip(v3s16 p, ManualMapVoxelManipulator *vm,
- Rotation rot, bool force_placement);
+ Rotation rot, bool force_placement, INodeDefManager *ndef);
- bool loadSchematicFile(NodeResolver *resolver,
+ bool loadSchematicFromFile(const char *filename, NodeResolver *resolver,
std::map<std::string, std::string> &replace_names);
- void saveSchematicFile(INodeDefManager *ndef);
-
+ void saveSchematicToFile(const char *filename, INodeDefManager *ndef);
bool getSchematicFromMap(Map *map, v3s16 p1, v3s16 p2);
- void placeStructure(Map *map, v3s16 p, bool force_placement);
+
+ void placeStructure(Map *map, v3s16 p, u32 flags,
+ Rotation rot, bool force_placement, INodeDefManager *nef);
void applyProbabilities(v3s16 p0,
std::vector<std::pair<v3s16, u8> > *plist,
std::vector<std::pair<s16, u8> > *splist);
};
+class SchematicManager : public GenElementManager {
+public:
+ static const char *ELEMENT_TITLE;
+ static const size_t ELEMENT_LIMIT = 0x10000;
+
+ SchematicManager(IGameDef *gamedef) {}
+ ~SchematicManager() {}
+
+ Schematic *create(int type)
+ {
+ return new Schematic;
+ }
+};
+
void build_nnlist_and_update_ids(MapNode *nodes, u32 nodecount,
std::vector<content_t> *usednodes);
}
/******************************************************************************/
-bool read_schematic(lua_State *L, int index, DecoSchematic *dschem, Server *server) {
+
+bool get_schematic(lua_State *L, int index, Schematic *schem,
+ INodeDefManager *ndef, std::map<std::string, std::string> &replace_names)
+{
if (index < 0)
index = lua_gettop(L) + 1 + index;
- INodeDefManager *ndef = server->getNodeDefManager();
-
if (lua_istable(L, index)) {
- lua_getfield(L, index, "size");
- v3s16 size = read_v3s16(L, -1);
- lua_pop(L, 1);
-
- int numnodes = size.X * size.Y * size.Z;
- MapNode *schemdata = new MapNode[numnodes];
- int i = 0;
-
- // Get schematic data
- lua_getfield(L, index, "data");
- luaL_checktype(L, -1, LUA_TTABLE);
-
- lua_pushnil(L);
- while (lua_next(L, -2)) {
- if (i < numnodes) {
- // same as readnode, except param1 default is MTSCHEM_PROB_CONST
- lua_getfield(L, -1, "name");
- const char *name = luaL_checkstring(L, -1);
- lua_pop(L, 1);
-
- u8 param1;
- lua_getfield(L, -1, "param1");
- param1 = !lua_isnil(L, -1) ? lua_tonumber(L, -1) : MTSCHEM_PROB_ALWAYS;
- lua_pop(L, 1);
+ return read_schematic(L, index, schem, ndef, replace_names);
+ } else if (lua_isstring(L, index)) {
+ NodeResolver *resolver = ndef->getResolver();
+ const char *filename = lua_tostring(L, index);
+ return schem->loadSchematicFromFile(filename, resolver, replace_names);
+ } else {
+ return false;
+ }
+}
+
+bool read_schematic(lua_State *L, int index, Schematic *schem,
+ INodeDefManager *ndef, std::map<std::string, std::string> &replace_names)
+{
+ //// Get schematic size
+ lua_getfield(L, index, "size");
+ v3s16 size = read_v3s16(L, -1);
+ lua_pop(L, 1);
+
+ //// Get schematic data
+ lua_getfield(L, index, "data");
+ luaL_checktype(L, -1, LUA_TTABLE);
- u8 param2;
- lua_getfield(L, -1, "param2");
- param2 = !lua_isnil(L, -1) ? lua_tonumber(L, -1) : 0;
- lua_pop(L, 1);
-
- schemdata[i] = MapNode(ndef, name, param1, param2);
- }
-
- i++;
+ int numnodes = size.X * size.Y * size.Z;
+ MapNode *schemdata = new MapNode[numnodes];
+ int i = 0;
+
+ lua_pushnil(L);
+ while (lua_next(L, -2)) {
+ if (i < numnodes) {
+ // same as readnode, except param1 default is MTSCHEM_PROB_CONST
+ lua_getfield(L, -1, "name");
+ std::string name = luaL_checkstring(L, -1);
+ lua_pop(L, 1);
+
+ u8 param1;
+ lua_getfield(L, -1, "param1");
+ param1 = !lua_isnil(L, -1) ? lua_tonumber(L, -1) : MTSCHEM_PROB_ALWAYS;
lua_pop(L, 1);
+
+ u8 param2;
+ lua_getfield(L, -1, "param2");
+ param2 = !lua_isnil(L, -1) ? lua_tonumber(L, -1) : 0;
+ lua_pop(L, 1);
+
+ std::map<std::string, std::string>::iterator it;
+ it = replace_names.find(name);
+ if (it != replace_names.end())
+ name = it->second;
+
+ schemdata[i] = MapNode(ndef, name, param1, param2);
}
- if (i != numnodes) {
- errorstream << "read_schematic: incorrect number of "
- "nodes provided in raw schematic data (got " << i <<
- ", expected " << numnodes << ")." << std::endl;
- return false;
- }
+ i++;
+ lua_pop(L, 1);
+ }
- u8 *sliceprobs = new u8[size.Y];
- for (i = 0; i != size.Y; i++)
- sliceprobs[i] = MTSCHEM_PROB_ALWAYS;
-
- // Get Y-slice probability values (if present)
- lua_getfield(L, index, "yslice_prob");
- if (lua_istable(L, -1)) {
- lua_pushnil(L);
- while (lua_next(L, -2)) {
- if (getintfield(L, -1, "ypos", i) && i >= 0 && i < size.Y) {
- sliceprobs[i] = getintfield_default(L, -1,
- "prob", MTSCHEM_PROB_ALWAYS);
- }
- lua_pop(L, 1);
- }
- }
+ if (i != numnodes) {
+ errorstream << "read_schematic: incorrect number of "
+ "nodes provided in raw schematic data (got " << i <<
+ ", expected " << numnodes << ")." << std::endl;
+ return false;
+ }
- dschem->size = size;
- dschem->schematic = schemdata;
- dschem->slice_probs = sliceprobs;
+ //// Get Y-slice probability values (if present)
+ u8 *slice_probs = new u8[size.Y];
+ for (i = 0; i != size.Y; i++)
+ slice_probs[i] = MTSCHEM_PROB_ALWAYS;
- } else if (lua_isstring(L, index)) {
- dschem->filename = std::string(lua_tostring(L, index));
- } else {
- errorstream << "read_schematic: missing schematic "
- "filename or raw schematic data" << std::endl;
- return false;
+ lua_getfield(L, index, "yslice_prob");
+ if (lua_istable(L, -1)) {
+ lua_pushnil(L);
+ while (lua_next(L, -2)) {
+ if (getintfield(L, -1, "ypos", i) && i >= 0 && i < size.Y) {
+ slice_probs[i] = getintfield_default(L, -1,
+ "prob", MTSCHEM_PROB_ALWAYS);
+ }
+ lua_pop(L, 1);
+ }
}
-
+
+ schem->flags = 0;
+ schem->size = size;
+ schem->schemdata = schemdata;
+ schem->slice_probs = slice_probs;
return true;
}
struct HitParams;
struct EnumString;
struct NoiseParams;
-class DecoSchematic;
+class Schematic;
ContentFeatures read_content_features (lua_State *L, int index);
bool read_noiseparams_nc (lua_State *L, int index,
NoiseParams *np);
-
+bool get_schematic (lua_State *L, int index,
+ Schematic *schem,
+ INodeDefManager *ndef,
+ std::map<std::string, std::string> &replace_names);
bool read_schematic (lua_State *L, int index,
- DecoSchematic *dschem,
- Server *server);
+ Schematic *dschem,
+ INodeDefManager *ndef,
+ std::map<std::string, std::string> &replace_names);
void luaentity_get (lua_State *L,u16 id);
#include "util/serialize.h"
#include "server.h"
#include "environment.h"
-#include "mg_biome.h"
#include "emerge.h"
#include "mg_biome.h"
#include "mg_ore.h"
#include "mg_decoration.h"
#include "mg_schematic.h"
#include "mapgen_v7.h"
+#include "settings.h"
#include "main.h"
#include "log.h"
static void read_schematic_replacements(lua_State *L,
- std::map<std::string, std::string> replace_names, int index)
+ std::map<std::string, std::string> &replace_names, int index)
{
lua_pushnil(L);
while (lua_next(L, index)) {
luaL_checktype(L, index, LUA_TTABLE);
NodeResolver *resolver = getServer(L)->getNodeDefManager()->getResolver();
- BiomeDefManager *bmgr = getServer(L)->getEmergeManager()->biomedef;
+ BiomeManager *bmgr = getServer(L)->getEmergeManager()->biomemgr;
enum BiomeTerrainType terrain = (BiomeTerrainType)getenumfield(L, index,
"terrain_type", es_BiomeTerrainType, BIOME_TERRAIN_NORMAL);
- Biome *b = bmgr->createBiome(terrain);
+ Biome *b = bmgr->create(terrain);
- b->name = getstringfield_default(L, index, "name", "<no name>");
+ b->name = getstringfield_default(L, index, "name", "");
b->depth_top = getintfield_default(L, index, "depth_top", 1);
b->depth_filler = getintfield_default(L, index, "depth_filler", 3);
b->height_min = getintfield_default(L, index, "height_min", 0);
b->humidity_point = getfloatfield_default(L, index, "humidity_point", 0.);
b->flags = 0; //reserved
- if (!bmgr->addBiome(b)) {
+ u32 id = bmgr->add(b);
+ if (id == (u32)-1) {
delete b;
return 0;
}
verbosestream << "register_biome: " << b->name << std::endl;
- return 0;
+ lua_pushinteger(L, id);
+ return 1;
}
// register_decoration({lots of stuff})
int index = 1;
luaL_checktype(L, index, LUA_TTABLE);
- EmergeManager *emerge = getServer(L)->getEmergeManager();
- BiomeDefManager *bdef = emerge->biomedef;
- NodeResolver *resolver = getServer(L)->getNodeDefManager()->getResolver();
+ INodeDefManager *ndef = getServer(L)->getNodeDefManager();
+ NodeResolver *resolver = getServer(L)->getNodeDefManager()->getResolver();
+ DecorationManager *decomgr = getServer(L)->getEmergeManager()->decomgr;
+ BiomeManager *biomemgr = getServer(L)->getEmergeManager()->biomemgr;
enum DecorationType decotype = (DecorationType)getenumfield(L, index,
"deco_type", es_DecorationType, -1);
- Decoration *deco = createDecoration(decotype);
+ Decoration *deco = decomgr->create(decotype);
if (!deco) {
errorstream << "register_decoration: decoration placement type "
<< decotype << " not implemented";
return 0;
}
+ deco->name = getstringfield_default(L, index, "name", "");
deco->fill_ratio = getfloatfield_default(L, index, "fill_ratio", 0.02);
deco->sidelen = getintfield_default(L, index, "sidelen", 8);
if (deco->sidelen <= 0) {
std::vector<const char *> biome_list;
getstringlistfield(L, index, "biomes", biome_list);
for (size_t i = 0; i != biome_list.size(); i++) {
- u8 biomeid = bdef->getBiomeIdByName(biome_list[i]);
- if (biomeid)
- deco->biomes.insert(biomeid);
+ Biome *b = (Biome *)biomemgr->getByName(biome_list[i]);
+ if (!b)
+ continue;
+
+ deco->biomes.insert(b->id);
}
//// Handle decoration type-specific parameters
success = regDecoSimple(L, resolver, (DecoSimple *)deco);
break;
case DECO_SCHEMATIC:
- success = regDecoSchematic(L, resolver, (DecoSchematic *)deco);
+ success = regDecoSchematic(L, ndef, (DecoSchematic *)deco);
break;
case DECO_LSYSTEM:
break;
return 0;
}
- emerge->decorations.push_back(deco);
-
- verbosestream << "register_decoration: decoration '" << deco->getName()
- << "' registered" << std::endl;
+ u32 id = decomgr->add(deco);
+ if (id == (u32)-1) {
+ delete deco;
+ return 0;
+ }
- return 0;
+ lua_pushinteger(L, id);
+ return 1;
}
bool ModApiMapgen::regDecoSimple(lua_State *L,
return true;
}
-bool ModApiMapgen::regDecoSchematic(lua_State *L,
- NodeResolver *resolver, DecoSchematic *deco)
+bool ModApiMapgen::regDecoSchematic(lua_State *L, INodeDefManager *ndef,
+ DecoSchematic *deco)
{
int index = 1;
read_schematic_replacements(L, replace_names, lua_gettop(L));
lua_pop(L, 1);
+ Schematic *schem = new Schematic;
lua_getfield(L, index, "schematic");
- if (!read_schematic(L, -1, deco, getServer(L))) {
+ if (!get_schematic(L, -1, schem, ndef, replace_names)) {
lua_pop(L, 1);
+ delete schem;
return false;
}
lua_pop(L, 1);
- if (!deco->filename.empty() &&
- !deco->loadSchematicFile(resolver, replace_names)) {
- errorstream << "register_decoration: failed to load schematic"
- " file '" << deco->filename << "'" << std::endl;
- return false;
- }
+ deco->schematic = schem;
return true;
}
int index = 1;
luaL_checktype(L, index, LUA_TTABLE);
- EmergeManager *emerge = getServer(L)->getEmergeManager();
NodeResolver *resolver = getServer(L)->getNodeDefManager()->getResolver();
+ OreManager *oremgr = getServer(L)->getEmergeManager()->oremgr;
enum OreType oretype = (OreType)getenumfield(L, index,
"ore_type", es_OreType, ORE_SCATTER);
- Ore *ore = createOre(oretype);
+ Ore *ore = oremgr->create(oretype);
if (!ore) {
- errorstream << "register_ore: ore_type "
- << oretype << " not implemented";
+ errorstream << "register_ore: ore_type " << oretype << " not implemented";
return 0;
}
+ ore->name = getstringfield_default(L, index, "name", "");
ore->ore_param2 = (u8)getintfield_default(L, index, "ore_param2", 0);
ore->clust_scarcity = getintfield_default(L, index, "clust_scarcity", 1);
ore->clust_num_ores = getintfield_default(L, index, "clust_num_ores", 1);
ore->clust_size = getintfield_default(L, index, "clust_size", 0);
ore->height_min = getintfield_default(L, index, "height_min", 0);
ore->height_max = getintfield_default(L, index, "height_max", 0);
- ore->nthresh = getfloatfield_default(L, index, "noise_threshhold", 0.);
+ ore->nthresh = getfloatfield_default(L, index, "noise_threshhold", 0);
ore->noise = NULL;
ore->flags = 0;
ore->np = read_noiseparams(L, -1);
lua_pop(L, 1);
+ u32 id = oremgr->add(ore);
+ if (id == (u32)-1) {
+ delete ore;
+ return 0;
+ }
+
std::vector<const char *> wherein_names;
getstringlistfield(L, index, "wherein", wherein_names);
for (size_t i = 0; i != wherein_names.size(); i++)
resolver->addNode(getstringfield_default(L, index, "ore", ""),
"", CONTENT_AIR, &ore->c_ore);
- emerge->ores.push_back(ore);
-
- //verbosestream << "register_ore: ore '" << ore->ore_name
- // << "' registered" << std::endl;
- return 0;
+ lua_pushinteger(L, id);
+ return 1;
}
// create_schematic(p1, p2, probability_list, filename)
int ModApiMapgen::l_create_schematic(lua_State *L)
{
- DecoSchematic dschem;
+ Schematic schem;
Map *map = &(getEnv(L)->getMap());
INodeDefManager *ndef = getServer(L)->getNodeDefManager();
}
}
- const char *s = lua_tostring(L, 4);
- dschem.filename = std::string(s ? s : "");
+ const char *filename = luaL_checkstring(L, 4);
- if (!dschem.getSchematicFromMap(map, p1, p2)) {
+ if (!schem.getSchematicFromMap(map, p1, p2)) {
errorstream << "create_schematic: failed to get schematic "
"from map" << std::endl;
return 0;
}
- dschem.applyProbabilities(p1, &prob_list, &slice_prob_list);
+ schem.applyProbabilities(p1, &prob_list, &slice_prob_list);
- dschem.saveSchematicFile(ndef);
+ schem.saveSchematicToFile(filename, ndef);
actionstream << "create_schematic: saved schematic file '"
- << dschem.filename << "'." << std::endl;
+ << filename << "'." << std::endl;
return 1;
}
// place_schematic(p, schematic, rotation, replacement)
int ModApiMapgen::l_place_schematic(lua_State *L)
{
- DecoSchematic dschem;
+ Schematic schem;
Map *map = &(getEnv(L)->getMap());
- NodeResolver *resolver = getServer(L)->getNodeDefManager()->getResolver();
+ INodeDefManager *ndef = getServer(L)->getNodeDefManager();
+ //// Read position
v3s16 p = read_v3s16(L, 1);
- if (!read_schematic(L, 2, &dschem, getServer(L)))
- return 0;
+ //// Read rotation
int rot = ROTATE_0;
if (lua_isstring(L, 3))
string_to_enum(es_Rotation, rot, std::string(lua_tostring(L, 3)));
- dschem.rotation = (Rotation)rot;
+ //// Read force placement
+ bool force_placement = true;
+ if (lua_isboolean(L, 5))
+ force_placement = lua_toboolean(L, 5);
+ //// Read node replacements
std::map<std::string, std::string> replace_names;
if (lua_istable(L, 4))
read_schematic_replacements(L, replace_names, 4);
- bool force_placement = true;
- if (lua_isboolean(L, 5))
- force_placement = lua_toboolean(L, 5);
-
- if (!dschem.filename.empty()) {
- if (!dschem.loadSchematicFile(resolver, replace_names)) {
- errorstream << "place_schematic: failed to load schematic file '"
- << dschem.filename << "'" << std::endl;
- return 0;
- }
+ //// Read schematic
+ if (!get_schematic(L, 2, &schem, ndef, replace_names)) {
+ errorstream << "place_schematic: failed to get schematic" << std::endl;
+ return 0;
}
- dschem.placeStructure(map, p, force_placement);
+ schem.placeStructure(map, p, 0, (Rotation)rot, force_placement, ndef);
return 1;
}
#include "lua_api/l_base.h"
+class INodeDefManager;
class NodeResolver;
class DecoSimple;
class DecoSchematic;
static bool regDecoSimple(lua_State *L,
NodeResolver *resolver, DecoSimple *deco);
static bool regDecoSchematic(lua_State *L,
- NodeResolver *resolver, DecoSchematic *deco);
+ INodeDefManager *ndef, DecoSchematic *deco);
static struct EnumString es_BiomeTerrainType[];
static struct EnumString es_DecorationType[];
projects / oweals / minetest.git / commitdiff