Add initial Decoration support, many misc. improvements & modifications

doc/lua_api.txt

@@ -410,6 +410,18 @@ Currently supported flags:  absheight
     Also produce this same ore between the height range of -height_max and -height_min.
     Useful for having ore in sky realms without having to duplicate ore entries.
 
+Decoration types
+-------------------
+The varying types of decorations that can be placed.
+The default value is simple, and is currently the only type supported.
+
+- simple
+    Creates a 1xHx1 column of a specified node (or a random node from a list, if a decoration
+    list is specified).  Can specify a certain node it must spawn next to, such as water or lava,
+    for example.  Can also generate a decoration of random height between a specified lower and
+    upper bound.  This type of decoration is intended for placement of grass, flowers, cacti,
+    papyrus, and so on.
+
 HUD element types
 -------------------
 The position field is used for all element types.
@@ -946,6 +958,7 @@ minetest.register_craftitem(name, item definition)
 minetest.register_alias(name, convert_to)
 minetest.register_craft(recipe)
 minetest.register_ore(ore definition)
+minetest.register_decoration(decoration definition)
 
 Global callback registration functions: (Call these only at load time)
 minetest.register_globalstep(func(dtime))
@@ -1835,7 +1848,7 @@ Recipe for register_craft (furnace fuel)
 
 Ore definition (register_ore)
 {
-    ore_type = "scatter" -- See "Ore types"
+    ore_type = "scatter", -- See "Ore types"
     ore = "default:stone_with_coal",
     wherein = "default:stone",
     clust_scarcity = 8*8*8,
@@ -1857,6 +1870,40 @@ Ore definition (register_ore)
     ^ Needed for sheet ore_type.  Omit from scatter ore_type for a uniform ore distribution
 }
 
+Decoration definition (register_decoration)
+{
+    deco_type = "simple", -- See "Decoration types"
+    place_on = "default:dirt_with_grass",
+    ^ Node that decoration can be placed on
+    divlen = 8,
+    ^ Number of divisions made in the chunk being generated
+    fill_ratio = 0.02,
+    ^ Ratio of the area to be uniformly filled by the decoration.
+    ^ Used only if noise_params is not specified.
+    noise_params = {offset=0, scale=.45, spread={x=100, y=100, z=100}, seed=354, octaves=3, persist=0.7},
+    ^ NoiseParams structure describing the perlin noise used for decoration distribution.
+    ^ The result of this is multiplied by the 2d area of the division being decorated.
+    biomes = {"Oceanside", "Hills", "Plains"},
+    ^ List of biomes in which this decoration occurs.  Occurs in all biomes if this is omitted,
+    ^ and ignored if the Mapgen being used does not support biomes.
+
+    ----- Simple-type parameters
+    decoration = "default:grass",
+    ^ The node name used as the decoration.
+    ^ If instead a list of strings, a randomly selected node from the list is placed as the decoration.
+    height = 1,
+    ^ Number of nodes high the decoration is made.
+    ^ If height_max is not 0, this is the lower bound of the randomly selected height.
+    height_max = 0,
+    ^ Number of nodes the decoration can be at maximum.
+    ^ If absent, the parameter 'height' is used as a constant.
+    spawn_by = "default:water",
+    ^ Node that the decoration only spawns next to, in a 1-node square radius.
+    num_spawn_by = 1,
+    ^ Number of spawn_by nodes that must be surrounding the decoration position to occur.
+    ^ If absent or -1, decorations occur next to any nodes.
+}
+
 Chatcommand definition (register_chatcommand)
 {
     params = "<name> <privilege>", -- short parameter description

src/biome.cpp

@@ -168,3 +168,13 @@ Biome *BiomeDefManager::getBiome(float heat, float humidity, s16 y) {
 	
 	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;
+}

src/biome.h

@@ -84,6 +84,7 @@ public:
 
 	void addBiome(Biome *b);
 	void resolveNodeNames(INodeDefManager *ndef);
+	u8 getBiomeIdByName(const char *name);
 };
 
 #endif

src/defaultsettings.cpp

@@ -239,7 +239,7 @@ void set_default_settings(Settings *settings)
 	settings->setDefault("mgv7_np_terrain_mod",      "0, 1, (350, 350, 350), 85039, 5, 0.6");
 	settings->setDefault("mgv7_np_terrain_persist",  "0, 1, (500, 500, 500), 539, 3, 0.6");
 	settings->setDefault("mgv7_np_height_select",    "0.5, 0.5, (250, 250, 250), 4213, 5, 0.69");
-	settings->setDefault("mgv7_np_ridge",            "0.5, 1, (100, 100, 100), 6467, 4, 0.75");
+	settings->setDefault("mgv7_np_ridge",            "0, 1, (100, 100, 100), 6467, 4, 0.75");
 
 	settings->setDefault("mgindev_np_terrain_base",   "-4,   20,  (250, 250, 250), 82341, 5, 0.6,  10,  10");
 	settings->setDefault("mgindev_np_terrain_higher", "20,   16,  (500, 500, 500), 85039, 5, 0.6,  10,  10");

src/emerge.cpp

@@ -102,6 +102,10 @@ EmergeManager::~EmergeManager() {
 		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 iter = mglist.begin();
 			iter != mglist.end(); iter ++) {
 		delete iter->second;

src/emerge.h

@@ -87,6 +87,7 @@ public:
 	//Mapgen-related structures
 	BiomeDefManager *biomedef;
 	std::vector<Ore *> ores;
+	std::vector<Decoration *> decorations;
 
 	EmergeManager(IGameDef *gamedef);
 	~EmergeManager();

src/mapgen.cpp

@@ -112,7 +112,6 @@ void Ore::placeOre(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax) {
 	resolveNodeNames(mg->ndef);
 
 	int ymin, ymax;
-	
 	if (in_range & ORE_RANGE_MIRROR) {
 		ymin = MYMAX(nmin.Y, -height_max);
 		ymax = MYMIN(nmax.Y, -height_min);
@@ -201,6 +200,316 @@ void OreSheet::generate(ManualMapVoxelManipulator *vm, int seed,
 }
 
 
+Decoration *createDecoration(DecorationType type) {
+	switch (type) {
+		case DECO_SIMPLE:
+			return new DecoSimple;
+		//case DECO_SCHEMATIC:
+		//	return new DecoSchematic;
+		//case DECO_LSYSTEM:
+		//	return new DecoLSystem;
+		default:
+			return NULL;
+	}
+}
+
+
+Decoration::~Decoration() {
+	delete np;
+}
+
+
+void Decoration::resolveNodeNames(INodeDefManager *ndef) {
+	if (c_place_on == CONTENT_IGNORE)
+		c_place_on = ndef->getId(place_on_name);
+}
+
+
+void Decoration::placeDeco(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax) {
+	resolveNodeNames(mg->ndef);
+
+	PseudoRandom ps(blockseed + 53);
+	int carea_size = nmax.X - nmin.X + 1;
+
+	// Divide area into parts
+	s16 sidelen = carea_size / divlen;
+	float area = sidelen * sidelen;
+
+	for (s16 z0 = 0; z0 < divlen; z0++)
+	for (s16 x0 = 0; x0 < divlen; x0++) {
+		v2s16 p2d_center( // Center position of part of division
+			nmin.X + sidelen / 2 + sidelen * x0,
+			nmin.Z + sidelen / 2 + sidelen * z0
+		);
+		v2s16 p2d_min( // Minimum edge of part of division
+			nmin.X + sidelen * x0,
+			nmin.Z + sidelen * z0
+		);
+		v2s16 p2d_max( // Maximum edge of part of division
+			nmin.X + sidelen + sidelen * x0 - 1,
+			nmin.Z + sidelen + sidelen * z0 - 1
+		);
+
+		// Amount of decorations
+		float nval = np ?
+			NoisePerlin2D(np, p2d_center.X, p2d_center.Y, mapseed) :
+			fill_ratio;
+		u32 deco_count = area * MYMAX(nval, 0.f);
+
+		for (u32 i = 0; i < deco_count; i++) {
+			s16 x = ps.range(p2d_min.X, p2d_max.X);
+			s16 z = ps.range(p2d_min.Y, p2d_max.Y);
+
+			int mapindex = carea_size * (z - nmin.Z) + (x - nmin.X);
+			
+			s16 y = mg->heightmap ? 
+					mg->heightmap[mapindex] :
+					mg->findGroundLevel(v2s16(x, z), nmin.Y, nmax.Y);
+					
+			if (y < nmin.Y || y > nmax.Y)
+				continue;
+
+			int height = getHeight();
+			int max_y = nmax.Y + MAP_BLOCKSIZE;
+			if (y + 1 + height > max_y) {
+				continue;
+#if 0
+				printf("Decoration at (%d %d %d) cut off\n", x, y, z);
+				//add to queue
+				JMutexAutoLock cutofflock(cutoff_mutex);
+				cutoffs.push_back(CutoffData(x, y, z, height));
+#endif
+			}
+
+			if (mg->biomemap) {
+				std::set<u8>::iterator iter;
+				
+				if (biomes.size()) {
+					iter = biomes.find(mg->biomemap[mapindex]);
+					if (iter == biomes.end())
+						continue;
+				}
+			}
+
+			generate(mg, &ps, max_y, 0, v3s16(x, y, z));
+		}
+	}
+}
+
+
+#if 0
+void Decoration::placeCutoffs(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax) {
+	PseudoRandom pr(blockseed + 53);
+	std::vector<CutoffData> handled_cutoffs;
+	
+	// Copy over the cutoffs we're interested in so we don't needlessly hold a lock
+	{
+		JMutexAutoLock cutofflock(cutoff_mutex);
+		for (std::list<CutoffData>::iterator i = cutoffs.begin();
+			i != cutoffs.end(); ++i) {
+			CutoffData cutoff = *i;
+			v3s16 p    = cutoff.p;
+			s16 height = cutoff.height;
+			if (p.X < nmin.X || p.X > nmax.X ||
+				p.Z < nmin.Z || p.Z > nmax.Z)
+				continue;
+			if (p.Y + height < nmin.Y || p.Y > nmax.Y)
+				continue;
+			
+			handled_cutoffs.push_back(cutoff);
+		}
+	}
+	
+	// Generate the cutoffs
+	for (size_t i = 0; i != handled_cutoffs.size(); i++) {
+		v3s16 p    = handled_cutoffs[i].p;
+		s16 height = handled_cutoffs[i].height;
+		
+		if (p.Y + height > nmax.Y) {
+			//printf("Decoration at (%d %d %d) cut off again!\n", p.X, p.Y, p.Z);
+			cuttoffs.push_back(v3s16(p.X, p.Y, p.Z));
+		}
+		
+		generate(mg, &pr, nmax.Y, nmin.Y - p.Y, v3s16(p.X, nmin.Y, p.Z));
+	}
+	
+	// Remove cutoffs that were handled from the cutoff list
+	{
+		JMutexAutoLock cutofflock(cutoff_mutex);
+		for (std::list<CutoffData>::iterator i = cutoffs.begin();
+			i != cutoffs.end(); ++i) {
+			
+			for (size_t j = 0; j != handled_cutoffs.size(); j++) {
+				CutoffData coff = *i;
+				if (coff.p == handled_cutoffs[j].p)
+					i = cutoffs.erase(i);
+			}
+		}
+	}	
+}
+#endif
+
+
+void DecoSimple::resolveNodeNames(INodeDefManager *ndef) {
+	Decoration::resolveNodeNames(ndef);
+	
+	if (c_deco == CONTENT_IGNORE) {
+		c_deco = ndef->getId(deco_name);
+		if (c_deco == CONTENT_IGNORE) {
+			errorstream << "DecoSimple::resolveNodeNames: decoration node '"
+				<< deco_name << "' not defined";
+			c_deco = CONTENT_AIR;
+		}
+	}
+	if (c_spawnby == CONTENT_IGNORE) {
+		c_spawnby = ndef->getId(spawnby_name);
+		if (c_spawnby == CONTENT_IGNORE) {
+			errorstream << "DecoSimple::resolveNodeNames: spawnby node '"
+				<< deco_name << "' not defined";
+			nspawnby = -1;
+			c_spawnby = CONTENT_AIR;
+		}
+	}
+	
+	if (c_decolist.size())
+		return;
+	
+	for (size_t i = 0; i != decolist_names.size(); i++) {		
+		content_t c = ndef->getId(decolist_names[i]);
+		if (c == CONTENT_IGNORE) {
+			errorstream << "DecoSimple::resolveNodeNames: decolist node '"
+				<< decolist_names[i] << "' not defined";
+			c = CONTENT_AIR;
+		}
+		c_decolist.push_back(c);
+	}
+}
+
+
+void DecoSimple::generate(Mapgen *mg, PseudoRandom *pr, s16 max_y, s16 start_y, v3s16 p) {
+	ManualMapVoxelManipulator *vm = mg->vm;
+
+	u32 vi = vm->m_area.index(p);
+	if (vm->m_data[vi].getContent() != c_place_on &&
+		c_place_on != CONTENT_IGNORE)
+		return;
+		
+	if (nspawnby != -1) {
+		int nneighs = 0;
+		v3s16 dirs[8] = { // a Moore neighborhood
+			v3s16( 0, 0,  1),
+			v3s16( 0, 0, -1),
+			v3s16( 1, 0,  0),
+			v3s16(-1, 0,  0),
+			v3s16( 1, 0,  1),
+			v3s16(-1, 0,  1),
+			v3s16(-1, 0, -1),
+			v3s16( 1, 0, -1)
+		};
+		
+		for (int i = 0; i != 8; i++) {
+			u32 index = vm->m_area.index(p + dirs[i]);
+			if (vm->m_area.contains(index) &&
+				vm->m_data[index].getContent() == c_spawnby)
+				nneighs++;
+		}
+		
+		if (nneighs < nspawnby)
+			return;
+	}
+	
+	size_t ndecos = c_decolist.size();
+	content_t c = ndecos ? c_decolist[pr->range(0, ndecos - 1)] : c_deco;
+
+	s16 height = (deco_height_max > 0) ?
+		pr->range(deco_height, deco_height_max) : deco_height;
+
+	height = MYMIN(height, max_y - p.Y);
+
+	v3s16 em = vm->m_area.getExtent();
+	for (int i = start_y; i < height; i++) {
+		vm->m_area.add_y(em, vi, 1);
+		vm->m_data[vi] = MapNode(c);
+	}
+}
+
+
+int DecoSimple::getHeight() {
+	return (deco_height_max > 0) ? deco_height_max : deco_height;
+}
+
+
+std::string DecoSimple::getName() {
+	return deco_name;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+Mapgen::Mapgen() {
+	seed        = 0;
+	water_level = 0;
+	generating  = false;
+	id          = -1;
+	vm          = NULL;
+	ndef        = NULL;
+	heightmap   = NULL;
+	biomemap    = NULL;
+}
+
+
+// Returns Y one under area minimum if not found
+s16 Mapgen::findGroundLevelFull(v2s16 p2d) {
+	v3s16 em = vm->m_area.getExtent();
+	s16 y_nodes_max = vm->m_area.MaxEdge.Y;
+	s16 y_nodes_min = vm->m_area.MinEdge.Y;
+	u32 i = vm->m_area.index(p2d.X, y_nodes_max, p2d.Y);
+	s16 y;
+	
+	for (y = y_nodes_max; y >= y_nodes_min; y--) {
+		MapNode &n = vm->m_data[i];
+		if (ndef->get(n).walkable)
+			break;
+
+		vm->m_area.add_y(em, i, -1);
+	}
+	return (y >= y_nodes_min) ? y : y_nodes_min - 1;
+}
+
+
+s16 Mapgen::findGroundLevel(v2s16 p2d, s16 ymin, s16 ymax) {
+	v3s16 em = vm->m_area.getExtent();
+	u32 i = vm->m_area.index(p2d.X, ymax, p2d.Y);
+	s16 y;
+	
+	for (y = ymax; y >= ymin; y--) {
+		MapNode &n = vm->m_data[i];
+		if (ndef->get(n).walkable)
+			break;
+
+		vm->m_area.add_y(em, i, -1);
+	}
+	return y;
+}
+
+
+void Mapgen::updateHeightmap(v3s16 nmin, v3s16 nmax) {
+	if (!heightmap)
+		return;
+	
+	//TimeTaker t("Mapgen::updateHeightmap", NULL, PRECISION_MICRO);
+	int index = 0;
+	for (s16 z = nmin.Z; z <= nmax.Z; z++) {
+		for (s16 x = nmin.X; x <= nmax.X; x++) {
+			s16 y = findGroundLevel(v2s16(x, z), nmin.Y, nmax.Y);
+			heightmap[index++] = y;
+		}
+	}
+	//printf("updateHeightmap: %dus\n", t.stop());
+}
+
+
 void Mapgen::updateLiquid(UniqueQueue<v3s16> *trans_liquid, v3s16 nmin, v3s16 nmax) {
 	bool isliquid, wasliquid;
 	v3s16 em  = vm->m_area.getExtent();
@@ -411,7 +720,6 @@ void MapgenV7Params::writeParams(Settings *settings) {
 
 /////////////////////////////////// legacy static functions for farmesh
 
-
 s16 Mapgen::find_ground_level_from_noise(u64 seed, v2s16 p2d, s16 precision) {
 	//just need to return something
 	s16 level = 5;

src/mapgen.h

@@ -86,9 +86,15 @@ public:
 	int id;
 	ManualMapVoxelManipulator *vm;
 	INodeDefManager *ndef;
+	s16 *heightmap;
+	u8 *biomemap;
 
+	Mapgen();
 	virtual ~Mapgen() {}
 
+	s16 findGroundLevelFull(v2s16 p2d);
+	s16 findGroundLevel(v2s16 p2d, s16 ymin, s16 ymax);
+	void updateHeightmap(v3s16 nmin, v3s16 nmax);
 	void updateLiquid(UniqueQueue<v3s16> *trans_liquid, v3s16 nmin, v3s16 nmax);
 	void setLighting(v3s16 nmin, v3s16 nmax, u8 light);
 	void lightSpread(VoxelArea &a, v3s16 p, u8 light);
@@ -166,5 +172,90 @@ class OreSheet : public Ore {
 
 Ore *createOre(OreType type);
 
+
+enum DecorationType {
+	DECO_SIMPLE,
+	DECO_SCHEMATIC,
+	DECO_LSYSTEM
+};
+
+#if 0
+struct CutoffData {
+	VoxelArea a;
+	Decoration *deco;
+	//v3s16 p;
+	//v3s16 size;
+	//s16 height;
+	
+	CutoffData(s16 x, s16 y, s16 z, s16 h) {
+		p = v3s16(x, y, z);
+		height = h;
+	}
+};
+#endif
+
+class Decoration {
+public:
+	int mapseed;
+	std::string place_on_name;
+	content_t c_place_on;
+	s16 divlen;
+	float fill_ratio;
+	NoiseParams *np;
+	
+	std::set<u8> biomes;
+	//std::list<CutoffData> cutoffs;
+	//JMutex cutoff_mutex;
+
+	virtual ~Decoration();
+	
+	virtual void resolveNodeNames(INodeDefManager *ndef);
+	void placeDeco(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
+	void placeCutoffs(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
+	
+	virtual void generate(Mapgen *mg, PseudoRandom *pr, s16 max_y,
+						s16 start_y, v3s16 p) = 0;
+	virtual int getHeight() = 0;
+	virtual std::string getName() = 0;
+};
+
+class DecoSimple : public Decoration {
+public:
+	std::string deco_name;
+	std::string spawnby_name;
+	content_t c_deco;
+	content_t c_spawnby;
+	s16 deco_height;
+	s16 deco_height_max;
+	s16 nspawnby;
+	
+	std::vector<std::string> decolist_names;
+	std::vector<content_t> c_decolist;
+
+	~DecoSimple() {}
+	
+	void resolveNodeNames(INodeDefManager *ndef);
+	virtual void generate(Mapgen *mg, PseudoRandom *pr, s16 max_y,
+						s16 start_y, v3s16 p);
+	virtual int getHeight();
+	virtual std::string getName();
+};
+
+/*
+class DecoSchematic : public Decoration {
+public:
+	virtual void generate(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
+};
+*/
+
+/*
+class DecoLSystem : public Decoration {
+public:
+	virtual void generate(Mapgen *mg, u32 blockseed, v3s16 nmin, v3s16 nmax);
+};
+*/
+
+Decoration *createDecoration(DecorationType type);
+
 #endif
 

src/mapgen_v6.cpp

@@ -108,23 +108,6 @@ MapgenV6::~MapgenV6() {
 
 //////////////////////// Some helper functions for the map generator
 
-// Returns Y one under area minimum if not found
-s16 MapgenV6::find_ground_level(v2s16 p2d) {
-	v3s16 em = vm->m_area.getExtent();
-	s16 y_nodes_max = vm->m_area.MaxEdge.Y;
-	s16 y_nodes_min = vm->m_area.MinEdge.Y;
-	u32 i = vm->m_area.index(p2d.X, y_nodes_max, p2d.Y);
-	s16 y;
-	
-	for (y = y_nodes_max; y >= y_nodes_min; y--) {
-		MapNode &n = vm->m_data[i];
-		if(ndef->get(n).walkable)
-			break;
-
-		vm->m_area.add_y(em, i, -1);
-	}
-	return (y >= y_nodes_min) ? y : y_nodes_min - 1;
-}
 
 // Returns Y one under area minimum if not found
 s16 MapgenV6::find_stone_level(v2s16 p2d) {
@@ -849,7 +832,7 @@ void MapgenV6::placeTreesAndJungleGrass() {
 				s16 x = grassrandom.range(p2d_min.X, p2d_max.X);
 				s16 z = grassrandom.range(p2d_min.Y, p2d_max.Y);
 				
-				s16 y = find_ground_level(v2s16(x, z)); ////////////////optimize this!
+				s16 y = findGroundLevelFull(v2s16(x, z)); ////////////////optimize this!
 				if (y < water_level || y < node_min.Y || y > node_max.Y)
 					continue;
 				
@@ -866,7 +849,7 @@ void MapgenV6::placeTreesAndJungleGrass() {
 		for (u32 i = 0; i < tree_count; i++) {
 			s16 x = myrand_range(p2d_min.X, p2d_max.X);
 			s16 z = myrand_range(p2d_min.Y, p2d_max.Y);
-			s16 y = find_ground_level(v2s16(x, z)); ////////////////////optimize this!
+			s16 y = findGroundLevelFull(v2s16(x, z)); ////////////////////optimize this!
 			// Don't make a tree under water level
 			// Don't make a tree so high that it doesn't fit
 			if(y < water_level || y > node_max.Y - 6)

src/mapgen_v6.h

@@ -132,7 +132,6 @@ public:
 	virtual float baseTerrainLevelFromMap(v2s16 p);
 	virtual float baseTerrainLevelFromMap(int index);
 
-	s16 find_ground_level(v2s16 p2d);
 	s16 find_stone_level(v2s16 p2d);
 	bool block_is_underground(u64 seed, v3s16 blockpos);
 	s16 find_ground_level_from_noise(u64 seed, v2s16 p2d, s16 precision);

src/mapgen_v7.cpp

@@ -52,7 +52,7 @@ NoiseParams nparams_v7_def_terrain_persist =
 NoiseParams nparams_v7_def_height_select =
 	{0.5, 0.5, v3f(250.0, 250.0, 250.0), 4213, 5, 0.69};
 NoiseParams nparams_v7_def_ridge =
-	{0.5, 1.0, v3f(100.0, 100.0, 100.0), 6467, 4, 0.75};
+	{0, 1.0, v3f(100.0, 100.0, 100.0), 6467, 4, 0.75};
 /*
 NoiseParams nparams_v6_def_beach =
 	{0.0, 1.0, v3f(250.0, 250.0, 250.0), 59420, 3, 0.50};
@@ -121,15 +121,19 @@ int MapgenV7::getGroundLevelAtPoint(v2s16 p) {
 	Biome *b = bmgr->getBiome(heat, humidity, groundlevel);
 	
 	s16 y = groundlevel;
-	if (y > water_level) {
+	int iters = 1024; // don't even bother iterating more than 64 times..
-		int iters = 1024; // don't even bother iterating more than 1024 times..
 	while (iters--) {
+		if (y <= water_level)
+			break;
+		
 		float ridgenoise = NoisePerlin3D(noise_ridge->np, p.X, y, p.Y, seed);
 		if (ridgenoise * (float)(y * y) < 15.0)
 			break;
+			
 		y--;
 	}
-	}
+	if (iters == 0)
+		printf("iters exhausted at %d %d\n", p.X, p.Y);
 
 	return y + b->top_depth;
 }
@@ -183,14 +187,23 @@ void MapgenV7::makeChunk(BlockMakeData *data) {
 	generateTerrain();
 	carveRidges();
 
+	if (flags & MG_CAVES)
 		generateCaves(stone_surface_max_y);
+	
 	addTopNodes();
 	
+	updateHeightmap(node_min, node_max);
+
 	if (flags & MG_DUNGEONS) {
 		DungeonGen dgen(ndef, data->seed, water_level);
 		dgen.generate(vm, 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);
+	}
+
 	for (size_t i = 0; i != emerge->ores.size(); i++) {
 		Ore *ore = emerge->ores[i];
 		ore->placeOre(this, blockseed + i, node_min, node_max);

src/mapgen_v7.h

@@ -67,9 +67,7 @@ public:
 	v3s16 full_node_min;
 	v3s16 full_node_max;
 	
-	s16 *heightmap;
 	s16 *ridge_heightmap;
-	u8 *biomemap;
 	
 	Noise *noise_terrain_base;
 	Noise *noise_terrain_alt;

src/script/lua_api/luaapi.cpp

@@ -43,6 +43,14 @@ struct EnumString ModApiBasic::es_OreType[] =
 	{0, NULL},
 };
 
+struct EnumString ModApiBasic::es_DecorationType[] =
+{
+	{DECO_SIMPLE,    "simple"},
+	{DECO_SCHEMATIC, "schematic"},
+	{DECO_LSYSTEM,   "lsystem"},
+	{0, NULL},
+};
+
 
 ModApiBasic::ModApiBasic() : ModApiBase() {
 }
@@ -92,6 +100,7 @@ bool ModApiBasic::Initialize(lua_State* L,int top) {
 	retval &= API_FCT(rollback_revert_actions_by);
 
 	retval &= API_FCT(register_ore);
+	retval &= API_FCT(register_decoration);
 
 	return retval;
 }
@@ -184,8 +193,6 @@ int ModApiBasic::l_register_biome(lua_State *L)
 	return 0;
 }
 
-
-
 // setting_set(name, value)
 int ModApiBasic::l_setting_set(lua_State *L)
 {
@@ -650,4 +657,111 @@ int ModApiBasic::l_register_ore(lua_State *L)
 	return 0;
 }
 
+// register_decoration({lots of stuff})
+int ModApiBasic::l_register_decoration(lua_State *L)
+{
+	int index = 1;
+	luaL_checktype(L, index, LUA_TTABLE);
+	
+	EmergeManager *emerge = getServer(L)->getEmergeManager();
+	BiomeDefManager *bdef = emerge->biomedef;
+
+	enum DecorationType decotype = (DecorationType)getenumfield(L, index,
+				"deco_type", es_DecorationType, -1);
+	if (decotype == -1) {
+		errorstream << "register_decoration: unrecognized "
+			"decoration placement type";
+		return 0;
+	}
+	
+	Decoration *deco = createDecoration(decotype);
+	if (!deco) {
+		errorstream << "register_decoration: decoration placement type "
+			<< decotype << " not implemented";
+		return 0;
+	}
+
+	deco->c_place_on    = CONTENT_IGNORE;
+	deco->place_on_name = getstringfield_default(L, index, "place_on", "ignore");
+	deco->divlen        = getintfield_default(L, index, "divlen", 8);
+	deco->fill_ratio    = getfloatfield_default(L, index, "fill_ratio", 0.02);
+	
+	lua_getfield(L, index, "noise_params");
+	deco->np = read_noiseparams(L, -1);
+	lua_pop(L, 1);
+	
+	lua_getfield(L, index, "biomes");
+	if (lua_istable(L, -1)) {
+		lua_pushnil(L);
+		while (lua_next(L, -2)) {
+			const char *s = lua_tostring(L, -1);
+			u8 biomeid = bdef->getBiomeIdByName(s);
+			if (biomeid)
+				deco->biomes.insert(biomeid);
+
+			lua_pop(L, 1);
+		}
+		lua_pop(L, 1);
+	}
+	
+	switch (decotype) {
+		case DECO_SIMPLE: {
+			DecoSimple *dsimple = (DecoSimple *)deco;
+			dsimple->c_deco     = CONTENT_IGNORE;
+			dsimple->c_spawnby  = CONTENT_IGNORE;
+			dsimple->spawnby_name    = getstringfield_default(L, index, "spawn_by", "air");
+			dsimple->deco_height     = getintfield_default(L, index, "height", 1);
+			dsimple->deco_height_max = getintfield_default(L, index, "height_max", 0);
+			dsimple->nspawnby        = getintfield_default(L, index, "num_spawn_by", -1);
+			
+			lua_getfield(L, index, "decoration");
+			if (lua_istable(L, -1)) {
+				lua_pushnil(L);
+				while (lua_next(L, -2)) {
+					const char *s = lua_tostring(L, -1);
+					std::string str(s);
+					dsimple->decolist_names.push_back(str);
+
+					lua_pop(L, 1);
+				}
+			} else if (lua_isstring(L, -1)) {
+				dsimple->deco_name  = std::string(lua_tostring(L, -1));
+			} else {
+				dsimple->deco_name = std::string("air");
+			}
+			lua_pop(L, 1);
+			
+			if (dsimple->deco_height <= 0) {
+				errorstream << "register_decoration: simple decoration height"
+					" must be greater than 0" << std::endl;
+				delete dsimple;
+				return 0;
+			}
+
+			break; }
+		case DECO_SCHEMATIC: {
+			//DecoSchematic *decoschematic = (DecoSchematic *)deco;
+			
+			break; }
+		case DECO_LSYSTEM: {
+			//DecoLSystem *decolsystem = (DecoLSystem *)deco;
+		
+			break; }
+	}
+	
+	if (deco->divlen <= 0) {
+		errorstream << "register_decoration: divlen must be "
+			"greater than 0" << std::endl;
+		delete deco;
+		return 0;
+	}
+	
+	emerge->decorations.push_back(deco);
+
+	verbosestream << "register_decoration: decoration '" << deco->getName()
+		<< "' registered" << std::endl;
+	return 0;
+}
+
+
 ModApiBasic modapibasic_prototype;

src/script/lua_api/luaapi.h

@@ -45,9 +45,6 @@ private:
 	// get_server_status()
 	static int l_get_server_status(lua_State *L);
 
-	// register_biome_groups({frequencies})
-	static int l_register_biome_groups(lua_State *L);
-
 	// register_biome({lots of stuff})
 	static int l_register_biome(lua_State *L);
 
@@ -130,9 +127,15 @@ private:
 	// rollback_revert_actions_by(actor, seconds) -> bool, log messages
 	static int l_rollback_revert_actions_by(lua_State *L);
 
+	// register_ore(oredesc)
 	static int l_register_ore(lua_State *L);
 	
+	// register_decoration(deco)
+	static int l_register_decoration(lua_State *L);
+
 	static struct EnumString es_OreType[];
+	static struct EnumString es_DecorationType[];
+
 };