X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmapgen_v6.cpp;h=0b419617d22bb2d8a54986c1600386fa3fa4ec65;hb=8800896824d609c754eee38d3720a112f4216e57;hp=b60758310a18f8a1b5cd95063980c66bfa7a44ca;hpb=d10223254ab9363eb1b6f8cc7aa6b99965940cee;p=dragonfireclient.git diff --git a/src/mapgen_v6.cpp b/src/mapgen_v6.cpp index b60758310..0b419617d 100644 --- a/src/mapgen_v6.cpp +++ b/src/mapgen_v6.cpp @@ -45,8 +45,6 @@ NoiseParams nparams_v6_def_steepness = {0.85, 0.5, v3f(125.0, 125.0, 125.0), -932, 5, 0.7}; NoiseParams nparams_v6_def_height_select = {0.5, 1.0, v3f(250.0, 250.0, 250.0), 4213, 5, 0.69}; -NoiseParams nparams_v6_def_trees = - {0.0, 1.0, v3f(125.0, 125.0, 125.0), 2, 4, 0.66}; NoiseParams nparams_v6_def_mud = {AVERAGE_MUD_AMOUNT, 2.0, v3f(200.0, 200.0, 200.0), 91013, 3, 0.55}; NoiseParams nparams_v6_def_beach = @@ -55,14 +53,21 @@ NoiseParams nparams_v6_def_biome = {0.0, 1.0, v3f(250.0, 250.0, 250.0), 9130, 3, 0.50}; NoiseParams nparams_v6_def_cave = {6.0, 6.0, v3f(250.0, 250.0, 250.0), 34329, 3, 0.50}; +NoiseParams nparams_v6_def_humidity = + {0.5, 0.5, v3f(500.0, 500.0, 500.0), 72384, 4, 0.66}; +NoiseParams nparams_v6_def_trees = + {0.0, 1.0, v3f(125.0, 125.0, 125.0), 2, 4, 0.66}; +NoiseParams nparams_v6_def_apple_trees = + {0.0, 1.0, v3f(100.0, 100.0, 100.0), 342902, 3, 0.45}; /////////////////////////////////////////////////////////////////////////////// -MapgenV6::MapgenV6(int mapgenid, MapgenV6Params *params) { +MapgenV6::MapgenV6(int mapgenid, MapgenV6Params *params, EmergeManager *emerge) { this->generating = false; this->id = mapgenid; + this->emerge = emerge; this->seed = (int)params->seed; this->water_level = params->water_level; @@ -74,13 +79,15 @@ MapgenV6::MapgenV6(int mapgenid, MapgenV6Params *params) { this->ystride = csize.X; //////fix this - np_cave = params->np_cave; + np_cave = params->np_cave; + np_humidity = params->np_humidity; + np_trees = params->np_trees; + np_apple_trees = params->np_apple_trees; noise_terrain_base = new Noise(params->np_terrain_base, seed, csize.X, csize.Y); noise_terrain_higher = new Noise(params->np_terrain_higher, seed, csize.X, csize.Y); noise_steepness = new Noise(params->np_steepness, seed, csize.X, csize.Y); noise_height_select = new Noise(params->np_height_select, seed, csize.X, csize.Y); - noise_trees = new Noise(params->np_trees, seed, csize.X, csize.Y); noise_mud = new Noise(params->np_mud, seed, csize.X, csize.Y); noise_beach = new Noise(params->np_beach, seed, csize.X, csize.Y); noise_biome = new Noise(params->np_biome, seed, csize.X, csize.Y); @@ -92,7 +99,6 @@ MapgenV6::~MapgenV6() { delete noise_terrain_higher; delete noise_steepness; delete noise_height_select; - delete noise_trees; delete noise_mud; delete noise_beach; delete noise_biome; @@ -234,12 +240,6 @@ int MapgenV6::getGroundLevelAtPoint(v2s16 p) { //////////////////////// Noise functions -float MapgenV6::getTreeAmount(v2s16 p) { - int index = (p.Y - node_min.Z) * ystride + (p.X - node_min.X); - return getTreeAmount(index); -} - - float MapgenV6::getMudAmount(v2s16 p) { int index = (p.Y - node_min.Z) * ystride + (p.X - node_min.X); return getMudAmount(index); @@ -258,13 +258,30 @@ BiomeType MapgenV6::getBiome(v2s16 p) { } -float MapgenV6::getTreeAmount(int index) +float MapgenV6::getHumidity(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;*/ + + float noise = NoisePerlin2D(np_humidity, p.X, p.Y, seed); + + if (noise < 0.0) + noise = 0.0; + if (noise > 1.0) + noise = 1.0; + return noise; +} + + +float MapgenV6::getTreeAmount(v2s16 p) { /*double noise = noise2d_perlin( 0.5+(float)p.X/125, 0.5+(float)p.Y/125, seed+2, 4, 0.66);*/ - float noise = noise_trees->result[index]; + float noise = NoisePerlin2D(np_trees, p.X, p.Y, seed); float zeroval = -0.39; if (noise < zeroval) return 0; @@ -273,6 +290,18 @@ float MapgenV6::getTreeAmount(int index) } +bool MapgenV6::getHaveAppleTree(v2s16 p) +{ + /*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;*/ + + float noise = NoisePerlin2D(np_apple_trees, p.X, p.Y, seed); + + return noise > 0.2; +} + + float MapgenV6::getMudAmount(int index) { if (flags & MG_FLAT) @@ -394,6 +423,8 @@ void MapgenV6::makeChunk(BlockMakeData *data) { // Generate general ground level to full area stone_surface_max_y = generateGround(); + generateSomething(); + const s16 max_spread_amount = MAP_BLOCKSIZE; // Limit dirt flow area by 1 because mud is flown into neighbors. s16 mudflow_minpos = -max_spread_amount + 1; @@ -429,12 +460,18 @@ void MapgenV6::makeChunk(BlockMakeData *data) { // Grow grass growGrass(); - // Generate some trees + // Generate some trees, and add grass, if a jungle if (flags & MG_TREES) - placeTrees(); + placeTreesAndJungleGrass(); + + // Generate the registered ores + for (unsigned int i = 0; i != emerge->ores.size(); i++) { + Ore *ore = emerge->ores[i]; + ore->generate(this, blockseed + i, node_min, node_max); + } // Calculate lighting - updateLighting(node_min, node_max); + calcLighting(node_min, node_max); this->generating = false; } @@ -464,20 +501,13 @@ void MapgenV6::calculateNoise() { noise_height_select->perlinMap2D( x + 0.5 * noise_height_select->np->spread.X, z + 0.5 * noise_height_select->np->spread.Z); - } - - if (flags & MG_TREES) { - noise_trees->perlinMap2D( - x + 0.5 * noise_trees->np->spread.X, - z + 0.5 * noise_trees->np->spread.Z); - } - - if (!(flags & MG_FLAT)) { + noise_mud->perlinMap2D( x + 0.5 * noise_mud->np->spread.X, z + 0.5 * noise_mud->np->spread.Z); noise_mud->transformNoiseMap(); } + noise_beach->perlinMap2D( x + 0.2 * noise_beach->np->spread.X, z + 0.7 * noise_beach->np->spread.Z); @@ -761,12 +791,26 @@ void MapgenV6::addDirtGravelBlobs() { } -void MapgenV6::placeTrees() { +void MapgenV6::placeTreesAndJungleGrass() { + //TimeTaker t("placeTrees"); + if (node_max.Y < water_level) + return; + + PseudoRandom grassrandom(blockseed + 53); + content_t c_junglegrass = ndef->getId("mapgen_junglegrass"); + // if we don't have junglegrass, don't place cignore... that's bad + if (c_junglegrass == CONTENT_IGNORE) + c_junglegrass = CONTENT_AIR; + MapNode n_junglegrass(c_junglegrass); + v3s16 em = vm->m_area.getExtent(); + // Divide area into parts s16 div = 8; s16 sidelen = central_area_size.X / div; double area = sidelen * sidelen; + // N.B. We must add jungle grass first, since tree leaves will + // obstruct the ground, giving us a false ground level for (s16 z0 = 0; z0 < div; z0++) for (s16 x0 = 0; x0 < div; x0++) { // Center position of part of division @@ -784,8 +828,40 @@ void MapgenV6::placeTrees() { node_min.X + sidelen + sidelen * x0 - 1, node_min.Z + sidelen + sidelen * z0 - 1 ); - // Amount of trees - u32 tree_count = area * getTreeAmount(p2d_center); /////////////optimize this! + + // Amount of trees, jungle area + u32 tree_count = area * getTreeAmount(p2d_center); + + float humidity; + bool is_jungle = false; + if (flags & MGV6_JUNGLES) { + humidity = getHumidity(p2d_center); + if (humidity > 0.75) { + is_jungle = true; + tree_count *= 4; + } + } + + // Add jungle grass + if (is_jungle) { + u32 grass_count = 5 * humidity * tree_count; + for (u32 i = 0; i < grass_count; i++) { + s16 x = grassrandom.range(p2d_min.X, p2d_max.X); + s16 z = grassrandom.range(p2d_min.Y, p2d_max.Y); + + s16 y = find_ground_level(v2s16(x, z)); ////////////////optimize this! + if (y < water_level || y < node_min.Y || y > node_max.Y) + continue; + + u32 vi = vm->m_area.index(x, y, z); + // place on dirt_with_grass, since we know it is exposed to sunlight + if (vm->m_data[vi].getContent() == c_dirt_with_grass) { + vm->m_area.add_y(em, vi, 1); + vm->m_data[vi] = n_junglegrass; + } + } + } + // Put trees in random places on part of division for (u32 i = 0; i < tree_count; i++) { s16 x = myrand_range(p2d_min.X, p2d_max.X); @@ -806,10 +882,18 @@ void MapgenV6::placeTrees() { continue; } p.Y++; + // Make a tree - treegen::make_tree(*vm, p, false, ndef, myrand()); + if (is_jungle) { + treegen::make_jungletree(*vm, p, ndef, myrand()); + } else { + bool is_apple_tree = (myrand_range(0, 3) == 0) && + getHaveAppleTree(v2s16(x, z)); + treegen::make_tree(*vm, p, is_apple_tree, ndef, myrand()); + } } } + //printf("placeTreesAndJungleGrass: %dms\n", t.stop()); } @@ -842,6 +926,25 @@ void MapgenV6::growGrass() { } +void MapgenV6::defineCave(Cave &cave, PseudoRandom ps, + v3s16 node_min, bool large_cave) { + cave.min_tunnel_diameter = 2; + cave.max_tunnel_diameter = ps.range(2,6); + cave.dswitchint = ps.range(1,14); + cave.flooded = true; //large_cave && ps.range(0,4); + if(large_cave){ + cave.part_max_length_rs = ps.range(2,4); + cave.tunnel_routepoints = ps.range(5, ps.range(15,30)); + cave.min_tunnel_diameter = 5; + cave.max_tunnel_diameter = ps.range(7, ps.range(8,24)); + } else { + cave.part_max_length_rs = ps.range(2,9); + cave.tunnel_routepoints = ps.range(10, ps.range(15,30)); + } + cave.large_cave_is_flat = (ps.range(0,1) == 0); +} + + void MapgenV6::generateCaves(int max_stone_y) { // 24ms @cs=8 //TimeTaker timer1("caves"); @@ -874,21 +977,9 @@ void MapgenV6::generateCaves(int max_stone_y) { break;*/ bool large_cave = (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); + + Cave cave; + defineCave(cave, ps, node_min, large_cave); v3f main_direction(0,0,0); @@ -901,13 +992,13 @@ void MapgenV6::generateCaves(int max_stone_y) { // Allow a bit more //(this should be more than the maximum radius of the tunnel) s16 insure = 10; - s16 more = max_spread_amount - max_tunnel_diameter / 2 - insure; + s16 more = max_spread_amount - cave.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 + max_stone_y + max_tunnel_diameter/2 + 7; + s16 route_y_max = -of.Y + max_stone_y + cave.max_tunnel_diameter/2 + 7; // Limit maximum to area route_y_max = rangelim(route_y_max, 0, ar.Y-1); @@ -917,10 +1008,10 @@ void MapgenV6::generateCaves(int max_stone_y) { 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; + min = water_level - cave.max_tunnel_diameter/3 - of.Y; + route_y_max = water_level + cave.max_tunnel_diameter/3 - of.Y; } - route_y_min = ps.range(min, min + max_tunnel_diameter); + route_y_min = ps.range(min, min + cave.max_tunnel_diameter); route_y_min = rangelim(route_y_min, 0, route_y_max); } @@ -948,9 +1039,9 @@ void MapgenV6::generateCaves(int max_stone_y) { Generate some tunnel starting from orp */ - for(u16 j=0; j 7 && abs(y0) >= rs/3) continue; @@ -1072,13 +1163,13 @@ void MapgenV6::generateCaves(int max_stone_y) { u32 i = vm->m_area.index(p); if(large_cave) { - if (full_node_min.Y < water_level && + if (cave.flooded && full_node_min.Y < water_level && full_node_max.Y > water_level) { if (p.Y <= water_level) vm->m_data[i] = waternode; else vm->m_data[i] = airnode; - } else if (full_node_max.Y < water_level) { + } else if (cave.flooded && full_node_max.Y < water_level) { if (p.Y < startp.Y - 2) vm->m_data[i] = lavanode; else