X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fmapgen.cpp;h=67e92f4498bca02d0f458a64cb818e7b498fa760;hb=0e6f7a21c60d162b3b7134882dc22dbd8acd014f;hp=a491ac81aa19206db256f9af3198867f8ee041ba;hpb=1cdf210e4f01b7221a241cbb911f08bc6ffa75bd;p=oweals%2Fminetest.git diff --git a/src/mapgen.cpp b/src/mapgen.cpp index a491ac81a..67e92f449 100644 --- a/src/mapgen.cpp +++ b/src/mapgen.cpp @@ -3,28 +3,32 @@ Minetest-c55 Copyright (C) 2010-2011 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "mapgen.h" #include "voxel.h" -#include "content_mapnode.h" #include "noise.h" #include "mapblock.h" #include "map.h" -#include "serverobject.h" -#include "mineral.h" +//#include "serverobject.h" +#include "content_sao.h" +#include "nodedef.h" +#include "content_mapnode.h" // For content_mapnode_get_new_name +#include "voxelalgorithms.h" +#include "profiler.h" +#include "main.h" // For g_profiler namespace mapgen { @@ -33,8 +37,10 @@ namespace mapgen Some helper functions for the map generator */ -#if 0 -static s16 find_ground_level(VoxelManipulator &vmanip, v2s16 p2d) +#if 1 +// Returns Y one under area minimum if not found +static s16 find_ground_level(VoxelManipulator &vmanip, v2s16 p2d, + INodeDefManager *ndef) { v3s16 em = vmanip.m_area.getExtent(); s16 y_nodes_max = vmanip.m_area.MaxEdge.Y; @@ -44,7 +50,7 @@ static s16 find_ground_level(VoxelManipulator &vmanip, v2s16 p2d) for(y=y_nodes_max; y>=y_nodes_min; y--) { MapNode &n = vmanip.m_data[i]; - if(content_walkable(n.d)) + if(ndef->get(n).walkable) break; vmanip.m_area.add_y(em, i, -1); @@ -52,22 +58,29 @@ static s16 find_ground_level(VoxelManipulator &vmanip, v2s16 p2d) if(y >= y_nodes_min) return y; else - return y_nodes_min; + return y_nodes_min - 1; } -static s16 find_ground_level_clever(VoxelManipulator &vmanip, v2s16 p2d) +#if 0 +// Returns Y one under area minimum if not found +static s16 find_ground_level_clever(VoxelManipulator &vmanip, v2s16 p2d, + INodeDefManager *ndef) { + if(!vmanip.m_area.contains(v3s16(p2d.X, vmanip.m_area.MaxEdge.Y, p2d.Y))) + return vmanip.m_area.MinEdge.Y-1; v3s16 em = vmanip.m_area.getExtent(); s16 y_nodes_max = vmanip.m_area.MaxEdge.Y; s16 y_nodes_min = vmanip.m_area.MinEdge.Y; u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); s16 y; + content_t c_tree = ndef->getId("mapgen_tree"); + content_t c_leaves = ndef->getId("mapgen_leaves"); for(y=y_nodes_max; y>=y_nodes_min; y--) { MapNode &n = vmanip.m_data[i]; - if(content_walkable(n.d) - && n.d != CONTENT_TREE - && n.d != CONTENT_LEAVES) + if(ndef->get(n).walkable + && n.getContent() != c_tree + && n.getContent() != c_leaves) break; vmanip.m_area.add_y(em, i, -1); @@ -75,16 +88,46 @@ static s16 find_ground_level_clever(VoxelManipulator &vmanip, v2s16 p2d) if(y >= y_nodes_min) return y; else - return y_nodes_min; + return y_nodes_min - 1; } #endif -static void make_tree(VoxelManipulator &vmanip, v3s16 p0) +// Returns Y one under area minimum if not found +static s16 find_stone_level(VoxelManipulator &vmanip, v2s16 p2d, + INodeDefManager *ndef) { - MapNode treenode(CONTENT_TREE); - MapNode leavesnode(CONTENT_LEAVES); + v3s16 em = vmanip.m_area.getExtent(); + s16 y_nodes_max = vmanip.m_area.MaxEdge.Y; + s16 y_nodes_min = vmanip.m_area.MinEdge.Y; + u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); + s16 y; + content_t c_stone = ndef->getId("mapgen_stone"); + content_t c_desert_stone = ndef->getId("mapgen_desert_stone"); + for(y=y_nodes_max; y>=y_nodes_min; y--) + { + MapNode &n = vmanip.m_data[i]; + content_t c = n.getContent(); + if(c != CONTENT_IGNORE && ( + c == c_stone || c == c_desert_stone)) + break; + + vmanip.m_area.add_y(em, i, -1); + } + if(y >= y_nodes_min) + return y; + else + return y_nodes_min - 1; +} +#endif - s16 trunk_h = myrand_range(3, 6); +void make_tree(ManualMapVoxelManipulator &vmanip, v3s16 p0, + bool is_apple_tree, INodeDefManager *ndef) +{ + MapNode treenode(ndef->getId("mapgen_tree")); + MapNode leavesnode(ndef->getId("mapgen_leaves")); + MapNode applenode(ndef->getId("mapgen_apple")); + + s16 trunk_h = myrand_range(4, 5); v3s16 p1 = p0; for(s16 ii=0; ii leaves_d(new u8[leaves_a.getVolume()]); Buffer leaves_d(leaves_a.getVolume()); for(s32 i=0; igetId("mapgen_jungletree")); + MapNode leavesnode(ndef->getId("mapgen_leaves")); - s16 trunk_h = myrand_range(2, 3); - v3s16 p1 = p0; - for(s16 ii=0; ii stone_d(stone_a.getVolume()); - for(s32 i=0; i leaves_d(new u8[leaves_a.getVolume()]); + Buffer leaves_d(leaves_a.getVolume()); + for(s32 i=0; i 0.0) + s16 d = 1; + for(s16 z=-d; z<=d; z++) + for(s16 y=-d; y<=d; y++) + for(s16 x=-d; x<=d; x++) { - u32 vi = stone_a.index(v3s16(x,y,z)); - stone_d[vi] = 1; + leaves_d[leaves_a.index(v3s16(x,y,z))] = 1; } } - /*// Add stone randomly - for(u32 iii=0; iii<7; iii++) + // Add leaves randomly + for(u32 iii=0; iii<30; iii++) { s16 d = 1; v3s16 p( - myrand_range(stone_a.MinEdge.X, stone_a.MaxEdge.X-d), - myrand_range(stone_a.MinEdge.Y, stone_a.MaxEdge.Y-d), - myrand_range(stone_a.MinEdge.Z, stone_a.MaxEdge.Z-d) + 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++) { - stone_d[stone_a.index(p+v3s16(x,y,z))] = 1; + leaves_d[leaves_a.index(p+v3s16(x,y,z))] = 1; } - }*/ + } - // Blit stone to vmanip - for(s16 z=stone_a.MinEdge.Z; z<=stone_a.MaxEdge.Z; z++) - for(s16 y=stone_a.MinEdge.Y; y<=stone_a.MaxEdge.Y; y++) - for(s16 x=stone_a.MinEdge.X; x<=stone_a.MaxEdge.X; x++) + // 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 += p0; + p += p1; 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) - vmanip.m_data[vi] = stonenode; + u32 i = leaves_a.index(x,y,z); + if(leaves_d[i] == 1) + vmanip.m_data[vi] = leavesnode; } } -#endif -#if 0 -static void make_largestone(VoxelManipulator &vmanip, v3s16 p0) +static void make_papyrus(VoxelManipulator &vmanip, v3s16 p0, + INodeDefManager *ndef) { - MapNode stonenode(CONTENT_STONE); - - s16 size = myrand_range(8, 16); - - VoxelArea stone_a(v3s16(-size/2,0,-size/2), v3s16(size/2,size,size/2)); - Buffer stone_d(stone_a.getVolume()); - for(s32 i=0; igetId("mapgen_papyrus")); - // Generate from perlin noise - for(s16 z=stone_a.MinEdge.Z; z<=stone_a.MaxEdge.Z; z++) - for(s16 y=stone_a.MinEdge.Y; y<=stone_a.MaxEdge.Y; y++) - for(s16 x=stone_a.MinEdge.X; x<=stone_a.MaxEdge.X; x++) + s16 trunk_h = myrand_range(2, 3); + v3s16 p1 = p0; + for(s16 ii=0; ii 1.0) - { - u32 vi = stone_a.index(v3s16(x,y,z)); - stone_d[vi] = 1; - } + if(vmanip.m_area.contains(p1)) + vmanip.m_data[vmanip.m_area.index(p1)] = papyrusnode; + p1.Y++; } +} - /*// Add stone randomly - for(u32 iii=0; iii<7; iii++) - { - s16 d = 1; - - v3s16 p( - myrand_range(stone_a.MinEdge.X, stone_a.MaxEdge.X-d), - myrand_range(stone_a.MinEdge.Y, stone_a.MaxEdge.Y-d), - myrand_range(stone_a.MinEdge.Z, stone_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++) - { - stone_d[stone_a.index(p+v3s16(x,y,z))] = 1; - } - }*/ +static void make_cactus(VoxelManipulator &vmanip, v3s16 p0, + INodeDefManager *ndef) +{ + MapNode cactusnode(ndef->getId("mapgen_cactus")); - // Blit stone to vmanip - for(s16 z=stone_a.MinEdge.Z; z<=stone_a.MaxEdge.Z; z++) - for(s16 y=stone_a.MinEdge.Y; y<=stone_a.MaxEdge.Y; y++) - for(s16 x=stone_a.MinEdge.X; x<=stone_a.MaxEdge.X; x++) + s16 trunk_h = 3; + v3s16 p1 = p0; + for(s16 ii=0; iigetId("mapgen_cobble")); } { v3s16 p = roomplace + v3s16(roomsize.X-1,y,z); @@ -375,7 +352,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(ndef->getId("mapgen_cobble")); } } @@ -390,7 +367,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(ndef->getId("mapgen_cobble")); } { v3s16 p = roomplace + v3s16(x,y,roomsize.Z-1); @@ -399,7 +376,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(ndef->getId("mapgen_cobble")); } } @@ -414,7 +391,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(ndef->getId("mapgen_cobble")); } { v3s16 p = roomplace + v3s16(x,roomsize.Y-1,z); @@ -423,7 +400,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(ndef->getId("mapgen_cobble")); } } @@ -459,17 +436,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(ndef->getId("mapgen_torch")); } static v3s16 rand_ortho_dir(PseudoRandom &random) @@ -520,9 +499,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; @@ -531,7 +510,7 @@ static void make_corridor(VoxelManipulator &vmanip, v3s16 doorplace, else length = random.range(1,6); length = random.range(1,13); - u32 partlength = random.range(1,length); + u32 partlength = random.range(1,13); u32 partcount = 0; s16 make_stairs = 0; if(random.next()%2 == 0 && partlength >= 3) @@ -543,9 +522,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) { }*/ @@ -556,7 +535,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(ndef->getId("mapgen_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), @@ -565,8 +544,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(ndef->getId("mapgen_cobble")), 0); + make_hole1(vmanip, p, ndef); /*make_fill(vmanip, p, v3s16(1,2,1), 0, MapNode(CONTENT_AIR), VMANIP_FLAG_DUNGEON_INSIDE);*/ } @@ -605,10 +584,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(); } @@ -641,10 +622,10 @@ public: randomizeDir(); continue; } - if(vmanip.getNodeNoExNoEmerge(p).d - == CONTENT_COBBLE - && vmanip.getNodeNoExNoEmerge(p1).d - == CONTENT_COBBLE) + if(vmanip.getNodeNoExNoEmerge(p).getContent() + == m_ndef->getId("mapgen_cobble") + && vmanip.getNodeNoExNoEmerge(p1).getContent() + == m_ndef->getId("mapgen_cobble")) { // Found wall, this is a good place! result_place = p; @@ -657,25 +638,25 @@ public: 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 + if(vmanip.getNodeNoExNoEmerge(p+v3s16(0,0,0)).getContent() + == m_ndef->getId("mapgen_cobble") + && vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).getContent() == CONTENT_AIR - && vmanip.getNodeNoExNoEmerge(p+v3s16(0,2,0)).d + && vmanip.getNodeNoExNoEmerge(p+v3s16(0,2,0)).getContent() == 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 + if(vmanip.getNodeNoExNoEmerge(p+v3s16(0,1,0)).getContent() + == m_ndef->getId("mapgen_cobble") + && vmanip.getNodeNoExNoEmerge(p+v3s16(0,0,0)).getContent() == CONTENT_AIR - && vmanip.getNodeNoExNoEmerge(p+v3s16(0,-1,0)).d + && vmanip.getNodeNoExNoEmerge(p+v3s16(0,-1,0)).getContent() == CONTENT_AIR) p += v3s16(0,-1,0); // Check if walking is now possible - 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) { // Cannot continue walking here @@ -700,14 +681,30 @@ public: continue; v3s16 roomplace; // X east, Z north, Y up +#if 1 if(doordir == v3s16(1,0,0)) // X+ - roomplace = doorplace + v3s16(0,-1,-roomsize.Z/2+m_random.range(-roomsize.Z/2+1,roomsize.Z/2-1)); + roomplace = doorplace + + v3s16(0,-1,m_random.range(-roomsize.Z+2,-2)); if(doordir == v3s16(-1,0,0)) // X- - roomplace = doorplace + v3s16(-roomsize.X+1,-1,-roomsize.Z/2+m_random.range(-roomsize.Z/2+1,roomsize.Z/2-1)); + roomplace = doorplace + + v3s16(-roomsize.X+1,-1,m_random.range(-roomsize.Z+2,-2)); if(doordir == v3s16(0,0,1)) // Z+ - roomplace = doorplace + v3s16(-roomsize.X/2+m_random.range(-roomsize.X/2+1,roomsize.X/2-1),-1,0); + roomplace = doorplace + + v3s16(m_random.range(-roomsize.X+2,-2),-1,0); if(doordir == v3s16(0,0,-1)) // Z- - roomplace = doorplace + v3s16(-roomsize.X/2+m_random.range(-roomsize.X/2+1,roomsize.X/2-1),-1,-roomsize.Z+1); + roomplace = doorplace + + v3s16(m_random.range(-roomsize.X+2,-2),-1,-roomsize.Z+1); +#endif +#if 0 + if(doordir == v3s16(1,0,0)) // X+ + roomplace = doorplace + v3s16(0,-1,-roomsize.Z/2); + if(doordir == v3s16(-1,0,0)) // X- + roomplace = doorplace + v3s16(-roomsize.X+1,-1,-roomsize.Z/2); + if(doordir == v3s16(0,0,1)) // Z+ + roomplace = doorplace + v3s16(-roomsize.X/2,-1,0); + if(doordir == v3s16(0,0,-1)) // Z- + roomplace = doorplace + v3s16(-roomsize.X/2,-1,-roomsize.Z+1); +#endif // Check fit bool fits = true; @@ -746,9 +743,11 @@ private: 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; @@ -781,7 +780,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; @@ -805,12 +804,12 @@ static void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random) for(u32 i=0; igetId("mapgen_torch")); // Quit if last room if(i == room_count-1) @@ -818,7 +817,7 @@ static void make_dungeon1(VoxelManipulator &vmanip, PseudoRandom &random) // Determine walker start position - bool start_in_last_room = (random.range(0,1)==0); + bool start_in_last_room = (random.range(0,2)!=0); //bool start_in_last_room = true; v3s16 walker_start_place; @@ -835,7 +834,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); @@ -844,7 +843,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; @@ -853,7 +852,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)); @@ -865,42 +864,98 @@ 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; } } +#endif + +#if 0 +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(ndef->getId("mapgen_nyancat"), facedir_i); + u32 length = random.range(3,15); + for(u32 j=0; jgetId("mapgen_nyancat_rainbow")); + } +} +#endif /* Noise functions. Make sure seed is mangled differently in each one. */ -// This affects the shape of the contour +#if 0 +/* + Scaling the output of the noise function affects the overdrive of the + contour function, which affects the shape of the output considerably. +*/ +#define CAVE_NOISE_SCALE 12.0 //#define CAVE_NOISE_SCALE 10.0 //#define CAVE_NOISE_SCALE 7.5 -#define CAVE_NOISE_SCALE 5.0 +//#define CAVE_NOISE_SCALE 5.0 +//#define CAVE_NOISE_SCALE 1.0 + +//#define CAVE_NOISE_THRESHOLD (2.5/CAVE_NOISE_SCALE) +#define CAVE_NOISE_THRESHOLD (1.5/CAVE_NOISE_SCALE) NoiseParams get_cave_noise1_params(u64 seed) { /*return NoiseParams(NOISE_PERLIN_CONTOUR, seed+52534, 5, 0.7, 200, CAVE_NOISE_SCALE);*/ - return NoiseParams(NOISE_PERLIN_CONTOUR, seed+52534, 4, 0.7, - 100, CAVE_NOISE_SCALE); + /*return NoiseParams(NOISE_PERLIN_CONTOUR, seed+52534, 4, 0.7, + 100, CAVE_NOISE_SCALE);*/ + /*return NoiseParams(NOISE_PERLIN_CONTOUR, seed+52534, 5, 0.6, + 100, CAVE_NOISE_SCALE);*/ + /*return NoiseParams(NOISE_PERLIN_CONTOUR, seed+52534, 5, 0.3, + 100, CAVE_NOISE_SCALE);*/ + return NoiseParams(NOISE_PERLIN_CONTOUR, seed+52534, 4, 0.5, + 50, CAVE_NOISE_SCALE); + //return NoiseParams(NOISE_CONSTANT_ONE); } NoiseParams get_cave_noise2_params(u64 seed) { /*return NoiseParams(NOISE_PERLIN_CONTOUR_FLIP_YZ, seed+10325, 5, 0.7, 200, CAVE_NOISE_SCALE);*/ - return NoiseParams(NOISE_PERLIN_CONTOUR_FLIP_YZ, seed+10325, 4, 0.7, - 100, CAVE_NOISE_SCALE); + /*return NoiseParams(NOISE_PERLIN_CONTOUR_FLIP_YZ, seed+10325, 4, 0.7, + 100, CAVE_NOISE_SCALE);*/ + /*return NoiseParams(NOISE_PERLIN_CONTOUR_FLIP_YZ, seed+10325, 5, 0.3, + 100, CAVE_NOISE_SCALE);*/ + return NoiseParams(NOISE_PERLIN_CONTOUR_FLIP_YZ, seed+10325, 4, 0.5, + 50, CAVE_NOISE_SCALE); + //return NoiseParams(NOISE_CONSTANT_ONE); } -//#define CAVE_NOISE_THRESHOLD (2.5/CAVE_NOISE_SCALE) -#define CAVE_NOISE_THRESHOLD (2.0/CAVE_NOISE_SCALE) - NoiseParams get_ground_noise1_params(u64 seed) { return NoiseParams(NOISE_PERLIN, seed+983240, 4, @@ -937,13 +992,13 @@ bool val_is_ground(double ground_noise1_val, v3s16 p, u64 seed) { //return ((double)p.Y < ground_noise1_val); - double f = 0.8 + noise2d_perlin( + double f = 0.55 + noise2d_perlin( 0.5+(float)p.X/250, 0.5+(float)p.Z/250, seed+920381, 3, 0.45); if(f < 0.01) f = 0.01; else if(f >= 1.0) - f *= 2.0; + f *= 1.6; double h = WATER_LEVEL + 10 * noise2d_perlin( 0.5+(float)p.X/250, 0.5+(float)p.Z/250, seed+84174, 4, 0.5); @@ -960,6 +1015,7 @@ bool is_ground(u64 seed, v3s16 p) double val1 = noise3d_param(get_ground_noise1_params(seed), p.X,p.Y,p.Z); return val_is_ground(val1, p, seed); } +#endif // Amount of trees per area in nodes double tree_amount_2d(u64 seed, v2s16 p) @@ -970,7 +1026,7 @@ 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 @@ -978,29 +1034,17 @@ double tree_amount_2d(u64 seed, v2s16 p) } #if 0 -double randomstone_amount_2d(u64 seed, v2s16 p) -{ - double noise = noise2d_perlin( - 0.5+(float)p.X/250, 0.5+(float)p.Y/250, - seed+3829434, 5, 0.66); - double zeroval = 0.1; - if(noise < zeroval) - return 0; - else - return 0.01 * (noise-zeroval) / (1.0-zeroval); -} -#endif - -double largestone_amount_2d(u64 seed, v2s16 p) +double surface_humidity_2d(u64 seed, v2s16 p) { double noise = noise2d_perlin( - 0.5+(float)p.X/250, 0.5+(float)p.Y/250, - seed+14143242, 5, 0.66); - double zeroval = 0.3; - if(noise < zeroval) - return 0; - else - return 0.005 * (noise-zeroval) / (1.0-zeroval); + 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; } /* @@ -1082,6 +1126,7 @@ double get_sector_maximum_ground_level(u64 seed, v2s16 sectorpos, double p) v2s16 node_min = sectorpos*MAP_BLOCKSIZE; v2s16 node_max = (sectorpos+v2s16(1,1))*MAP_BLOCKSIZE-v2s16(1,1); double a = -31000; + // Corners a = MYMAX(a, find_ground_level_from_noise(seed, v2s16(node_min.X, node_min.Y), p)); a = MYMAX(a, find_ground_level_from_noise(seed, @@ -1090,8 +1135,18 @@ double get_sector_maximum_ground_level(u64 seed, v2s16 sectorpos, double p) v2s16(node_max.X, node_max.Y), p)); a = MYMAX(a, find_ground_level_from_noise(seed, v2s16(node_min.X, node_min.Y), p)); + // Center a = MYMAX(a, find_ground_level_from_noise(seed, v2s16(node_min.X+MAP_BLOCKSIZE/2, node_min.Y+MAP_BLOCKSIZE/2), p)); + // Side middle points + a = MYMAX(a, find_ground_level_from_noise(seed, + v2s16(node_min.X+MAP_BLOCKSIZE/2, node_min.Y), p)); + a = MYMAX(a, find_ground_level_from_noise(seed, + v2s16(node_min.X+MAP_BLOCKSIZE/2, node_max.Y), p)); + a = MYMAX(a, find_ground_level_from_noise(seed, + v2s16(node_min.X, node_min.Y+MAP_BLOCKSIZE/2), p)); + a = MYMAX(a, find_ground_level_from_noise(seed, + v2s16(node_max.X, node_min.Y+MAP_BLOCKSIZE/2), p)); return a; } @@ -1102,6 +1157,7 @@ double get_sector_minimum_ground_level(u64 seed, v2s16 sectorpos, double p) v2s16 node_min = sectorpos*MAP_BLOCKSIZE; v2s16 node_max = (sectorpos+v2s16(1,1))*MAP_BLOCKSIZE-v2s16(1,1); double a = 31000; + // Corners a = MYMIN(a, find_ground_level_from_noise(seed, v2s16(node_min.X, node_min.Y), p)); a = MYMIN(a, find_ground_level_from_noise(seed, @@ -1110,15 +1166,29 @@ double get_sector_minimum_ground_level(u64 seed, v2s16 sectorpos, double p) v2s16(node_max.X, node_max.Y), p)); a = MYMIN(a, find_ground_level_from_noise(seed, v2s16(node_min.X, node_min.Y), p)); + // Center a = MYMIN(a, find_ground_level_from_noise(seed, v2s16(node_min.X+MAP_BLOCKSIZE/2, node_min.Y+MAP_BLOCKSIZE/2), p)); + // Side middle points + a = MYMIN(a, find_ground_level_from_noise(seed, + v2s16(node_min.X+MAP_BLOCKSIZE/2, node_min.Y), p)); + a = MYMIN(a, find_ground_level_from_noise(seed, + v2s16(node_min.X+MAP_BLOCKSIZE/2, node_max.Y), p)); + a = MYMIN(a, find_ground_level_from_noise(seed, + v2s16(node_min.X, node_min.Y+MAP_BLOCKSIZE/2), p)); + a = MYMIN(a, find_ground_level_from_noise(seed, + v2s16(node_max.X, node_min.Y+MAP_BLOCKSIZE/2), p)); return a; } +#endif +// Required by mapgen.h bool block_is_underground(u64 seed, v3s16 blockpos) { - s16 minimum_groundlevel = (s16)get_sector_minimum_ground_level( - seed, v2s16(blockpos.X, blockpos.Z)); + /*s16 minimum_groundlevel = (s16)get_sector_minimum_ground_level( + seed, v2s16(blockpos.X, blockpos.Z));*/ + // Nah, this is just a heuristic, just return something + s16 minimum_groundlevel = WATER_LEVEL; if(blockpos.Y*MAP_BLOCKSIZE + MAP_BLOCKSIZE <= minimum_groundlevel) return true; @@ -1126,7 +1196,6 @@ bool block_is_underground(u64 seed, v3s16 blockpos) return false; } -#if 0 #define AVERAGE_MUD_AMOUNT 4 double base_rock_level_2d(u64 seed, v2s16 p) @@ -1134,20 +1203,20 @@ double base_rock_level_2d(u64 seed, v2s16 p) // The base ground level double base = (double)WATER_LEVEL - (double)AVERAGE_MUD_AMOUNT + 20. * noise2d_perlin( - 0.5+(float)p.X/500., 0.5+(float)p.Y/500., - (seed>>32)+654879876, 6, 0.6); + 0.5+(float)p.X/250., 0.5+(float)p.Y/250., + seed+82341, 5, 0.6); /*// A bit hillier one double base2 = WATER_LEVEL - 4.0 + 40. * noise2d_perlin( 0.5+(float)p.X/250., 0.5+(float)p.Y/250., - (seed>>27)+90340, 6, 0.69); + seed+93413, 6, 0.69); if(base2 > base) base = base2;*/ #if 1 // Higher ground level - double higher = (double)WATER_LEVEL + 25. + 35. * noise2d_perlin( - 0.5+(float)p.X/250., 0.5+(float)p.Y/250., - seed+85039, 5, 0.69); + double higher = (double)WATER_LEVEL + 20. + 16. * noise2d_perlin( + 0.5+(float)p.X/500., 0.5+(float)p.Y/500., + seed+85039, 5, 0.6); //higher = 30; // For debugging // Limit higher to at least base @@ -1155,25 +1224,33 @@ double base_rock_level_2d(u64 seed, v2s16 p) higher = base; // Steepness factor of cliffs - double b = 1.0 + 1.0 * noise2d_perlin( - 0.5+(float)p.X/250., 0.5+(float)p.Y/250., - seed-932, 7, 0.7); + double b = 0.85 + 0.5 * noise2d_perlin( + 0.5+(float)p.X/125., 0.5+(float)p.Y/125., + seed-932, 5, 0.7); b = rangelim(b, 0.0, 1000.0); - b = pow(b, 5); - b *= 7; - b = rangelim(b, 3.0, 1000.0); + b = pow(b, 7); + b *= 5; + b = rangelim(b, 0.5, 1000.0); + // Values 1.5...100 give quite horrible looking slopes + if(b > 1.5 && b < 100.0){ + if(b < 10.0) + b = 1.5; + else + b = 100.0; + } //dstream<<"b="< -0.15); + return (sandnoise > 0.15); } -/* - Adds random objects to block, depending on the content of the block -*/ -void add_random_objects(MapBlock *block) +enum BiomeType { - for(s16 z0=0; z0getNodeNoEx(p); - if(n.d == CONTENT_IGNORE) - continue; - if(content_features(n.d).liquid_type != LIQUID_NONE) - continue; - if(content_features(n.d).walkable) - { - last_node_walkable = true; - continue; - } - if(last_node_walkable) - { - // If block contains light information - if(content_features(n.d).param_type == CPT_LIGHT) - { - if(n.getLight(LIGHTBANK_DAY) <= 3) - { - if(myrand() % 300 == 0) - { - v3f pos_f = intToFloat(p+block->getPosRelative(), BS); - pos_f.Y -= BS*0.4; - ServerActiveObject *obj = new RatSAO(NULL, 0, pos_f); - std::string data = obj->getStaticData(); - StaticObject s_obj(obj->getType(), - obj->getBasePosition(), data); - // Add some - block->m_static_objects.insert(0, s_obj); - block->m_static_objects.insert(0, s_obj); - block->m_static_objects.insert(0, s_obj); - block->m_static_objects.insert(0, s_obj); - block->m_static_objects.insert(0, s_obj); - block->m_static_objects.insert(0, s_obj); - delete obj; - } - if(myrand() % 1000 == 0) - { - v3f pos_f = intToFloat(p+block->getPosRelative(), BS); - pos_f.Y -= BS*0.4; - ServerActiveObject *obj = new Oerkki1SAO(NULL,0,pos_f); - std::string data = obj->getStaticData(); - StaticObject s_obj(obj->getType(), - obj->getBasePosition(), data); - // Add one - block->m_static_objects.insert(0, s_obj); - delete obj; - } - } - } - } - last_node_walkable = false; - } - } - block->setChangedFlag(); + BT_NORMAL, + BT_DESERT +}; + +BiomeType get_biome(u64 seed, v2s16 p2d) +{ + // Just do something very simple as for now + double d = noise2d_perlin( + 0.6+(float)p2d.X/250, 0.2+(float)p2d.Y/250, + seed+9130, 3, 0.50); + if(d > 0.45) + return BT_DESERT; + if(d > 0.35 && (noise2d( p2d.X, p2d.Y, int(seed) ) + 1.0) > ( 0.45 - d ) * 20.0 ) + return BT_DESERT; + return BT_NORMAL; +}; + +u32 get_blockseed(u64 seed, v3s16 p) +{ + s32 x=p.X, y=p.Y, z=p.Z; + return (u32)(seed%0x100000000ULL) + z*38134234 + y*42123 + x*23; } +#define VMANIP_FLAG_CAVE VOXELFLAG_CHECKED1 + void make_block(BlockMakeData *data) { if(data->no_op) { - dstream<<"makeBlock: no-op"<blockpos; + assert(data->vmanip); + assert(data->nodedef); + assert(data->blockpos_requested.X >= data->blockpos_min.X && + data->blockpos_requested.Y >= data->blockpos_min.Y && + data->blockpos_requested.Z >= data->blockpos_min.Z); + assert(data->blockpos_requested.X <= data->blockpos_max.X && + data->blockpos_requested.Y <= data->blockpos_max.Y && + data->blockpos_requested.Z <= data->blockpos_max.Z); + + INodeDefManager *ndef = data->nodedef; + + // Hack: use minimum block coordinates for old code that assumes + // a single block + v3s16 blockpos = data->blockpos_requested; /*dstream<<"makeBlock(): ("<blockpos_min; + v3s16 blockpos_max = data->blockpos_max; + v3s16 blockpos_full_min = blockpos_min - v3s16(1,1,1); + v3s16 blockpos_full_max = blockpos_max + v3s16(1,1,1); + ManualMapVoxelManipulator &vmanip = *(data->vmanip); - v3s16 blockpos_min = blockpos - v3s16(1,1,1); - v3s16 blockpos_max = blockpos + v3s16(1,1,1); - // Area of center block - v3s16 node_min = blockpos*MAP_BLOCKSIZE; - v3s16 node_max = (blockpos+v3s16(1,1,1))*MAP_BLOCKSIZE-v3s16(1,1,1); + // Area of central chunk + v3s16 node_min = blockpos_min*MAP_BLOCKSIZE; + v3s16 node_max = (blockpos_max+v3s16(1,1,1))*MAP_BLOCKSIZE-v3s16(1,1,1); // Full allocated area - v3s16 full_node_min = (blockpos-1)*MAP_BLOCKSIZE; - v3s16 full_node_max = (blockpos+2)*MAP_BLOCKSIZE-v3s16(1,1,1); - // Area of a block - double block_area_nodes = MAP_BLOCKSIZE*MAP_BLOCKSIZE; + v3s16 full_node_min = (blockpos_min-1)*MAP_BLOCKSIZE; + v3s16 full_node_max = (blockpos_max+2)*MAP_BLOCKSIZE-v3s16(1,1,1); - v2s16 p2d_center(node_min.X+MAP_BLOCKSIZE/2, node_min.Z+MAP_BLOCKSIZE/2); + v3s16 central_area_size = node_max - node_min + v3s16(1,1,1); - /* - Get average ground level from noise - */ - - s16 approx_groundlevel = (s16)get_sector_average_ground_level( - data->seed, v2s16(blockpos.X, blockpos.Z)); - //dstream<<"approx_groundlevel="<seed, v2s16(blockpos.X, blockpos.Z)); - // Minimum amount of ground above the top of the central block - s16 minimum_ground_depth = minimum_groundlevel - node_max.Y; + // Generated surface area + //double gen_area_nodes = MAP_BLOCKSIZE*MAP_BLOCKSIZE * rel_volume; - s16 maximum_groundlevel = (s16)get_sector_maximum_ground_level( - data->seed, v2s16(blockpos.X, blockpos.Z), 1); - // Maximum amount of ground above the bottom of the central block - s16 maximum_ground_depth = maximum_groundlevel - node_min.Y; - - #if 0 - /* - Special case for high air or water: Just fill with air and water. - */ - if(maximum_ground_depth < -20) - { - for(s16 x=node_min.X; x<=node_max.X; x++) - for(s16 z=node_min.Z; z<=node_max.Z; z++) - { - // Node position - v2s16 p2d(x,z); - { - // Use fast index incrementing - v3s16 em = vmanip.m_area.getExtent(); - u32 i = vmanip.m_area.index(v3s16(p2d.X, node_min.Y, p2d.Y)); - 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(y <= WATER_LEVEL) - vmanip.m_data[i] = MapNode(CONTENT_WATERSOURCE); - else - vmanip.m_data[i] = MapNode(CONTENT_AIR); - } - - data->vmanip->m_area.add_y(em, i, 1); - } - } - } - - // We're done - return; - } - #endif + // Horribly wrong heuristic, but better than nothing + bool block_is_underground = (WATER_LEVEL > node_max.Y); - /* - If block is deep underground, this is set to true and ground - density noise is not generated, for speed optimization. - */ - bool all_is_ground_except_caves = (minimum_ground_depth > 16); - /* Create a block-specific seed */ - u32 blockseed = (data->seed%0x100000000) + full_node_min.Z*38134234 - + full_node_min.Y*42123 + full_node_min.X*23; + u32 blockseed = get_blockseed(data->seed, full_node_min); /* - Make some 3D noise + Cache some ground type values for speed */ - - //NoiseBuffer noisebuf1; - //NoiseBuffer noisebuf2; - NoiseBuffer noisebuf_cave; - NoiseBuffer noisebuf_ground; - NoiseBuffer noisebuf_ground_crumbleness; - NoiseBuffer noisebuf_ground_wetness; - { - v3f minpos_f(node_min.X, node_min.Y, node_min.Z); - v3f maxpos_f(node_max.X, node_max.Y, node_max.Z); - - //TimeTaker timer("noisebuf.create"); - /* - Cave noise - */ +// Creates variables c_name=id and n_name=node +#define CONTENT_VARIABLE(ndef, name)\ + content_t c_##name = ndef->getId("mapgen_" #name);\ + MapNode n_##name(c_##name); +// Default to something else if was CONTENT_IGNORE +#define CONTENT_VARIABLE_FALLBACK(name, dname)\ + if(c_##name == CONTENT_IGNORE){\ + c_##name = c_##dname;\ + n_##name = n_##dname;\ + } - noisebuf_cave.create(get_cave_noise1_params(data->seed), - minpos_f.X, minpos_f.Y, minpos_f.Z, - maxpos_f.X, maxpos_f.Y, maxpos_f.Z, - 4, 3, 4); - - noisebuf_cave.multiply(get_cave_noise2_params(data->seed)); + CONTENT_VARIABLE(ndef, stone); + CONTENT_VARIABLE(ndef, air); + CONTENT_VARIABLE(ndef, water_source); + CONTENT_VARIABLE(ndef, dirt); + CONTENT_VARIABLE(ndef, sand); + CONTENT_VARIABLE(ndef, gravel); + CONTENT_VARIABLE(ndef, clay); + CONTENT_VARIABLE(ndef, lava_source); + CONTENT_VARIABLE(ndef, cobble); + CONTENT_VARIABLE(ndef, mossycobble); + CONTENT_VARIABLE(ndef, dirt_with_grass); + CONTENT_VARIABLE(ndef, junglegrass); + CONTENT_VARIABLE(ndef, stone_with_coal); + CONTENT_VARIABLE(ndef, stone_with_iron); + CONTENT_VARIABLE(ndef, mese); + CONTENT_VARIABLE(ndef, desert_sand); + CONTENT_VARIABLE_FALLBACK(desert_sand, sand); + CONTENT_VARIABLE(ndef, desert_stone); + CONTENT_VARIABLE_FALLBACK(desert_stone, stone); + + // Maximum height of the stone surface and obstacles. + // This is used to guide the cave generation + s16 stone_surface_max_y = 0; - /* - Ground noise - */ - - // Sample length - v3f sl = v3f(4.0, 4.0, 4.0); - - /* - Density noise - */ - if(all_is_ground_except_caves == false) - //noisebuf_ground.create(data->seed+983240, 6, 0.60, false, - noisebuf_ground.create(get_ground_noise1_params(data->seed), - minpos_f.X, minpos_f.Y, minpos_f.Z, - maxpos_f.X, maxpos_f.Y, maxpos_f.Z, - sl.X, sl.Y, sl.Z); - - /* - Ground property noise - */ - sl = v3f(2.5, 2.5, 2.5); - noisebuf_ground_crumbleness.create( - get_ground_crumbleness_params(data->seed), - minpos_f.X, minpos_f.Y, minpos_f.Z, - maxpos_f.X, maxpos_f.Y+5, maxpos_f.Z, - sl.X, sl.Y, sl.Z); - noisebuf_ground_wetness.create( - get_ground_wetness_params(data->seed), - minpos_f.X, minpos_f.Y, minpos_f.Z, - maxpos_f.X, maxpos_f.Y+5, maxpos_f.Z, - sl.X, sl.Y, sl.Z); - } - /* - Make base ground level + Generate general ground level to full area */ - + { +#if 1 + TimeTaker timer1("Generating ground level"); + for(s16 x=node_min.X; x<=node_max.X; x++) for(s16 z=node_min.Z; z<=node_max.Z; z++) { // Node position - v2s16 p2d(x,z); + v2s16 p2d = v2s16(x,z); + + /* + Skip of already generated + */ + /*{ + v3s16 p(p2d.X, node_min.Y, p2d.Y); + if(vmanip.m_data[vmanip.m_area.index(p)].d != CONTENT_AIR) + continue; + }*/ + + // Ground height at this point + float surface_y_f = 0.0; + + // Use perlin noise for ground height + surface_y_f = base_rock_level_2d(data->seed, p2d); + + /*// Experimental stuff + { + float a = highlands_level_2d(data->seed, p2d); + if(a > surface_y_f) + surface_y_f = a; + }*/ + + // Convert to integer + s16 surface_y = (s16)surface_y_f; + + // Log it + if(surface_y > stone_surface_max_y) + stone_surface_max_y = surface_y; + + BiomeType bt = get_biome(data->seed, p2d); + /* + Fill ground with stone + */ { // Use fast index incrementing v3s16 em = vmanip.m_area.getExtent(); u32 i = vmanip.m_area.index(v3s16(p2d.X, node_min.Y, p2d.Y)); 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) - { - // First priority: make air and water. - // This avoids caves inside water. - if(all_is_ground_except_caves == false - && val_is_ground(noisebuf_ground.get(x,y,z), - v3s16(x,y,z), data->seed) == false) - { - if(y <= WATER_LEVEL) - vmanip.m_data[i] = MapNode(CONTENT_WATERSOURCE); + if(vmanip.m_data[i].getContent() == CONTENT_IGNORE){ + if(y <= surface_y){ + if(y > WATER_LEVEL && bt == BT_DESERT) + vmanip.m_data[i] = n_desert_stone; else - vmanip.m_data[i] = MapNode(CONTENT_AIR); + vmanip.m_data[i] = n_stone; + } else if(y <= WATER_LEVEL){ + vmanip.m_data[i] = MapNode(c_water_source); + } else { + vmanip.m_data[i] = MapNode(c_air); } - else if(noisebuf_cave.get(x,y,z) > CAVE_NOISE_THRESHOLD) - vmanip.m_data[i] = MapNode(CONTENT_AIR); - else - vmanip.m_data[i] = MapNode(CONTENT_STONE); } - - data->vmanip->m_area.add_y(em, i, 1); + vmanip.m_area.add_y(em, i, 1); } } } +#endif + + }//timer1 + + // Limit dirt flow area by 1 because mud is flown into neighbors. + assert(central_area_size.X == central_area_size.Z); + s16 mudflow_minpos = 0-max_spread_amount+1; + s16 mudflow_maxpos = central_area_size.X+max_spread_amount-2; /* - Add minerals + Loop this part, it will make stuff look older and newer nicely */ + const u32 age_loops = 2; + for(u32 i_age=0; i_ageseed+34329, 3, 0.50); + cave_amount = MYMAX(0.0, cave_amount); + u32 caves_count = cave_amount * volume_nodes / 50000; + u32 bruises_count = 1; + PseudoRandom ps(blockseed+21343); + PseudoRandom ps2(blockseed+1032); + if(ps.range(1, 6) == 1) + bruises_count = ps.range(0, ps.range(0, 2)); + if(get_biome(data->seed, v2s16(node_min.X, node_min.Y)) == BT_DESERT){ + caves_count /= 3; + bruises_count /= 3; + } + for(u32 jj=0; jj= caves_count); + s16 min_tunnel_diameter = 2; + s16 max_tunnel_diameter = ps.range(2,6); + int dswitchint = ps.range(1,14); + u16 tunnel_routepoints = 0; + int part_max_length_rs = 0; + if(large_cave){ + part_max_length_rs = ps.range(2,4); + tunnel_routepoints = ps.range(5, ps.range(15,30)); + min_tunnel_diameter = 5; + max_tunnel_diameter = ps.range(7, ps.range(8,24)); + } else { + part_max_length_rs = ps.range(2,9); + tunnel_routepoints = ps.range(10, ps.range(15,30)); + } + bool large_cave_is_flat = (ps.range(0,1) == 0); + + v3f main_direction(0,0,0); + + // Allowed route area size in nodes + v3s16 ar = central_area_size; + + // Area starting point in nodes + v3s16 of = node_min; + + // Allow a bit more + //(this should be more than the maximum radius of the tunnel) + //s16 insure = 5; // Didn't work with max_d = 20 + s16 insure = 10; + s16 more = max_spread_amount - max_tunnel_diameter/2 - insure; + ar += v3s16(1,0,1) * more * 2; + of -= v3s16(1,0,1) * more; + + s16 route_y_min = 0; + // Allow half a diameter + 7 over stone surface + s16 route_y_max = -of.Y + stone_surface_max_y + max_tunnel_diameter/2 + 7; + + /*// If caves, don't go through surface too often + if(large_cave == false) + route_y_max -= ps.range(0, max_tunnel_diameter*2);*/ + + // Limit maximum to area + route_y_max = rangelim(route_y_max, 0, ar.Y-1); + + if(large_cave) + { + /*// Minimum is at y=0 + route_y_min = -of.Y - 0;*/ + // Minimum is at y=max_tunnel_diameter/4 + //route_y_min = -of.Y + max_tunnel_diameter/4; + //s16 min = -of.Y + max_tunnel_diameter/4; + //s16 min = -of.Y + 0; + s16 min = 0; + if(node_min.Y < WATER_LEVEL && node_max.Y > WATER_LEVEL) + { + min = WATER_LEVEL - max_tunnel_diameter/3 - of.Y; + route_y_max = WATER_LEVEL + max_tunnel_diameter/3 - of.Y; + } + route_y_min = ps.range(min, min + max_tunnel_diameter); + route_y_min = rangelim(route_y_min, 0, route_y_max); + } + + /*dstream<<"route_y_min = "<seed, p2d) / 2.0 + 0.5; + + // Find ground level + s16 surface_y = find_stone_level(vmanip, p2d, ndef); + // Handle area not found + if(surface_y == vmanip.m_area.MinEdge.Y - 1) + continue; + + MapNode addnode(c_dirt); + BiomeType bt = get_biome(data->seed, p2d); + + if(bt == BT_DESERT) + addnode = MapNode(c_desert_sand); + + if(bt == BT_DESERT && surface_y + mud_add_amount <= WATER_LEVEL+1){ + addnode = MapNode(c_sand); + } else if(mud_add_amount <= 0){ + mud_add_amount = 1 - mud_add_amount; + addnode = MapNode(c_gravel); + } else if(bt == BT_NORMAL && get_have_beach(data->seed, p2d) && + surface_y + mud_add_amount <= WATER_LEVEL+2){ + addnode = MapNode(c_sand); + } + + if(bt == BT_DESERT){ + if(surface_y > 20){ + mud_add_amount = MYMAX(0, mud_add_amount - (surface_y - 20)/5); + } + } + /* - Add others + If topmost node is grass, change it to mud. + It might be if it was flown to there from a neighboring + chunk and then converted. */ { - u16 a = mineralrandom.range(0,15); - a = a*a*a; - u16 amount = 20 * a/1000; - for(s16 i=0; igetContent() == c_dirt_with_grass) + *n = MapNode(c_dirt); + } + + /* + Add mud on ground + */ + { + s16 mudcount = 0; + v3s16 em = vmanip.m_area.getExtent(); + s16 y_start = surface_y+1; + u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + for(s16 y=y_start; y<=node_max.Y; y++) { - s16 x = mineralrandom.range(node_min.X+1, node_max.X-1); - s16 y = mineralrandom.range(node_min.Y+1, node_max.Y-1); - s16 z = mineralrandom.range(node_min.Z+1, node_max.Z-1); + if(mudcount >= mud_add_amount) + break; + + MapNode &n = vmanip.m_data[i]; + n = addnode; + mudcount++; - u8 base_content = CONTENT_STONE; - MapNode new_content(CONTENT_IGNORE); - u32 sparseness = 6; + vmanip.m_area.add_y(em, i, 1); + } + } - if(noisebuf_ground_crumbleness.get(x,y+5,z) < -0.1) + } + + }//timer1 +#endif + + /* + Add blobs of dirt and gravel underground + */ + if(get_biome(data->seed, v2s16(node_min.X, node_min.Y)) == BT_NORMAL) + { + PseudoRandom pr(blockseed+983); + for(int i=0; i -32 && pr.range(0,1) == 0) + n1 = MapNode(c_dirt); + else + n1 = MapNode(c_gravel); + for(int x1=0; x1= node_min.Y) + { + + for(;; y--) + { + MapNode *n = NULL; + // Find mud + for(; y>=node_min.Y; y--) + { + n = &vmanip.m_data[i]; + //if(content_walkable(n->d)) + // break; + if(n->getContent() == c_dirt || + n->getContent() == c_dirt_with_grass || + n->getContent() == c_gravel) + break; + + vmanip.m_area.add_y(em, i, -1); + } + + // Stop if out of area + //if(vmanip.m_area.contains(i) == false) + if(y < node_min.Y) + break; + + /*// If not mud, do nothing to it + MapNode *n = &vmanip.m_data[i]; + if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS) + continue;*/ + + if(n->getContent() == c_dirt || + n->getContent() == c_dirt_with_grass) + { + // Make it exactly mud + n->setContent(c_dirt); + + /* + Don't flow it if the stuff under it is not mud + */ { - new_content = MapNode(CONTENT_STONE, MINERAL_COAL); + u32 i2 = i; + vmanip.m_area.add_y(em, i2, -1); + // Cancel if out of area + if(vmanip.m_area.contains(i2) == false) + continue; + MapNode *n2 = &vmanip.m_data[i2]; + if(n2->getContent() != c_dirt && + n2->getContent() != c_dirt_with_grass) + continue; } - else - { - if(noisebuf_ground_wetness.get(x,y+5,z) > 0.0) - new_content = MapNode(CONTENT_STONE, MINERAL_IRON); - /*if(noisebuf_ground_wetness.get(x,y,z) > 0.0) - vmanip.m_data[i] = MapNode(CONTENT_MUD); + } + + /*s16 recurse_count = 0; + mudflow_recurse:*/ + + v3s16 dirs4[4] = { + v3s16(0,0,1), // back + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(-1,0,0), // left + }; + + // Theck that upper is air or doesn't exist. + // Cancel dropping if upper keeps it in place + u32 i3 = i; + vmanip.m_area.add_y(em, i3, 1); + if(vmanip.m_area.contains(i3) == true + && ndef->get(vmanip.m_data[i3]).walkable) + { + continue; + } + + // Drop mud on side + + for(u32 di=0; di<4; di++) + { + v3s16 dirp = dirs4[di]; + u32 i2 = i; + // Move to side + vmanip.m_area.add_p(em, i2, dirp); + // Fail if out of area + if(vmanip.m_area.contains(i2) == false) + continue; + // Check that side is air + MapNode *n2 = &vmanip.m_data[i2]; + if(ndef->get(*n2).walkable) + continue; + // Check that under side is air + vmanip.m_area.add_y(em, i2, -1); + if(vmanip.m_area.contains(i2) == false) + continue; + n2 = &vmanip.m_data[i2]; + if(ndef->get(*n2).walkable) + continue; + /*// Check that under that is air (need a drop of 2) + vmanip.m_area.add_y(em, i2, -1); + if(vmanip.m_area.contains(i2) == false) + continue; + n2 = &vmanip.m_data[i2]; + if(content_walkable(n2->d)) + continue;*/ + // Loop further down until not air + bool dropped_to_unknown = false; + do{ + vmanip.m_area.add_y(em, i2, -1); + n2 = &vmanip.m_data[i2]; + // if out of known area + if(vmanip.m_area.contains(i2) == false + || n2->getContent() == CONTENT_IGNORE){ + dropped_to_unknown = true; + break; + } + }while(ndef->get(*n2).walkable == false); + // Loop one up so that we're in air + vmanip.m_area.add_y(em, i2, 1); + n2 = &vmanip.m_data[i2]; + + bool old_is_water = (n->getContent() == c_water_source); + // Move mud to new place + if(!dropped_to_unknown) { + *n2 = *n; + // Set old place to be air (or water) + if(old_is_water) + *n = MapNode(c_water_source); else - vmanip.m_data[i] = MapNode(CONTENT_SAND);*/ + *n = MapNode(CONTENT_AIR); } - /*else if(noisebuf_ground_crumbleness.get(x,y,z) > 0.1) - { - }*/ - if(new_content.d != CONTENT_IGNORE) + // Done + break; + } + } + } + } + + } + + }//timer1 +#endif + + } // Aging loop + /*********************** + END OF AGING LOOP + ************************/ + + /* + Add top and bottom side of water to transforming_liquid queue + */ + + for(s16 x=full_node_min.X; x<=full_node_max.X; x++) + for(s16 z=full_node_min.Z; z<=full_node_max.Z; z++) + { + // Node position + v2s16 p2d(x,z); + { + bool water_found = false; + // Use fast index incrementing + v3s16 em = vmanip.m_area.getExtent(); + 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(y == full_node_max.Y){ + water_found = + (vmanip.m_data[i].getContent() == c_water_source || + vmanip.m_data[i].getContent() == c_lava_source); + } + else if(water_found == false) { - for(u16 i=0; i<27; i++) + if(vmanip.m_data[i].getContent() == c_water_source || + vmanip.m_data[i].getContent() == c_lava_source) { - 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(mineralrandom.next()%sparseness == 0) - vmanip.m_data[vi] = new_content; - } + v3s16 p = v3s16(p2d.X, y, p2d.Y); + data->transforming_liquid.push_back(p); + water_found = true; } } + else + { + // 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].getContent() != c_water_source || + vmanip.m_data[i+1].getContent() != c_lava_source) + { + v3s16 p = v3s16(p2d.X, y+1, p2d.Y); + data->transforming_liquid.push_back(p); + water_found = false; + } + } + + vmanip.m_area.add_y(em, i, -1); } } + } + + /* + Grow grass + */ + + for(s16 x=full_node_min.X; x<=full_node_max.X; x++) + for(s16 z=full_node_min.Z; z<=full_node_max.Z; z++) + { + // Node position in 2d + v2s16 p2d = v2s16(x,z); + /* - Add coal + Find the lowest surface to which enough light ends up + to make grass grow. + + Basically just wait until not air and not leaves. */ - //for(s16 i=0; i < MYMAX(0, 50 - abs(node_min.Y+8 - (-30))); i++) - //for(s16 i=0; i<50; i++) - u16 coal_amount = 30; - u16 coal_rareness = 60 / coal_amount; - if(coal_rareness == 0) - coal_rareness = 1; - if(mineralrandom.next()%coal_rareness == 0) + s16 surface_y = 0; { - u16 a = mineralrandom.next() % 16; - u16 amount = coal_amount * a*a*a / 1000; - for(s16 i=0; i=full_node_min.Y; y--) { - s16 x = mineralrandom.range(node_min.X+1, node_max.X-1); - s16 y = mineralrandom.range(node_min.Y+1, node_max.Y-1); - s16 z = mineralrandom.range(node_min.Z+1, node_max.Z-1); - for(u16 i=0; i<27; i++) + MapNode &n = vmanip.m_data[i]; + if(ndef->get(n).param_type != CPT_LIGHT + || ndef->get(n).liquid_type != LIQUID_NONE) + break; + vmanip.m_area.add_y(em, i, -1); + } + if(y >= full_node_min.Y) + surface_y = y; + else + surface_y = full_node_min.Y; + } + + u32 i = vmanip.m_area.index(p2d.X, surface_y, p2d.Y); + MapNode *n = &vmanip.m_data[i]; + if(n->getContent() == c_dirt){ + // Well yeah, this can't be overground... + if(surface_y < WATER_LEVEL - 20) + continue; + n->setContent(c_dirt_with_grass); + } + } + + /* + Generate some trees + */ + assert(central_area_size.X == central_area_size.Z); + { + // Divide area into parts + s16 div = 8; + s16 sidelen = central_area_size.X / div; + double area = sidelen * sidelen; + for(s16 x0=0; x0seed, p2d_center); + // Put trees in random places on part of division + for(u32 i=0; i node_max.Y - 6) + continue; + v3s16 p(x,y,z); + /* + Trees grow only on mud and grass + */ { - 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(mineralrandom.next()%8 == 0) - vmanip.m_data[vi] = MapNode(CONTENT_STONE, MINERAL_COAL); + u32 i = vmanip.m_area.index(v3s16(p)); + MapNode *n = &vmanip.m_data[i]; + if(n->getContent() != c_dirt + && n->getContent() != c_dirt_with_grass) + continue; } + p.Y++; + // Make a tree + make_tree(vmanip, p, false, ndef); } } - /* - Add iron - */ - u16 iron_amount = 8; - u16 iron_rareness = 60 / iron_amount; - if(iron_rareness == 0) - iron_rareness = 1; - if(mineralrandom.next()%iron_rareness == 0) + } + +#if 0 + /* + Make base ground level + */ + + for(s16 x=node_min.X; x<=node_max.X; x++) + for(s16 z=node_min.Z; z<=node_max.Z; z++) + { + // Node position + v2s16 p2d(x,z); { - u16 a = mineralrandom.next() % 16; - u16 amount = iron_amount * a*a*a / 1000; - for(s16 i=0; iseed) == false) + { + if(y <= WATER_LEVEL) + vmanip.m_data[i] = n_water_source; + else + vmanip.m_data[i] = n_air; + } + else if(noisebuf_cave.get(x,y,z) > CAVE_NOISE_THRESHOLD) + vmanip.m_data[i] = n_air; + else + vmanip.m_data[i] = n_stone; } + + vmanip->m_area.add_y(em, i, 1); } } } @@ -1614,23 +2299,33 @@ 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)); } } - data->vmanip->m_area.add_y(em, i, -1); + vmanip->m_area.add_y(em, i, -1); } } } @@ -1650,7 +2345,7 @@ void make_block(BlockMakeData *data) && node_min.Y < approx_groundlevel) { // Dungeon generator doesn't modify places which have this set - data->vmanip->clearFlag(VMANIP_FLAG_DUNGEON_INSIDE + vmanip->clearFlag(VMANIP_FLAG_DUNGEON_INSIDE | VMANIP_FLAG_DUNGEON_PRESERVE); // Set all air and water to be untouchable to make dungeons open @@ -1666,11 +2361,11 @@ 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); + vmanip->m_area.add_y(em, i, -1); } } } @@ -1678,7 +2373,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++) @@ -1699,23 +2394,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(c_dirt); }*/ - data->vmanip->m_area.add_y(em, i, -1); + 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 @@ -1735,7 +2441,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); @@ -1747,7 +2453,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); @@ -1755,7 +2461,7 @@ void make_block(BlockMakeData *data) } } - data->vmanip->m_area.add_y(em, i, -1); + vmanip->m_area.add_y(em, i, -1); } } } @@ -1777,36 +2483,29 @@ void make_block(BlockMakeData *data) // Node position v2s16 p2d(x,z); { - bool possibly_have_sand = get_have_sand(data->seed, p2d); + bool possibly_have_sand = get_have_beach(data->seed, p2d); bool have_sand = false; u32 current_depth = 0; bool air_detected = false; 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 @@ -1817,24 +2516,21 @@ void make_block(BlockMakeData *data) { if(have_sand) { - if (have_clay) - vmanip.m_data[i] = MapNode(CONTENT_CLAY); - else - vmanip.m_data[i] = MapNode(CONTENT_SAND); + vmanip.m_data[i] = MapNode(c_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(c_dirt_with_grass); #endif else - vmanip.m_data[i] = MapNode(CONTENT_MUD); + vmanip.m_data[i] = MapNode(c_dirt); } 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() == c_dirt + || vmanip.m_data[i].getContent() == c_dirt_with_grass) + vmanip.m_data[i] = MapNode(c_stone); } current_depth++; @@ -1845,24 +2541,32 @@ void make_block(BlockMakeData *data) else if(current_depth != 0) break; - data->vmanip->m_area.add_y(em, i, -1); + vmanip->m_area.add_y(em, i, -1); } } } /* - 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); + u32 tree_count = gen_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; ivmanip, v2s16(x,z)); + //s16 y = find_ground_level(vmanip, v2s16(x,z)); s16 y = find_ground_level_from_noise(data->seed, v2s16(x,z), 4); // Don't make a tree under water level if(y < WATER_LEVEL) @@ -1878,9 +2582,9 @@ void make_block(BlockMakeData *data) 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(n->d != CONTENT_AIR && n->d != CONTENT_WATERSOURCE && n->d != CONTENT_IGNORE) + u32 i = vmanip->m_area.index(p); + MapNode *n = &vmanip->m_data[i]; + if(n->getContent() != CONTENT_AIR && n->getContent() != c_water_source && n->getContent() != CONTENT_IGNORE) { found = true; break; @@ -1891,30 +2595,90 @@ void make_block(BlockMakeData *data) continue; { - u32 i = data->vmanip->m_area.index(p); - MapNode *n = &data->vmanip->m_data[i]; + u32 i = vmanip->m_area.index(p); + MapNode *n = &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() == c_dirt_with_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; iseed, 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 = vmanip->m_area.index(p); + MapNode *n = &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)] = c_dirt; + p.Y++;*/ + if(vmanip.m_area.contains(p)) + vmanip.m_data[vmanip.m_area.index(p)] = c_junglegrass; } } @@ -1923,7 +2687,7 @@ void make_block(BlockMakeData *data) Add some kind of random stones */ - u32 random_stone_count = block_area_nodes * + u32 random_stone_count = gen_area_nodes * randomstone_amount_2d(data->seed, p2d_center); // Put in random places on part of division for(u32 i=0; ivmanip->m_area.index(v3s16(p)); - MapNode *n = &data->vmanip->m_data[i]; - if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS) + u32 i = vmanip->m_area.index(v3s16(p)); + MapNode *n = &vmanip->m_data[i]; + if(n->getContent() != c_dirt && n->getContent() != c_dirt_with_grass) continue; }*/ // Will be placed one higher p.Y++; // Add it - make_randomstone(data->vmanip, p); + make_randomstone(vmanip, p); } #endif @@ -1957,7 +2721,7 @@ void make_block(BlockMakeData *data) Add larger stones */ - u32 large_stone_count = block_area_nodes * + u32 large_stone_count = gen_area_nodes * largestone_amount_2d(data->seed, p2d_center); //u32 large_stone_count = 1; // Put in random places on part of division @@ -1975,25 +2739,193 @@ void make_block(BlockMakeData *data) v3s16 p(x,y,z); // Filter placement /*{ - 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) + u32 i = vmanip->m_area.index(v3s16(p)); + MapNode *n = &vmanip->m_data[i]; + if(n->getContent() != c_dirt && n->getContent() != c_dirt_with_grass) continue; }*/ // Will be placed one lower p.Y--; // Add it - make_largestone(data->vmanip, p); + make_largestone(vmanip, p); } #endif } + /* + Add minerals + */ + + { + PseudoRandom mineralrandom(blockseed); + + /* + Add meseblocks + */ + for(s16 i=0; i 0.0) + new_content = MapNode(c_stone_with_iron); + /*if(noisebuf_ground_wetness.get(x,y,z) > 0.0) + vmanip.m_data[i] = MapNode(c_dirt); + else + vmanip.m_data[i] = MapNode(c_sand);*/ + } + /*else if(noisebuf_ground_crumbleness.get(x,y,z) > 0.1) + { + }*/ + + 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].getContent() == base_content) + { + if(mineralrandom.next()%sparseness == 0) + vmanip.m_data[vi] = new_content; + } + } + } + } + } + /* + Add coal + */ + //for(s16 i=0; i < MYMAX(0, 50 - abs(node_min.Y+8 - (-30))); i++) + //for(s16 i=0; i<50; i++) + u16 coal_amount = 30; + u16 coal_rareness = 60 / coal_amount; + if(coal_rareness == 0) + coal_rareness = 1; + if(mineralrandom.next()%coal_rareness == 0) + { + u16 a = mineralrandom.next() % 16; + u16 amount = coal_amount * a*a*a / 1000; + for(s16 i=0; i light_sources; + core::map unlight_from; + + voxalgo::clearLightAndCollectSources(vmanip, a, bank, ndef, + light_sources, unlight_from); + + bool inexistent_top_provides_sunlight = !block_is_underground; + voxalgo::SunlightPropagateResult res = voxalgo::propagateSunlight( + vmanip, a, inexistent_top_provides_sunlight, + light_sources, ndef); + // TODO: Do stuff according to bottom_sunlight_valid + + vmanip.unspreadLight(bank, unlight_from, light_sources, ndef); + + vmanip.spreadLight(bank, light_sources, ndef); + } + } } BlockMakeData::BlockMakeData(): no_op(false), vmanip(NULL), - seed(0) + seed(0), + nodedef(NULL) {} BlockMakeData::~BlockMakeData()