X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapgen.cpp;h=c2256cedbe5d1e1856ef64664a92a4c000974079;hb=392485aa454e871566a67afc61e11331f9d27397;hp=d7b6e56c440bb5e659a74a3d9c76c5138da143e0;hpb=3560f0de082a8950a84e2e866981f8bdfd05428a;p=minetest.git

diff --git a/src/mapgen.cpp b/src/mapgen.cpp
index d7b6e56c4..c2256cedb 100644
--- a/src/mapgen.cpp
+++ b/src/mapgen.cpp
@@ -19,13 +19,14 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include "mapgen.h"
 #include "voxel.h"
-#include "content_mapnode.h"
 #include "noise.h"
 #include "mapblock.h"
 #include "map.h"
 #include "mineral.h"
 //#include "serverobject.h"
 #include "content_sao.h"
+#include "nodedef.h"
+#include "content_mapnode.h" // For content_mapnode_get_new_name
 
 namespace mapgen
 {
@@ -67,8 +68,8 @@ static s16 find_ground_level_clever(VoxelManipulator &vmanip, v2s16 p2d)
 	{
 		MapNode &n = vmanip.m_data[i];
 		if(content_walkable(n.d)
-				&& n.d != CONTENT_TREE
-				&& n.d != CONTENT_LEAVES)
+				&& n.getContent() != LEGN(ndef, "CONTENT_TREE")
+				&& n.getContent() != LEGN(ndef, "CONTENT_LEAVES"))
 			break;
 
 		vmanip.m_area.add_y(em, i, -1);
@@ -80,12 +81,14 @@ static s16 find_ground_level_clever(VoxelManipulator &vmanip, v2s16 p2d)
 }
 #endif
 
-static void make_tree(VoxelManipulator &vmanip, v3s16 p0)
+void make_tree(ManualMapVoxelManipulator &vmanip, v3s16 p0,
+		bool is_apple_tree, INodeDefManager *ndef)
 {
-	MapNode treenode(CONTENT_TREE);
-	MapNode leavesnode(CONTENT_LEAVES);
-
-	s16 trunk_h = myrand_range(3, 6);
+	MapNode treenode(LEGN(ndef, "CONTENT_TREE"));
+	MapNode leavesnode(LEGN(ndef, "CONTENT_LEAVES"));
+	MapNode applenode(LEGN(ndef, "CONTENT_APPLE"));
+	
+	s16 trunk_h = myrand_range(4, 5);
 	v3s16 p1 = p0;
 	for(s16 ii=0; ii<trunk_h; ii++)
 	{
@@ -97,7 +100,7 @@ static void make_tree(VoxelManipulator &vmanip, v3s16 p0)
 	// p1 is now the last piece of the trunk
 	p1.Y -= 1;
 
-	VoxelArea leaves_a(v3s16(-2,-2,-2), v3s16(2,2,2));
+	VoxelArea leaves_a(v3s16(-2,-1,-2), v3s16(2,2,2));
 	//SharedPtr<u8> leaves_d(new u8[leaves_a.getVolume()]);
 	Buffer<u8> leaves_d(leaves_a.getVolume());
 	for(s32 i=0; i<leaves_a.getVolume(); i++)
@@ -143,8 +146,101 @@ static void make_tree(VoxelManipulator &vmanip, v3s16 p0)
 		if(vmanip.m_area.contains(p) == false)
 			continue;
 		u32 vi = vmanip.m_area.index(p);
-		if(vmanip.m_data[vi].d != CONTENT_AIR
-				&& vmanip.m_data[vi].d != CONTENT_IGNORE)
+		if(vmanip.m_data[vi].getContent() != CONTENT_AIR
+				&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
+			continue;
+		u32 i = leaves_a.index(x,y,z);
+		if(leaves_d[i] == 1) {
+			bool is_apple = myrand_range(0,99) < 10;
+			if(is_apple_tree && is_apple) {
+				vmanip.m_data[vi] = applenode;
+			} else {
+				vmanip.m_data[vi] = leavesnode;
+			}
+		}
+	}
+}
+
+static void make_jungletree(VoxelManipulator &vmanip, v3s16 p0,
+		INodeDefManager *ndef)
+{
+	MapNode treenode(LEGN(ndef, "CONTENT_JUNGLETREE"));
+	MapNode leavesnode(LEGN(ndef, "CONTENT_LEAVES"));
+
+	for(s16 x=-1; x<=1; x++)
+	for(s16 z=-1; z<=1; z++)
+	{
+		if(myrand_range(0, 2) == 0)
+			continue;
+		v3s16 p1 = p0 + v3s16(x,0,z);
+		v3s16 p2 = p0 + v3s16(x,-1,z);
+		if(vmanip.m_area.contains(p2)
+				&& vmanip.m_data[vmanip.m_area.index(p2)] == CONTENT_AIR)
+			vmanip.m_data[vmanip.m_area.index(p2)] = treenode;
+		else if(vmanip.m_area.contains(p1))
+			vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
+	}
+
+	s16 trunk_h = myrand_range(8, 12);
+	v3s16 p1 = p0;
+	for(s16 ii=0; ii<trunk_h; ii++)
+	{
+		if(vmanip.m_area.contains(p1))
+			vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
+		p1.Y++;
+	}
+
+	// p1 is now the last piece of the trunk
+	p1.Y -= 1;
+
+	VoxelArea leaves_a(v3s16(-3,-2,-3), v3s16(3,2,3));
+	//SharedPtr<u8> leaves_d(new u8[leaves_a.getVolume()]);
+	Buffer<u8> leaves_d(leaves_a.getVolume());
+	for(s32 i=0; i<leaves_a.getVolume(); i++)
+		leaves_d[i] = 0;
+
+	// Force leaves at near the end of the trunk
+	{
+		s16 d = 1;
+		for(s16 z=-d; z<=d; z++)
+		for(s16 y=-d; y<=d; y++)
+		for(s16 x=-d; x<=d; x++)
+		{
+			leaves_d[leaves_a.index(v3s16(x,y,z))] = 1;
+		}
+	}
+
+	// Add leaves randomly
+	for(u32 iii=0; iii<30; iii++)
+	{
+		s16 d = 1;
+
+		v3s16 p(
+			myrand_range(leaves_a.MinEdge.X, leaves_a.MaxEdge.X-d),
+			myrand_range(leaves_a.MinEdge.Y, leaves_a.MaxEdge.Y-d),
+			myrand_range(leaves_a.MinEdge.Z, leaves_a.MaxEdge.Z-d)
+		);
+
+		for(s16 z=0; z<=d; z++)
+		for(s16 y=0; y<=d; y++)
+		for(s16 x=0; x<=d; x++)
+		{
+			leaves_d[leaves_a.index(p+v3s16(x,y,z))] = 1;
+		}
+	}
+
+	// Blit leaves to vmanip
+	for(s16 z=leaves_a.MinEdge.Z; z<=leaves_a.MaxEdge.Z; z++)
+	for(s16 y=leaves_a.MinEdge.Y; y<=leaves_a.MaxEdge.Y; y++)
+	for(s16 x=leaves_a.MinEdge.X; x<=leaves_a.MaxEdge.X; x++)
+	{
+		v3s16 p(x,y,z);
+		p += p1;
+		if(vmanip.m_area.contains(p) == false)
+			continue;
+		u32 vi = vmanip.m_area.index(p);
+		if(vmanip.m_data[vi].getContent() != CONTENT_AIR
+				&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
 			continue;
 		u32 i = leaves_a.index(x,y,z);
 		if(leaves_d[i] == 1)
@@ -152,9 +248,10 @@ static void make_tree(VoxelManipulator &vmanip, v3s16 p0)
 	}
 }
 
-void make_papyrus(VoxelManipulator &vmanip, v3s16 p0)
+void make_papyrus(VoxelManipulator &vmanip, v3s16 p0,
+		INodeDefManager *ndef)
 {
-	MapNode papyrusnode(CONTENT_PAPYRUS);
+	MapNode papyrusnode(LEGN(ndef, "CONTENT_PAPYRUS"));
 
 	s16 trunk_h = myrand_range(2, 3);
 	v3s16 p1 = p0;
@@ -166,9 +263,10 @@ void make_papyrus(VoxelManipulator &vmanip, v3s16 p0)
 	}
 }
 
-void make_cactus(VoxelManipulator &vmanip, v3s16 p0)
+void make_cactus(VoxelManipulator &vmanip, v3s16 p0,
+		INodeDefManager *ndef)
 {
-	MapNode cactusnode(CONTENT_CACTUS);
+	MapNode cactusnode(LEGN(ndef, "CONTENT_CACTUS"));
 
 	s16 trunk_h = 3;
 	v3s16 p1 = p0;
@@ -183,7 +281,7 @@ void make_cactus(VoxelManipulator &vmanip, v3s16 p0)
 #if 0
 static void make_randomstone(VoxelManipulator &vmanip, v3s16 p0)
 {
-	MapNode stonenode(CONTENT_STONE);
+	MapNode stonenode(LEGN(ndef, "CONTENT_STONE"));
 
 	s16 size = myrand_range(3, 6);
 	
@@ -251,8 +349,8 @@ static void make_randomstone(VoxelManipulator &vmanip, v3s16 p0)
 		if(vmanip.m_area.contains(p) == false)
 			continue;
 		u32 vi = vmanip.m_area.index(p);
-		if(vmanip.m_data[vi].d != CONTENT_AIR
-				&& vmanip.m_data[vi].d != CONTENT_IGNORE)
+		if(vmanip.m_data[vi].getContent() != CONTENT_AIR
+				&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
 			continue;
 		u32 i = stone_a.index(x,y,z);
 		if(stone_d[i] == 1)
@@ -264,7 +362,7 @@ static void make_randomstone(VoxelManipulator &vmanip, v3s16 p0)
 #if 0
 static void make_largestone(VoxelManipulator &vmanip, v3s16 p0)
 {
-	MapNode stonenode(CONTENT_STONE);
+	MapNode stonenode(LEGN(ndef, "CONTENT_STONE"));
 
 	s16 size = myrand_range(8, 16);
 	
@@ -335,8 +433,8 @@ static void make_largestone(VoxelManipulator &vmanip, v3s16 p0)
 		if(vmanip.m_area.contains(p) == false)
 			continue;
 		u32 vi = vmanip.m_area.index(p);
-		/*if(vmanip.m_data[vi].d != CONTENT_AIR
-				&& vmanip.m_data[vi].d != CONTENT_IGNORE)
+		/*if(vmanip.m_data[vi].getContent() != CONTENT_AIR
+				&& vmanip.m_data[vi].getContent() != CONTENT_IGNORE)
 			continue;*/
 		u32 i = stone_a.index(x,y,z);
 		if(stone_d[i] == 1)
@@ -354,7 +452,8 @@ static void make_largestone(VoxelManipulator &vmanip, v3s16 p0)
 #define VMANIP_FLAG_DUNGEON_UNTOUCHABLE (\
 		VMANIP_FLAG_DUNGEON_INSIDE|VMANIP_FLAG_DUNGEON_PRESERVE)
 
-static void make_room1(VoxelManipulator &vmanip, v3s16 roomsize, v3s16 roomplace)
+static void make_room1(VoxelManipulator &vmanip, v3s16 roomsize, v3s16 roomplace,
+		INodeDefManager *ndef)
 {
 	// Make +-X walls
 	for(s16 z=0; z<roomsize.Z; z++)
@@ -367,7 +466,7 @@ static void make_room1(VoxelManipulator &vmanip, v3s16 roomsize, v3s16 roomplace
 			u32 vi = vmanip.m_area.index(p);
 			if(vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
 				continue;
-			vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
+			vmanip.m_data[vi] = MapNode(LEGN(ndef, "CONTENT_COBBLE"));
 		}
 		{
 			v3s16 p = roomplace + v3s16(roomsize.X-1,y,z);
@@ -376,7 +475,7 @@ static void make_room1(VoxelManipulator &vmanip, v3s16 roomsize, v3s16 roomplace
 			u32 vi = vmanip.m_area.index(p);
 			if(vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
 				continue;
-			vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
+			vmanip.m_data[vi] = MapNode(LEGN(ndef, "CONTENT_COBBLE"));
 		}
 	}
 	
@@ -391,7 +490,7 @@ static void make_room1(VoxelManipulator &vmanip, v3s16 roomsize, v3s16 roomplace
 			u32 vi = vmanip.m_area.index(p);
 			if(vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
 				continue;
-			vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
+			vmanip.m_data[vi] = MapNode(LEGN(ndef, "CONTENT_COBBLE"));
 		}
 		{
 			v3s16 p = roomplace + v3s16(x,y,roomsize.Z-1);
@@ -400,7 +499,7 @@ static void make_room1(VoxelManipulator &vmanip, v3s16 roomsize, v3s16 roomplace
 			u32 vi = vmanip.m_area.index(p);
 			if(vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
 				continue;
-			vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
+			vmanip.m_data[vi] = MapNode(LEGN(ndef, "CONTENT_COBBLE"));
 		}
 	}
 	
@@ -415,7 +514,7 @@ static void make_room1(VoxelManipulator &vmanip, v3s16 roomsize, v3s16 roomplace
 			u32 vi = vmanip.m_area.index(p);
 			if(vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
 				continue;
-			vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
+			vmanip.m_data[vi] = MapNode(LEGN(ndef, "CONTENT_COBBLE"));
 		}
 		{
 			v3s16 p = roomplace + v3s16(x,roomsize.Y-1,z);
@@ -424,7 +523,7 @@ static void make_room1(VoxelManipulator &vmanip, v3s16 roomsize, v3s16 roomplace
 			u32 vi = vmanip.m_area.index(p);
 			if(vmanip.m_flags[vi] & VMANIP_FLAG_DUNGEON_UNTOUCHABLE)
 				continue;
-			vmanip.m_data[vi] = MapNode(CONTENT_COBBLE);
+			vmanip.m_data[vi] = MapNode(LEGN(ndef, "CONTENT_COBBLE"));
 		}
 	}
 	
@@ -460,17 +559,19 @@ static void make_fill(VoxelManipulator &vmanip, v3s16 place, v3s16 size,
 	}
 }
 
-static void make_hole1(VoxelManipulator &vmanip, v3s16 place)
+static void make_hole1(VoxelManipulator &vmanip, v3s16 place,
+		INodeDefManager *ndef)
 {
 	make_fill(vmanip, place, v3s16(1,2,1), 0, MapNode(CONTENT_AIR),
 			VMANIP_FLAG_DUNGEON_INSIDE);
 }
 
-static void make_door1(VoxelManipulator &vmanip, v3s16 doorplace, v3s16 doordir)
+static void make_door1(VoxelManipulator &vmanip, v3s16 doorplace, v3s16 doordir,
+		INodeDefManager *ndef)
 {
-	make_hole1(vmanip, doorplace);
+	make_hole1(vmanip, doorplace, ndef);
 	// Place torch (for testing)
-	//vmanip.m_data[vmanip.m_area.index(doorplace)] = MapNode(CONTENT_TORCH);
+	//vmanip.m_data[vmanip.m_area.index(doorplace)] = MapNode(LEGN(ndef, "CONTENT_TORCH"));
 }
 
 static v3s16 rand_ortho_dir(PseudoRandom &random)
@@ -521,9 +622,9 @@ static v3s16 random_turn(PseudoRandom &random, v3s16 olddir)
 
 static void make_corridor(VoxelManipulator &vmanip, v3s16 doorplace,
 		v3s16 doordir, v3s16 &result_place, v3s16 &result_dir,
-		PseudoRandom &random)
+		PseudoRandom &random, INodeDefManager *ndef)
 {
-	make_hole1(vmanip, doorplace);
+	make_hole1(vmanip, doorplace, ndef);
 	v3s16 p0 = doorplace;
 	v3s16 dir = doordir;
 	u32 length;
@@ -544,9 +645,9 @@ static void make_corridor(VoxelManipulator &vmanip, v3s16 doorplace,
 			p.Y += make_stairs;
 
 		/*// If already empty
-		if(vmanip.getNodeNoExNoEmerge(p).d
+		if(vmanip.getNodeNoExNoEmerge(p).getContent()
 				== CONTENT_AIR
-		&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).d
+		&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).getContent()
 				== CONTENT_AIR)
 		{
 		}*/
@@ -557,7 +658,7 @@ static void make_corridor(VoxelManipulator &vmanip, v3s16 doorplace,
 			if(make_stairs)
 			{
 				make_fill(vmanip, p+v3s16(-1,-1,-1), v3s16(3,5,3),
-						VMANIP_FLAG_DUNGEON_UNTOUCHABLE, MapNode(CONTENT_COBBLE), 0);
+						VMANIP_FLAG_DUNGEON_UNTOUCHABLE, MapNode(LEGN(ndef, "CONTENT_COBBLE")), 0);
 				make_fill(vmanip, p, v3s16(1,2,1), 0, MapNode(CONTENT_AIR),
 						VMANIP_FLAG_DUNGEON_INSIDE);
 				make_fill(vmanip, p-dir, v3s16(1,2,1), 0, MapNode(CONTENT_AIR),
@@ -566,8 +667,8 @@ static void make_corridor(VoxelManipulator &vmanip, v3s16 doorplace,
 			else
 			{
 				make_fill(vmanip, p+v3s16(-1,-1,-1), v3s16(3,4,3),
-						VMANIP_FLAG_DUNGEON_UNTOUCHABLE, MapNode(CONTENT_COBBLE), 0);
-				make_hole1(vmanip, p);
+						VMANIP_FLAG_DUNGEON_UNTOUCHABLE, MapNode(LEGN(ndef, "CONTENT_COBBLE")), 0);
+				make_hole1(vmanip, p, ndef);
 				/*make_fill(vmanip, p, v3s16(1,2,1), 0, MapNode(CONTENT_AIR),
 						VMANIP_FLAG_DUNGEON_INSIDE);*/
 			}
@@ -606,10 +707,12 @@ class RoomWalker
 {
 public:
 
-	RoomWalker(VoxelManipulator &vmanip_, v3s16 pos, PseudoRandom &random):
+	RoomWalker(VoxelManipulator &vmanip_, v3s16 pos, PseudoRandom &random,
+			INodeDefManager *ndef):
 			vmanip(vmanip_),
 			m_pos(pos),
-			m_random(random)
+			m_random(random),
+			m_ndef(ndef)
 	{
 		randomizeDir();
 	}
@@ -642,10 +745,10 @@ class RoomWalker
 				randomizeDir();
 				continue;
 			}
-			if(vmanip.getNodeNoExNoEmerge(p).d
-					== CONTENT_COBBLE
-			&& vmanip.getNodeNoExNoEmerge(p1).d
-					== CONTENT_COBBLE)
+			if(vmanip.getNodeNoExNoEmerge(p).getContent()
+					== LEGN(m_ndef, "CONTENT_COBBLE")
+			&& vmanip.getNodeNoExNoEmerge(p1).getContent()
+					== LEGN(m_ndef, "CONTENT_COBBLE"))
 			{
 				// Found wall, this is a good place!
 				result_place = p;
@@ -658,26 +761,26 @@ class RoomWalker
 				Determine where to move next
 			*/
 			// Jump one up if the actual space is there
-			if(vmanip.getNodeNoExNoEmerge(p+v3s16(0,0,0)).d
-					== CONTENT_COBBLE
-			&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).d
-					== CONTENT_AIR
-			&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,2,0)).d
-					== CONTENT_AIR)
+			if(vmanip.getNodeNoExNoEmerge(p+v3s16(0,0,0)).getContent()
+					== LEGN(m_ndef, "CONTENT_COBBLE")
+			&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).getContent()
+					== LEGN(m_ndef, "CONTENT_AIR")
+			&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,2,0)).getContent()
+					== LEGN(m_ndef, "CONTENT_AIR"))
 				p += v3s16(0,1,0);
 			// Jump one down if the actual space is there
-			if(vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).d
-					== CONTENT_COBBLE
-			&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,0,0)).d
-					== CONTENT_AIR
-			&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,-1,0)).d
-					== CONTENT_AIR)
+			if(vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).getContent()
+					== LEGN(m_ndef, "CONTENT_COBBLE")
+			&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,0,0)).getContent()
+					== LEGN(m_ndef, "CONTENT_AIR")
+			&& vmanip.getNodeNoExNoEmerge(p+v3s16(0,-1,0)).getContent()
+					== LEGN(m_ndef, "CONTENT_AIR"))
 				p += v3s16(0,-1,0);
 			// Check if walking is now possible
-			if(vmanip.getNodeNoExNoEmerge(p).d
-					!= CONTENT_AIR
-			|| vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).d
-					!= CONTENT_AIR)
+			if(vmanip.getNodeNoExNoEmerge(p).getContent()
+					!= LEGN(m_ndef, "CONTENT_AIR")
+			|| vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).getContent()
+					!= LEGN(m_ndef, "CONTENT_AIR"))
 			{
 				// Cannot continue walking here
 				randomizeDir();
@@ -763,9 +866,11 @@ class RoomWalker
 	v3s16 m_pos;
 	v3s16 m_dir;
 	PseudoRandom &m_random;
+	INodeDefManager *m_ndef;
 };
 
-static void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random)
+static void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random,
+		INodeDefManager *ndef)
 {
 	v3s16 areasize = vmanip.m_area.getExtent();
 	v3s16 roomsize;
@@ -798,7 +903,7 @@ static void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random)
 				fits = false;
 				break;
 			}
-			if(vmanip.m_data[vi].d == CONTENT_IGNORE)
+			if(vmanip.m_data[vi].getContent() == CONTENT_IGNORE)
 			{
 				fits = false;
 				break;
@@ -822,12 +927,12 @@ static void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random)
 	for(u32 i=0; i<room_count; i++)
 	{
 		// Make a room to the determined place
-		make_room1(vmanip, roomsize, roomplace);
+		make_room1(vmanip, roomsize, roomplace, ndef);
 		
 		v3s16 room_center = roomplace + v3s16(roomsize.X/2,1,roomsize.Z/2);
 
 		// Place torch at room center (for testing)
-		//vmanip.m_data[vmanip.m_area.index(room_center)] = MapNode(CONTENT_TORCH);
+		//vmanip.m_data[vmanip.m_area.index(room_center)] = MapNode(LEGN(ndef, "CONTENT_TORCH"));
 
 		// Quit if last room
 		if(i == room_count-1)
@@ -852,7 +957,7 @@ static void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random)
 		}
 		
 		// Create walker and find a place for a door
-		RoomWalker walker(vmanip, walker_start_place, random);
+		RoomWalker walker(vmanip, walker_start_place, random, ndef);
 		v3s16 doorplace;
 		v3s16 doordir;
 		bool r = walker.findPlaceForDoor(doorplace, doordir);
@@ -861,7 +966,7 @@ static void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random)
 		
 		if(random.range(0,1)==0)
 			// Make the door
-			make_door1(vmanip, doorplace, doordir);
+			make_door1(vmanip, doorplace, doordir, ndef);
 		else
 			// Don't actually make a door
 			doorplace -= doordir;
@@ -870,7 +975,7 @@ static void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random)
 		v3s16 corridor_end;
 		v3s16 corridor_end_dir;
 		make_corridor(vmanip, doorplace, doordir, corridor_end,
-				corridor_end_dir, random);
+				corridor_end_dir, random, ndef);
 		
 		// Find a place for a random sized room
 		roomsize = v3s16(random.range(4,8),random.range(4,6),random.range(4,8));
@@ -882,7 +987,7 @@ static void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random)
 
 		if(random.range(0,1)==0)
 			// Make the door
-			make_door1(vmanip, doorplace, doordir);
+			make_door1(vmanip, doorplace, doordir, ndef);
 		else
 			// Don't actually make a door
 			roomplace -= doordir;
@@ -890,6 +995,41 @@ static void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random)
 	}
 }
 
+static void make_nc(VoxelManipulator &vmanip, PseudoRandom &random,
+		INodeDefManager *ndef)
+{
+	v3s16 dir;
+	u8 facedir_i = 0;
+	s32 r = random.range(0, 3);
+	if(r == 0){
+		dir = v3s16( 1, 0, 0);
+		facedir_i = 3;
+	}
+	if(r == 1){
+		dir = v3s16(-1, 0, 0);
+		facedir_i = 1;
+	}
+	if(r == 2){
+		dir = v3s16( 0, 0, 1);
+		facedir_i = 2;
+	}
+	if(r == 3){
+		dir = v3s16( 0, 0,-1);
+		facedir_i = 0;
+	}
+	v3s16 p = vmanip.m_area.MinEdge + v3s16(
+			16+random.range(0,15),
+			16+random.range(0,15),
+			16+random.range(0,15));
+	vmanip.m_data[vmanip.m_area.index(p)] = MapNode(LEGN(ndef, "CONTENT_NC"), facedir_i);
+	u32 length = random.range(3,15);
+	for(u32 j=0; j<length; j++)
+	{
+		p -= dir;
+		vmanip.m_data[vmanip.m_area.index(p)] = MapNode(LEGN(ndef, "CONTENT_NC_RB"));
+	}
+}
+
 /*
 	Noise functions. Make sure seed is mangled differently in each one.
 */
@@ -1004,13 +1144,26 @@ double tree_amount_2d(u64 seed, v2s16 p)
 	double noise = noise2d_perlin(
 			0.5+(float)p.X/125, 0.5+(float)p.Y/125,
 			seed+2, 4, 0.66);
-	double zeroval = -0.35;
+	double zeroval = -0.39;
 	if(noise < zeroval)
 		return 0;
 	else
 		return 0.04 * (noise-zeroval) / (1.0-zeroval);
 }
 
+double surface_humidity_2d(u64 seed, v2s16 p)
+{
+	double noise = noise2d_perlin(
+			0.5+(float)p.X/500, 0.5+(float)p.Y/500,
+			seed+72384, 4, 0.66);
+	noise = (noise + 1.0)/2.0;
+	if(noise < 0.0)
+		noise = 0.0;
+	if(noise > 1.0)
+		noise = 1.0;
+	return noise;
+}
+
 #if 0
 double randomstone_amount_2d(u64 seed, v2s16 p)
 {
@@ -1265,6 +1418,7 @@ bool get_have_sand(u64 seed, v2s16 p2d)
 */
 void add_random_objects(MapBlock *block)
 {
+#if 0
 	for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
 	for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
 	{
@@ -1273,11 +1427,11 @@ void add_random_objects(MapBlock *block)
 		{
 			v3s16 p(x0,y0,z0);
 			MapNode n = block->getNodeNoEx(p);
-			if(n.d == CONTENT_IGNORE)
+			if(n.getContent() == CONTENT_IGNORE)
 				continue;
-			if(content_features(n.d).liquid_type != LIQUID_NONE)
+			if(data->nodedef->get(n)->liquid_type != LIQUID_NONE)
 				continue;
-			if(content_features(n.d).walkable)
+			if(data->nodedef->get(n)->walkable)
 			{
 				last_node_walkable = true;
 				continue;
@@ -1285,7 +1439,7 @@ void add_random_objects(MapBlock *block)
 			if(last_node_walkable)
 			{
 				// If block contains light information
-				if(content_features(n.d).param_type == CPT_LIGHT)
+				if(content_features(n).param_type == CPT_LIGHT)
 				{
 					if(n.getLight(LIGHTBANK_DAY) <= 3)
 					{
@@ -1324,17 +1478,23 @@ void add_random_objects(MapBlock *block)
 			last_node_walkable = false;
 		}
 	}
-	block->setChangedFlag();
+	block->raiseModified(MOD_STATE_WRITE_NEEDED, "mapgen::add_random_objects");
+#endif
 }
 
 void make_block(BlockMakeData *data)
 {
 	if(data->no_op)
 	{
-		dstream<<"makeBlock: no-op"<<std::endl;
+		//dstream<<"makeBlock: no-op"<<std::endl;
 		return;
 	}
 
+	assert(data->vmanip);
+	assert(data->nodedef);
+
+	INodeDefManager *ndef = data->nodedef;
+
 	v3s16 blockpos = data->blockpos;
 	
 	/*dstream<<"makeBlock(): ("<<blockpos.X<<","<<blockpos.Y<<","
@@ -1374,7 +1534,7 @@ void make_block(BlockMakeData *data)
 	// Maximum amount of ground above the bottom of the central block
 	s16 maximum_ground_depth = maximum_groundlevel - node_min.Y;
 
-	#if 0
+	#if 1
 	/*
 		Special case for high air or water: Just fill with air and water.
 	*/
@@ -1392,10 +1552,10 @@ void make_block(BlockMakeData *data)
 				for(s16 y=node_min.Y; y<=node_max.Y; y++)
 				{
 					// Only modify places that have no content
-					if(vmanip.m_data[i].d == CONTENT_IGNORE)
+					if(vmanip.m_data[i].getContent() == CONTENT_IGNORE)
 					{
 						if(y <= WATER_LEVEL)
-							vmanip.m_data[i] = MapNode(CONTENT_WATERSOURCE);
+							vmanip.m_data[i] = MapNode(LEGN(ndef, "CONTENT_WATERSOURCE"));
 						else
 							vmanip.m_data[i] = MapNode(CONTENT_AIR);
 					}
@@ -1419,7 +1579,7 @@ void make_block(BlockMakeData *data)
 	/*
 		Create a block-specific seed
 	*/
-	u32 blockseed = (u32)(data->seed%0x100000000) + full_node_min.Z*38134234
+	u32 blockseed = (u32)(data->seed%0x100000000ULL) + full_node_min.Z*38134234
 			+ full_node_min.Y*42123 + full_node_min.X*23;
 	
 	/*
@@ -1481,7 +1641,27 @@ void make_block(BlockMakeData *data)
 				maxpos_f.X, maxpos_f.Y+5, maxpos_f.Z,
 				sl.X, sl.Y, sl.Z);
 	}
-	
+
+	/*
+		Cache some ground type values for speed
+	*/
+
+// Creates variables c_name=id and n_name=node
+#define CONTENT_VARIABLE(ndef, name)\
+	content_t c_##name = ndef->getId(#name);\
+	MapNode n_##name(c_##name);
+
+	CONTENT_VARIABLE(ndef, stone);
+	CONTENT_VARIABLE(ndef, water_source);
+	CONTENT_VARIABLE(ndef, air);
+	CONTENT_VARIABLE(ndef, dirt);
+	CONTENT_VARIABLE(ndef, sand);
+	CONTENT_VARIABLE(ndef, gravel);
+	CONTENT_VARIABLE(ndef, lava_source);
+	CONTENT_VARIABLE(ndef, cobble);
+	CONTENT_VARIABLE(ndef, mossycobble);
+	CONTENT_VARIABLE(ndef, dirt_with_grass);
+
 	/*
 		Make base ground level
 	*/
@@ -1498,7 +1678,7 @@ void make_block(BlockMakeData *data)
 			for(s16 y=node_min.Y; y<=node_max.Y; y++)
 			{
 				// Only modify places that have no content
-				if(vmanip.m_data[i].d == CONTENT_IGNORE)
+				if(vmanip.m_data[i].getContent() == CONTENT_IGNORE)
 				{
 					// First priority: make air and water.
 					// This avoids caves inside water.
@@ -1507,14 +1687,14 @@ void make_block(BlockMakeData *data)
 							v3s16(x,y,z), data->seed) == false)
 					{
 						if(y <= WATER_LEVEL)
-							vmanip.m_data[i] = MapNode(CONTENT_WATERSOURCE);
+							vmanip.m_data[i] = n_water_source;
 						else
-							vmanip.m_data[i] = MapNode(CONTENT_AIR);
+							vmanip.m_data[i] = n_air;
 					}
 					else if(noisebuf_cave.get(x,y,z) > CAVE_NOISE_THRESHOLD)
-						vmanip.m_data[i] = MapNode(CONTENT_AIR);
+						vmanip.m_data[i] = n_air;
 					else
-						vmanip.m_data[i] = MapNode(CONTENT_STONE);
+						vmanip.m_data[i] = n_stone;
 				}
 			
 				data->vmanip->m_area.add_y(em, i, 1);
@@ -1543,9 +1723,9 @@ void make_block(BlockMakeData *data)
 				{
 					v3s16 p = v3s16(x,y,z) + g_27dirs[i];
 					u32 vi = vmanip.m_area.index(p);
-					if(vmanip.m_data[vi].d == CONTENT_STONE)
+					if(vmanip.m_data[vi].getContent() == c_stone)
 						if(mineralrandom.next()%8 == 0)
-							vmanip.m_data[vi] = MapNode(CONTENT_MESE);
+							vmanip.m_data[vi] = MapNode(LEGN(ndef, "CONTENT_MESE"));
 				}
 					
 			}
@@ -1563,34 +1743,34 @@ void make_block(BlockMakeData *data)
 				s16 y = mineralrandom.range(node_min.Y+1, node_max.Y-1);
 				s16 z = mineralrandom.range(node_min.Z+1, node_max.Z-1);
 
-				u8 base_content = CONTENT_STONE;
+				u8 base_content = LEGN(ndef, "CONTENT_STONE");
 				MapNode new_content(CONTENT_IGNORE);
 				u32 sparseness = 6;
 
 				if(noisebuf_ground_crumbleness.get(x,y+5,z) < -0.1)
 				{
-					new_content = MapNode(CONTENT_STONE, MINERAL_COAL);
+					new_content = MapNode(LEGN(ndef, "CONTENT_STONE"), MINERAL_COAL);
 				}
 				else
 				{
 					if(noisebuf_ground_wetness.get(x,y+5,z) > 0.0)
-						new_content = MapNode(CONTENT_STONE, MINERAL_IRON);
+						new_content = MapNode(LEGN(ndef, "CONTENT_STONE"), MINERAL_IRON);
 					/*if(noisebuf_ground_wetness.get(x,y,z) > 0.0)
-						vmanip.m_data[i] = MapNode(CONTENT_MUD);
+						vmanip.m_data[i] = MapNode(LEGN(ndef, "CONTENT_MUD"));
 					else
-						vmanip.m_data[i] = MapNode(CONTENT_SAND);*/
+						vmanip.m_data[i] = MapNode(LEGN(ndef, "CONTENT_SAND"));*/
 				}
 				/*else if(noisebuf_ground_crumbleness.get(x,y,z) > 0.1)
 				{
 				}*/
 
-				if(new_content.d != CONTENT_IGNORE)
+				if(new_content.getContent() != CONTENT_IGNORE)
 				{
 					for(u16 i=0; i<27; i++)
 					{
 						v3s16 p = v3s16(x,y,z) + g_27dirs[i];
 						u32 vi = vmanip.m_area.index(p);
-						if(vmanip.m_data[vi].d == base_content)
+						if(vmanip.m_data[vi].getContent() == base_content)
 						{
 							if(mineralrandom.next()%sparseness == 0)
 								vmanip.m_data[vi] = new_content;
@@ -1621,9 +1801,9 @@ void make_block(BlockMakeData *data)
 				{
 					v3s16 p = v3s16(x,y,z) + g_27dirs[i];
 					u32 vi = vmanip.m_area.index(p);
-					if(vmanip.m_data[vi].d == CONTENT_STONE)
+					if(vmanip.m_data[vi].getContent() == c_stone)
 						if(mineralrandom.next()%8 == 0)
-							vmanip.m_data[vi] = MapNode(CONTENT_STONE, MINERAL_COAL);
+							vmanip.m_data[vi] = MapNode(LEGN(ndef, "CONTENT_STONE"), MINERAL_COAL);
 				}
 			}
 		}
@@ -1647,9 +1827,9 @@ void make_block(BlockMakeData *data)
 				{
 					v3s16 p = v3s16(x,y,z) + g_27dirs[i];
 					u32 vi = vmanip.m_area.index(p);
-					if(vmanip.m_data[vi].d == CONTENT_STONE)
+					if(vmanip.m_data[vi].getContent() == c_stone)
 						if(mineralrandom.next()%8 == 0)
-							vmanip.m_data[vi] = MapNode(CONTENT_STONE, MINERAL_IRON);
+							vmanip.m_data[vi] = MapNode(LEGN(ndef, "CONTENT_STONE"), MINERAL_IRON);
 				}
 			}
 		}
@@ -1670,19 +1850,29 @@ void make_block(BlockMakeData *data)
 			u32 i = vmanip.m_area.index(v3s16(p2d.X, node_max.Y, p2d.Y));
 			for(s16 y=node_max.Y; y>=node_min.Y; y--)
 			{
-				if(vmanip.m_data[i].d == CONTENT_STONE)
+				if(vmanip.m_data[i].getContent() == c_stone)
 				{
 					if(noisebuf_ground_crumbleness.get(x,y,z) > 1.3)
 					{
 						if(noisebuf_ground_wetness.get(x,y,z) > 0.0)
-							vmanip.m_data[i] = MapNode(CONTENT_MUD);
+							vmanip.m_data[i] = n_dirt;
 						else
-							vmanip.m_data[i] = MapNode(CONTENT_SAND);
+							vmanip.m_data[i] = n_sand;
 					}
 					else if(noisebuf_ground_crumbleness.get(x,y,z) > 0.7)
 					{
 						if(noisebuf_ground_wetness.get(x,y,z) < -0.6)
-							vmanip.m_data[i] = MapNode(CONTENT_GRAVEL);
+							vmanip.m_data[i] = n_gravel;
+					}
+					else if(noisebuf_ground_crumbleness.get(x,y,z) <
+							-3.0 + MYMIN(0.1 * sqrt((float)MYMAX(0, -y)), 1.5))
+					{
+						vmanip.m_data[i] = n_lava_source;
+						for(s16 x1=-1; x1<=1; x1++)
+						for(s16 y1=-1; y1<=1; y1++)
+						for(s16 z1=-1; z1<=1; z1++)
+							data->transforming_liquid.push_back(
+									v3s16(p2d.X+x1, y+y1, p2d.Y+z1));
 					}
 				}
 
@@ -1722,9 +1912,9 @@ void make_block(BlockMakeData *data)
 				u32 i = vmanip.m_area.index(v3s16(p2d.X, full_node_max.Y, p2d.Y));
 				for(s16 y=full_node_max.Y; y>=full_node_min.Y; y--)
 				{
-					if(vmanip.m_data[i].d == CONTENT_AIR)
+					if(vmanip.m_data[i].getContent() == CONTENT_AIR)
 						vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON_PRESERVE;
-					else if(vmanip.m_data[i].d == CONTENT_WATERSOURCE)
+					else if(vmanip.m_data[i].getContent() == c_water_source)
 						vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON_PRESERVE;
 					data->vmanip->m_area.add_y(em, i, -1);
 				}
@@ -1734,7 +1924,7 @@ void make_block(BlockMakeData *data)
 		PseudoRandom random(blockseed+2);
 
 		// Add it
-		make_dungeon1(vmanip, random);
+		make_dungeon1(vmanip, random, ndef);
 		
 		// Convert some cobble to mossy cobble
 		for(s16 x=full_node_min.X; x<=full_node_max.X; x++)
@@ -1755,23 +1945,34 @@ void make_block(BlockMakeData *data)
 					double d = noise3d_perlin((float)x/2.5,
 							(float)y/2.5,(float)z/2.5,
 							blockseed, 2, 1.4);
-					if(vmanip.m_data[i].d == CONTENT_COBBLE)
+					if(vmanip.m_data[i].getContent() == c_cobble)
 					{
 						if(d < wetness/3.0)
 						{
-							vmanip.m_data[i].d = CONTENT_MOSSYCOBBLE;
+							vmanip.m_data[i].setContent(c_mossycobble);
 						}
 					}
 					/*else if(vmanip.m_flags[i] & VMANIP_FLAG_DUNGEON_INSIDE)
 					{
 						if(wetness > 1.2)
-							vmanip.m_data[i].d = CONTENT_MUD;
+							vmanip.m_data[i].setContent(LEGN(ndef, "CONTENT_MUD"));
 					}*/
 					data->vmanip->m_area.add_y(em, i, -1);
 				}
 			}
 		}
 	}
+
+	/*
+		Add NC
+	*/
+	{
+		PseudoRandom ncrandom(blockseed+9324342);
+		if(ncrandom.range(0, 1000) == 0 && blockpos.Y <= -3)
+		{
+			make_nc(vmanip, ncrandom, ndef);
+		}
+	}
 	
 	/*
 		Add top and bottom side of water to transforming_liquid queue
@@ -1791,7 +1992,7 @@ void make_block(BlockMakeData *data)
 			{
 				if(water_found == false)
 				{
-					if(vmanip.m_data[i].d == CONTENT_WATERSOURCE)
+					if(vmanip.m_data[i].getContent() == c_water_source)
 					{
 						v3s16 p = v3s16(p2d.X, y, p2d.Y);
 						data->transforming_liquid.push_back(p);
@@ -1803,7 +2004,7 @@ void make_block(BlockMakeData *data)
 					// This can be done because water_found can only
 					// turn to true and end up here after going through
 					// a single block.
-					if(vmanip.m_data[i+1].d != CONTENT_WATERSOURCE)
+					if(vmanip.m_data[i+1].getContent() != c_water_source)
 					{
 						v3s16 p = v3s16(p2d.X, y+1, p2d.Y);
 						data->transforming_liquid.push_back(p);
@@ -1840,29 +2041,22 @@ void make_block(BlockMakeData *data)
 				bool water_detected = false;
 				bool have_clay = false;
 
-				// Determine whether to have clay in the sand here
-				double claynoise = noise2d_perlin(
-						0.5+(float)p2d.X/500, 0.5+(float)p2d.Y/500,
-						data->seed+4321, 6, 0.95);
-
-				have_clay = have_sand && (claynoise > 1.25);
-
 				// Use fast index incrementing
 				s16 start_y = node_max.Y+2;
 				v3s16 em = vmanip.m_area.getExtent();
 				u32 i = vmanip.m_area.index(v3s16(p2d.X, start_y, p2d.Y));
 				for(s16 y=start_y; y>=node_min.Y-3; y--)
 				{
-					if(vmanip.m_data[i].d == CONTENT_WATERSOURCE)
+					if(vmanip.m_data[i].getContent() == c_water_source)
 						water_detected = true;
-					if(vmanip.m_data[i].d == CONTENT_AIR)
+					if(vmanip.m_data[i].getContent() == CONTENT_AIR)
 						air_detected = true;
 
-					if((vmanip.m_data[i].d == CONTENT_STONE
-							|| vmanip.m_data[i].d == CONTENT_GRASS
-							|| vmanip.m_data[i].d == CONTENT_MUD
-							|| vmanip.m_data[i].d == CONTENT_SAND
-							|| vmanip.m_data[i].d == CONTENT_GRAVEL
+					if((vmanip.m_data[i].getContent() == c_stone
+							|| vmanip.m_data[i].getContent() == c_dirt_with_grass
+							|| vmanip.m_data[i].getContent() == c_dirt
+							|| vmanip.m_data[i].getContent() == c_sand
+							|| vmanip.m_data[i].getContent() == c_gravel
 							) && (air_detected || water_detected))
 					{
 						if(current_depth == 0 && y <= WATER_LEVEL+2
@@ -1873,24 +2067,33 @@ void make_block(BlockMakeData *data)
 						{
 							if(have_sand)
 							{
+								// Determine whether to have clay in the sand here
+								double claynoise = noise2d_perlin(
+										0.5+(float)p2d.X/500, 0.5+(float)p2d.Y/500,
+										data->seed+4321, 6, 0.95) + 0.5;
+				
+								have_clay = (y <= WATER_LEVEL) && (y >= WATER_LEVEL-2) && (
+									((claynoise > 0) && (claynoise < 0.04) && (current_depth == 0)) ||
+									((claynoise > 0) && (claynoise < 0.12) && (current_depth == 1))
+									);
 								if (have_clay)
-									vmanip.m_data[i] = MapNode(CONTENT_CLAY);
+									vmanip.m_data[i] = MapNode(LEGN(ndef, "CONTENT_CLAY"));
 								else
-									vmanip.m_data[i] = MapNode(CONTENT_SAND);
+									vmanip.m_data[i] = MapNode(LEGN(ndef, "CONTENT_SAND"));
 							}
 							#if 1
 							else if(current_depth==0 && !water_detected
 									&& y >= WATER_LEVEL && air_detected)
-								vmanip.m_data[i] = MapNode(CONTENT_GRASS);
+								vmanip.m_data[i] = MapNode(LEGN(ndef, "CONTENT_GRASS"));
 							#endif
 							else
-								vmanip.m_data[i] = MapNode(CONTENT_MUD);
+								vmanip.m_data[i] = MapNode(LEGN(ndef, "CONTENT_MUD"));
 						}
 						else
 						{
-							if(vmanip.m_data[i].d == CONTENT_MUD
-								|| vmanip.m_data[i].d == CONTENT_GRASS)
-								vmanip.m_data[i] = MapNode(CONTENT_STONE);
+							if(vmanip.m_data[i].getContent() == LEGN(ndef, "CONTENT_MUD")
+								|| vmanip.m_data[i].getContent() == LEGN(ndef, "CONTENT_GRASS"))
+								vmanip.m_data[i] = MapNode(LEGN(ndef, "CONTENT_STONE"));
 						}
 
 						current_depth++;
@@ -1907,11 +2110,19 @@ void make_block(BlockMakeData *data)
 		}
 
 		/*
-			Add trees
+			Calculate some stuff
 		*/
 		
+		float surface_humidity = surface_humidity_2d(data->seed, p2d_center);
+		bool is_jungle = surface_humidity > 0.75;
 		// Amount of trees
 		u32 tree_count = block_area_nodes * tree_amount_2d(data->seed, p2d_center);
+		if(is_jungle)
+			tree_count *= 5;
+
+		/*
+			Add trees
+		*/
 		PseudoRandom treerandom(blockseed);
 		// Put trees in random places on part of division
 		for(u32 i=0; i<tree_count; i++)
@@ -1936,7 +2147,7 @@ void make_block(BlockMakeData *data)
 			{
 				u32 i = data->vmanip->m_area.index(p);
 				MapNode *n = &data->vmanip->m_data[i];
-				if(n->d != CONTENT_AIR && n->d != CONTENT_WATERSOURCE && n->d != CONTENT_IGNORE)
+				if(n->getContent() != CONTENT_AIR && n->getContent() != c_water_source && n->getContent() != CONTENT_IGNORE)
 				{
 					found = true;
 					break;
@@ -1950,30 +2161,90 @@ void make_block(BlockMakeData *data)
 				u32 i = data->vmanip->m_area.index(p);
 				MapNode *n = &data->vmanip->m_data[i];
 
-				if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS && n->d != CONTENT_SAND)
+				if(n->getContent() != c_dirt && n->getContent() != c_dirt_with_grass && n->getContent() != c_sand)
 						continue;
 
 				// Papyrus grows only on mud and in water
-				if(n->d == CONTENT_MUD && y <= WATER_LEVEL)
+				if(n->getContent() == c_dirt && y <= WATER_LEVEL)
 				{
 					p.Y++;
-					make_papyrus(vmanip, p);
+					make_papyrus(vmanip, p, ndef);
 				}
 				// Trees grow only on mud and grass, on land
-				else if((n->d == CONTENT_MUD || n->d == CONTENT_GRASS) && y > WATER_LEVEL + 2)
+				else if((n->getContent() == c_dirt || n->getContent() == LEGN(ndef, "CONTENT_GRASS")) && y > WATER_LEVEL + 2)
 				{
 					p.Y++;
-					make_tree(vmanip, p);
+					//if(surface_humidity_2d(data->seed, v2s16(x, y)) < 0.5)
+					if(is_jungle == false)
+					{
+						bool is_apple_tree;
+						if(myrand_range(0,4) != 0)
+							is_apple_tree = false;
+						else
+							is_apple_tree = noise2d_perlin(
+									0.5+(float)p.X/100, 0.5+(float)p.Z/100,
+									data->seed+342902, 3, 0.45) > 0.2;
+						make_tree(vmanip, p, is_apple_tree, ndef);
+					}
+					else
+						make_jungletree(vmanip, p, ndef);
 				}
 				// Cactii grow only on sand, on land
-				else if(n->d == CONTENT_SAND && y > WATER_LEVEL + 2)
+				else if(n->getContent() == c_sand && y > WATER_LEVEL + 2)
 				{
 					p.Y++;
-					make_cactus(vmanip, p);
+					make_cactus(vmanip, p, ndef);
 				}
 			}
 		}
 
+		/*
+			Add jungle grass
+		*/
+		if(is_jungle)
+		{
+			PseudoRandom grassrandom(blockseed);
+			for(u32 i=0; i<surface_humidity*5*tree_count; i++)
+			{
+				s16 x = grassrandom.range(node_min.X, node_max.X);
+				s16 z = grassrandom.range(node_min.Z, node_max.Z);
+				s16 y = find_ground_level_from_noise(data->seed, v2s16(x,z), 4);
+				if(y < WATER_LEVEL)
+					continue;
+				if(y < node_min.Y || y > node_max.Y)
+					continue;
+				/*
+					Find exact ground level
+				*/
+				v3s16 p(x,y+6,z);
+				bool found = false;
+				for(; p.Y >= y-6; p.Y--)
+				{
+					u32 i = data->vmanip->m_area.index(p);
+					MapNode *n = &data->vmanip->m_data[i];
+					if(data->nodedef->get(*n).is_ground_content)
+					{
+						found = true;
+						break;
+					}
+				}
+				// If not found, handle next one
+				if(found == false)
+					continue;
+				p.Y++;
+				if(vmanip.m_area.contains(p) == false)
+					continue;
+				if(vmanip.m_data[vmanip.m_area.index(p)].getContent() != CONTENT_AIR)
+					continue;
+				/*p.Y--;
+				if(vmanip.m_area.contains(p))
+					vmanip.m_data[vmanip.m_area.index(p)] = LEGN(ndef, "CONTENT_MUD");
+				p.Y++;*/
+				if(vmanip.m_area.contains(p))
+					vmanip.m_data[vmanip.m_area.index(p)] = LEGN(ndef, "CONTENT_JUNGLEGRASS");
+			}
+		}
+
 #if 0
 		/*
 			Add some kind of random stones
@@ -1998,7 +2269,7 @@ void make_block(BlockMakeData *data)
 			/*{
 				u32 i = data->vmanip->m_area.index(v3s16(p));
 				MapNode *n = &data->vmanip->m_data[i];
-				if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS)
+				if(n->getContent() != LEGN(ndef, "CONTENT_MUD") && n->getContent() != LEGN(ndef, "CONTENT_GRASS"))
 					continue;
 			}*/
 			// Will be placed one higher
@@ -2033,7 +2304,7 @@ void make_block(BlockMakeData *data)
 			/*{
 				u32 i = data->vmanip->m_area.index(v3s16(p));
 				MapNode *n = &data->vmanip->m_data[i];
-				if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS)
+				if(n->getContent() != LEGN(ndef, "CONTENT_MUD") && n->getContent() != LEGN(ndef, "CONTENT_GRASS"))
 					continue;
 			}*/
 			// Will be placed one lower
@@ -2049,7 +2320,8 @@ void make_block(BlockMakeData *data)
 BlockMakeData::BlockMakeData():
 	no_op(false),
 	vmanip(NULL),
-	seed(0)
+	seed(0),
+	nodedef(NULL)
 {}
 
 BlockMakeData::~BlockMakeData()