From ae929ce2fdcfcfc95cffece35f3d38ea4d96dd9f Mon Sep 17 00:00:00 2001 From: paramat Date: Mon, 23 Jan 2017 08:07:34 +0000 Subject: Dungeons: Add nodebox stairs to desert and sandstone dungeons Desert and sandstone dungeons have 2 node wide corridors. Previously, nodebox stairs were disabled because dungeon generation code did not support nodebox stairs wider than 1 node, now it does. Add 'stair desert stone' content id to MappgenBasic. Requires 'mapgen stair desert stone' to be added to Minetest Game. --- src/mapgen.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'src/mapgen.cpp') diff --git a/src/mapgen.cpp b/src/mapgen.cpp index fd4f5858f..e42fc7467 100644 --- a/src/mapgen.cpp +++ b/src/mapgen.cpp @@ -604,6 +604,7 @@ MapgenBasic::MapgenBasic(int mapgenid, MapgenParams *params, EmergeManager *emer c_cobble = ndef->getId("mapgen_cobble"); c_stair_cobble = ndef->getId("mapgen_stair_cobble"); c_mossycobble = ndef->getId("mapgen_mossycobble"); + c_stair_desert_stone = ndef->getId("mapgen_stair_desert_stone"); c_sandstonebrick = ndef->getId("mapgen_sandstonebrick"); c_stair_sandstonebrick = ndef->getId("mapgen_stair_sandstonebrick"); @@ -867,7 +868,7 @@ void MapgenBasic::generateDungeons(s16 max_stone_y, MgStoneType stone_type) case MGSTONE_DESERT_STONE: dp.c_wall = c_desert_stone; dp.c_alt_wall = CONTENT_IGNORE; - dp.c_stair = c_desert_stone; + dp.c_stair = c_stair_desert_stone; dp.diagonal_dirs = true; dp.holesize = v3s16(2, 3, 2); @@ -877,7 +878,7 @@ void MapgenBasic::generateDungeons(s16 max_stone_y, MgStoneType stone_type) case MGSTONE_SANDSTONE: dp.c_wall = c_sandstonebrick; dp.c_alt_wall = CONTENT_IGNORE; - dp.c_stair = c_sandstonebrick; + dp.c_stair = c_stair_sandstonebrick; dp.diagonal_dirs = false; dp.holesize = v3s16(2, 2, 2); -- cgit v1.2.3 From 2d03cfd24c89c66e5ace4f335dae42f7c2c84f6b Mon Sep 17 00:00:00 2001 From: paramat Date: Sat, 4 Feb 2017 04:04:03 +0000 Subject: MapgenBasic node resolver: Various fixes Add a fallback node for stair_desert_stone to avoid ignore placed in Minimal subgame desert dungeons. Don't allow river_water_source to fallback to water_source as river water needs to be non-renewable and have a short flow range. Make stair_sandstonebrick fall back to sandstonebrick instead of sandstone. Re-order some lines. Add a comment. --- src/mapgen.cpp | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) (limited to 'src/mapgen.cpp') diff --git a/src/mapgen.cpp b/src/mapgen.cpp index e42fc7467..00ae917a1 100644 --- a/src/mapgen.cpp +++ b/src/mapgen.cpp @@ -587,23 +587,23 @@ MapgenBasic::MapgenBasic(int mapgenid, MapgenParams *params, EmergeManager *emer //// Look up some commonly used content c_stone = ndef->getId("mapgen_stone"); - c_water_source = ndef->getId("mapgen_water_source"); c_desert_stone = ndef->getId("mapgen_desert_stone"); c_sandstone = ndef->getId("mapgen_sandstone"); + c_water_source = ndef->getId("mapgen_water_source"); c_river_water_source = ndef->getId("mapgen_river_water_source"); // Fall back to more basic content if not defined + // river_water_source cannot fallback to water_source because river water + // needs to be non-renewable and have a short flow range. if (c_desert_stone == CONTENT_IGNORE) c_desert_stone = c_stone; if (c_sandstone == CONTENT_IGNORE) c_sandstone = c_stone; - if (c_river_water_source == CONTENT_IGNORE) - c_river_water_source = c_water_source; //// Content used for dungeon generation c_cobble = ndef->getId("mapgen_cobble"); - c_stair_cobble = ndef->getId("mapgen_stair_cobble"); c_mossycobble = ndef->getId("mapgen_mossycobble"); + c_stair_cobble = ndef->getId("mapgen_stair_cobble"); c_stair_desert_stone = ndef->getId("mapgen_stair_desert_stone"); c_sandstonebrick = ndef->getId("mapgen_sandstonebrick"); c_stair_sandstonebrick = ndef->getId("mapgen_stair_sandstonebrick"); @@ -613,10 +613,12 @@ MapgenBasic::MapgenBasic(int mapgenid, MapgenParams *params, EmergeManager *emer c_mossycobble = c_cobble; if (c_stair_cobble == CONTENT_IGNORE) c_stair_cobble = c_cobble; + if (c_stair_desert_stone == CONTENT_IGNORE) + c_stair_desert_stone = c_desert_stone; if (c_sandstonebrick == CONTENT_IGNORE) c_sandstonebrick = c_sandstone; if (c_stair_sandstonebrick == CONTENT_IGNORE) - c_stair_sandstonebrick = c_sandstone; + c_stair_sandstonebrick = c_sandstonebrick; } -- cgit v1.2.3 From a901a56859e5beaec6a542eae037dc0b736a20e3 Mon Sep 17 00:00:00 2001 From: paramat Date: Tue, 21 Feb 2017 01:56:34 +0000 Subject: Dungeongen: Add and improve parameters Add: Bool for 'only_in_ground'. Min and max corridor length. Min and max room size with X, Y, Z components. Min and max large room size with X, Y, Z components. 'only_in_ground = false' allows core mapgens to create structures in air and water using dungeongen. Corridor length parameters replace a fixed random range. Room size parameters replace the former system where one parameter 'roomsize' was added to fixed random ranges. All parameters are set for no change to current dungeon behaviour. Remove some now-redundant and long-unused code. --- src/dungeongen.cpp | 94 ++++++++++++++++++++++++++---------------------------- src/dungeongen.h | 8 ++++- src/mapgen.cpp | 80 +++++++++++++++++++++++++++------------------- src/mapgen_v6.cpp | 63 +++++++++++++++++++++--------------- 4 files changed, 137 insertions(+), 108 deletions(-) (limited to 'src/mapgen.cpp') diff --git a/src/dungeongen.cpp b/src/dungeongen.cpp index 7825e9e2c..6cef3f88d 100644 --- a/src/dungeongen.cpp +++ b/src/dungeongen.cpp @@ -52,6 +52,7 @@ DungeonGen::DungeonGen(INodeDefManager *ndef, if (dparams) { memcpy(&dp, dparams, sizeof(dp)); } else { + // Default dungeon parameters dp.seed = 0; dp.c_water = ndef->getId("mapgen_water_source"); @@ -63,14 +64,20 @@ DungeonGen::DungeonGen(INodeDefManager *ndef, if (dp.c_river_water == CONTENT_IGNORE) dp.c_river_water = ndef->getId("mapgen_water_source"); - dp.diagonal_dirs = false; - dp.holesize = v3s16(1, 2, 1); - dp.roomsize = v3s16(0, 0, 0); - dp.rooms_min = 2; - dp.rooms_max = 16; - dp.y_min = -MAX_MAP_GENERATION_LIMIT; - dp.y_max = MAX_MAP_GENERATION_LIMIT; - dp.notifytype = GENNOTIFY_DUNGEON; + dp.diagonal_dirs = false; + dp.only_in_ground = true; + dp.holesize = v3s16(1, 2, 1); + dp.corridor_len_min = 1; + dp.corridor_len_max = 13; + dp.room_size_min = v3s16(4, 4, 4); + dp.room_size_max = v3s16(8, 6, 8); + dp.room_size_large_min = v3s16(8, 8, 8); + dp.room_size_large_max = v3s16(16, 16, 16); + dp.rooms_min = 2; + dp.rooms_max = 16; + dp.y_min = -MAX_MAP_GENERATION_LIMIT; + dp.y_max = MAX_MAP_GENERATION_LIMIT; + dp.notifytype = GENNOTIFY_DUNGEON; dp.np_density = nparams_dungeon_density; dp.np_alt_wall = nparams_dungeon_alt_wall; @@ -97,16 +104,19 @@ void DungeonGen::generate(MMVManip *vm, u32 bseed, v3s16 nmin, v3s16 nmax) // Dungeon generator doesn't modify places which have this set vm->clearFlag(VMANIP_FLAG_DUNGEON_INSIDE | VMANIP_FLAG_DUNGEON_PRESERVE); - // Set all air and water to be untouchable - // to make dungeons open to caves and open air - for (s16 z = nmin.Z; z <= nmax.Z; z++) { - for (s16 y = nmin.Y; y <= nmax.Y; y++) { - u32 i = vm->m_area.index(nmin.X, y, z); - for (s16 x = nmin.X; x <= nmax.X; x++) { - content_t c = vm->m_data[i].getContent(); - if (c == CONTENT_AIR || c == dp.c_water || c == dp.c_river_water) - vm->m_flags[i] |= VMANIP_FLAG_DUNGEON_PRESERVE; - i++; + if (dp.only_in_ground) { + // Set all air and water to be untouchable + // to make dungeons open to caves and open air + for (s16 z = nmin.Z; z <= nmax.Z; z++) { + for (s16 y = nmin.Y; y <= nmax.Y; y++) { + u32 i = vm->m_area.index(nmin.X, y, z); + for (s16 x = nmin.X; x <= nmax.X; x++) { + content_t c = vm->m_data[i].getContent(); + if (c == CONTENT_AIR || c == dp.c_water || + c == dp.c_river_water) + vm->m_flags[i] |= VMANIP_FLAG_DUNGEON_PRESERVE; + i++; + } } } } @@ -142,21 +152,25 @@ void DungeonGen::makeDungeon(v3s16 start_padding) v3s16 roomplace; /* - Find place for first room + Find place for first room. + There is a 1 in 4 chance of the first room being 'large', + all other rooms are not 'large'. */ bool fits = false; for (u32 i = 0; i < 100 && !fits; i++) { bool is_large_room = ((random.next() & 3) == 1); if (is_large_room) { - roomsize.Z = random.range(8, 16); - roomsize.Y = random.range(8, 16); - roomsize.X = random.range(8, 16); + roomsize.Z = random.range( + dp.room_size_large_min.Z, dp.room_size_large_max.Z); + roomsize.Y = random.range( + dp.room_size_large_min.Y, dp.room_size_large_max.Y); + roomsize.X = random.range( + dp.room_size_large_min.X, dp.room_size_large_max.X); } else { - roomsize.Z = random.range(4, 8); - roomsize.Y = random.range(4, 6); - roomsize.X = random.range(4, 8); + roomsize.Z = random.range(dp.room_size_min.Z, dp.room_size_max.Z); + roomsize.Y = random.range(dp.room_size_min.Y, dp.room_size_max.Y); + roomsize.X = random.range(dp.room_size_min.X, dp.room_size_max.X); } - roomsize += dp.roomsize; // start_padding is used to disallow starting the generation of // a dungeon in a neighboring generation chunk @@ -246,10 +260,9 @@ void DungeonGen::makeDungeon(v3s16 start_padding) makeCorridor(doorplace, doordir, corridor_end, corridor_end_dir); // Find a place for a random sized room - roomsize.Z = random.range(4, 8); - roomsize.Y = random.range(4, 6); - roomsize.X = random.range(4, 8); - roomsize += dp.roomsize; + roomsize.Z = random.range(dp.room_size_min.Z, dp.room_size_max.Z); + roomsize.Y = random.range(dp.room_size_min.Y, dp.room_size_max.Y); + roomsize.X = random.range(dp.room_size_min.X, dp.room_size_max.X); m_pos = corridor_end; m_dir = corridor_end_dir; @@ -397,13 +410,8 @@ void DungeonGen::makeCorridor(v3s16 doorplace, v3s16 doordir, makeHole(doorplace); v3s16 p0 = doorplace; v3s16 dir = doordir; - u32 length; - /*if (random.next() % 2) - length = random.range(1, 13); - else - length = random.range(1, 6);*/ - length = random.range(1, 13); - u32 partlength = random.range(1, 13); + u32 length = random.range(dp.corridor_len_min, dp.corridor_len_max); + u32 partlength = random.range(dp.corridor_len_min, dp.corridor_len_max); u32 partcount = 0; s16 make_stairs = 0; @@ -556,7 +564,6 @@ bool DungeonGen::findPlaceForRoomDoor(v3s16 roomsize, v3s16 &result_doorplace, continue; v3s16 roomplace; // X east, Z north, Y up -#if 1 if (doordir == v3s16(1, 0, 0)) // X+ roomplace = doorplace + v3s16(0, -1, random.range(-roomsize.Z + 2, -2)); @@ -569,17 +576,6 @@ bool DungeonGen::findPlaceForRoomDoor(v3s16 roomsize, v3s16 &result_doorplace, if (doordir == v3s16(0, 0, -1)) // Z- roomplace = doorplace + v3s16(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; diff --git a/src/dungeongen.h b/src/dungeongen.h index 30786b9f3..4bd208330 100644 --- a/src/dungeongen.h +++ b/src/dungeongen.h @@ -48,8 +48,14 @@ struct DungeonParams { content_t c_stair; bool diagonal_dirs; + bool only_in_ground; v3s16 holesize; - v3s16 roomsize; + u16 corridor_len_min; + u16 corridor_len_max; + v3s16 room_size_min; + v3s16 room_size_max; + v3s16 room_size_large_min; + v3s16 room_size_large_max; u16 rooms_min; u16 rooms_max; s16 y_min; diff --git a/src/mapgen.cpp b/src/mapgen.cpp index 00ae917a1..e1e3ccd25 100644 --- a/src/mapgen.cpp +++ b/src/mapgen.cpp @@ -845,47 +845,61 @@ void MapgenBasic::generateDungeons(s16 max_stone_y, MgStoneType stone_type) DungeonParams dp; - dp.seed = seed; - dp.c_water = c_water_source; - dp.c_river_water = c_river_water_source; - dp.rooms_min = 2; - dp.rooms_max = 16; - dp.y_min = -MAX_MAP_GENERATION_LIMIT; - dp.y_max = MAX_MAP_GENERATION_LIMIT; - dp.np_density = nparams_dungeon_density; - dp.np_alt_wall = nparams_dungeon_alt_wall; + dp.seed = seed; + dp.c_water = c_water_source; + dp.c_river_water = c_river_water_source; + + dp.only_in_ground = true; + dp.corridor_len_min = 1; + dp.corridor_len_max = 13; + dp.rooms_min = 2; + dp.rooms_max = 16; + dp.y_min = -MAX_MAP_GENERATION_LIMIT; + dp.y_max = MAX_MAP_GENERATION_LIMIT; + + dp.np_density = nparams_dungeon_density; + dp.np_alt_wall = nparams_dungeon_alt_wall; switch (stone_type) { default: case MGSTONE_STONE: - dp.c_wall = c_cobble; - dp.c_alt_wall = c_mossycobble; - dp.c_stair = c_stair_cobble; - - dp.diagonal_dirs = false; - dp.holesize = v3s16(1, 2, 1); - dp.roomsize = v3s16(0, 0, 0); - dp.notifytype = GENNOTIFY_DUNGEON; + dp.c_wall = c_cobble; + dp.c_alt_wall = c_mossycobble; + dp.c_stair = c_stair_cobble; + + dp.diagonal_dirs = false; + dp.holesize = v3s16(1, 2, 1); + dp.room_size_min = v3s16(4, 4, 4); + dp.room_size_max = v3s16(8, 6, 8); + dp.room_size_large_min = v3s16(8, 8, 8); + dp.room_size_large_max = v3s16(16, 16, 16); + dp.notifytype = GENNOTIFY_DUNGEON; break; case MGSTONE_DESERT_STONE: - dp.c_wall = c_desert_stone; - dp.c_alt_wall = CONTENT_IGNORE; - dp.c_stair = c_stair_desert_stone; - - dp.diagonal_dirs = true; - dp.holesize = v3s16(2, 3, 2); - dp.roomsize = v3s16(2, 5, 2); - dp.notifytype = GENNOTIFY_TEMPLE; + dp.c_wall = c_desert_stone; + dp.c_alt_wall = CONTENT_IGNORE; + dp.c_stair = c_stair_desert_stone; + + dp.diagonal_dirs = true; + dp.holesize = v3s16(2, 3, 2); + dp.room_size_min = v3s16(6, 9, 6); + dp.room_size_max = v3s16(10, 11, 10); + dp.room_size_large_min = v3s16(10, 13, 10); + dp.room_size_large_max = v3s16(18, 21, 18); + dp.notifytype = GENNOTIFY_TEMPLE; break; case MGSTONE_SANDSTONE: - dp.c_wall = c_sandstonebrick; - dp.c_alt_wall = CONTENT_IGNORE; - dp.c_stair = c_stair_sandstonebrick; - - dp.diagonal_dirs = false; - dp.holesize = v3s16(2, 2, 2); - dp.roomsize = v3s16(2, 0, 2); - dp.notifytype = GENNOTIFY_DUNGEON; + dp.c_wall = c_sandstonebrick; + dp.c_alt_wall = CONTENT_IGNORE; + dp.c_stair = c_stair_sandstonebrick; + + dp.diagonal_dirs = false; + dp.holesize = v3s16(2, 2, 2); + dp.room_size_min = v3s16(6, 4, 6); + dp.room_size_max = v3s16(10, 6, 10); + dp.room_size_large_min = v3s16(10, 8, 10); + dp.room_size_large_max = v3s16(18, 16, 18); + dp.notifytype = GENNOTIFY_DUNGEON; break; } diff --git a/src/mapgen_v6.cpp b/src/mapgen_v6.cpp index 807bbe751..f3e893f58 100644 --- a/src/mapgen_v6.cpp +++ b/src/mapgen_v6.cpp @@ -564,34 +564,47 @@ void MapgenV6::makeChunk(BlockMakeData *data) if ((flags & MG_DUNGEONS) && (stone_surface_max_y >= node_min.Y)) { DungeonParams dp; - dp.seed = seed; - dp.c_water = c_water_source; - dp.c_river_water = c_water_source; - dp.rooms_min = 2; - dp.rooms_max = 16; - dp.y_min = -MAX_MAP_GENERATION_LIMIT; - dp.y_max = MAX_MAP_GENERATION_LIMIT; - dp.np_density = NoiseParams(0.9, 0.5, v3f(500.0, 500.0, 500.0), 0, 2, 0.8, 2.0); - dp.np_alt_wall = NoiseParams(-0.4, 1.0, v3f(40.0, 40.0, 40.0), 32474, 6, 1.1, 2.0); + dp.seed = seed; + dp.c_water = c_water_source; + dp.c_river_water = c_water_source; + + dp.only_in_ground = true; + dp.corridor_len_min = 1; + dp.corridor_len_max = 13; + dp.rooms_min = 2; + dp.rooms_max = 16; + dp.y_min = -MAX_MAP_GENERATION_LIMIT; + dp.y_max = MAX_MAP_GENERATION_LIMIT; + + dp.np_density + = NoiseParams(0.9, 0.5, v3f(500.0, 500.0, 500.0), 0, 2, 0.8, 2.0); + dp.np_alt_wall + = NoiseParams(-0.4, 1.0, v3f(40.0, 40.0, 40.0), 32474, 6, 1.1, 2.0); if (getBiome(0, v2s16(node_min.X, node_min.Z)) == BT_DESERT) { - dp.c_wall = c_desert_stone; - dp.c_alt_wall = CONTENT_IGNORE; - dp.c_stair = c_stair_desert_stone; - - dp.diagonal_dirs = true; - dp.holesize = v3s16(2, 3, 2); - dp.roomsize = v3s16(2, 5, 2); - dp.notifytype = GENNOTIFY_TEMPLE; + dp.c_wall = c_desert_stone; + dp.c_alt_wall = CONTENT_IGNORE; + dp.c_stair = c_stair_desert_stone; + + dp.diagonal_dirs = true; + dp.holesize = v3s16(2, 3, 2); + dp.room_size_min = v3s16(6, 9, 6); + dp.room_size_max = v3s16(10, 11, 10); + dp.room_size_large_min = v3s16(10, 13, 10); + dp.room_size_large_max = v3s16(18, 21, 18); + dp.notifytype = GENNOTIFY_TEMPLE; } else { - dp.c_wall = c_cobble; - dp.c_alt_wall = c_mossycobble; - dp.c_stair = c_stair_cobble; - - dp.diagonal_dirs = false; - dp.holesize = v3s16(1, 2, 1); - dp.roomsize = v3s16(0, 0, 0); - dp.notifytype = GENNOTIFY_DUNGEON; + dp.c_wall = c_cobble; + dp.c_alt_wall = c_mossycobble; + dp.c_stair = c_stair_cobble; + + dp.diagonal_dirs = false; + dp.holesize = v3s16(1, 2, 1); + dp.room_size_min = v3s16(4, 4, 4); + dp.room_size_max = v3s16(8, 6, 8); + dp.room_size_large_min = v3s16(8, 8, 8); + dp.room_size_large_max = v3s16(16, 16, 16); + dp.notifytype = GENNOTIFY_DUNGEON; } DungeonGen dgen(ndef, &gennotify, &dp); -- cgit v1.2.3 From e10e5fd16c2bd55b9b106edc6cedd07530cf103d Mon Sep 17 00:00:00 2001 From: paramat Date: Sat, 4 Mar 2017 05:10:10 +0000 Subject: Dungeons: Use 'block' instead of 'brick' for nodebox stairs Affects only sandstone dungeons. Nodebox stairs made from 'sandstone_block' look better because every step is undivided. --- src/mapgen.cpp | 18 +++++++++--------- src/mapgen.h | 2 +- 2 files changed, 10 insertions(+), 10 deletions(-) (limited to 'src/mapgen.cpp') diff --git a/src/mapgen.cpp b/src/mapgen.cpp index e1e3ccd25..a0b9990b7 100644 --- a/src/mapgen.cpp +++ b/src/mapgen.cpp @@ -601,12 +601,12 @@ MapgenBasic::MapgenBasic(int mapgenid, MapgenParams *params, EmergeManager *emer c_sandstone = c_stone; //// Content used for dungeon generation - c_cobble = ndef->getId("mapgen_cobble"); - c_mossycobble = ndef->getId("mapgen_mossycobble"); - c_stair_cobble = ndef->getId("mapgen_stair_cobble"); - c_stair_desert_stone = ndef->getId("mapgen_stair_desert_stone"); - c_sandstonebrick = ndef->getId("mapgen_sandstonebrick"); - c_stair_sandstonebrick = ndef->getId("mapgen_stair_sandstonebrick"); + c_cobble = ndef->getId("mapgen_cobble"); + c_mossycobble = ndef->getId("mapgen_mossycobble"); + c_stair_cobble = ndef->getId("mapgen_stair_cobble"); + c_stair_desert_stone = ndef->getId("mapgen_stair_desert_stone"); + c_sandstonebrick = ndef->getId("mapgen_sandstonebrick"); + c_stair_sandstone_block = ndef->getId("mapgen_stair_sandstone_block"); // Fall back to more basic content if not defined if (c_mossycobble == CONTENT_IGNORE) @@ -617,8 +617,8 @@ MapgenBasic::MapgenBasic(int mapgenid, MapgenParams *params, EmergeManager *emer c_stair_desert_stone = c_desert_stone; if (c_sandstonebrick == CONTENT_IGNORE) c_sandstonebrick = c_sandstone; - if (c_stair_sandstonebrick == CONTENT_IGNORE) - c_stair_sandstonebrick = c_sandstonebrick; + if (c_stair_sandstone_block == CONTENT_IGNORE) + c_stair_sandstone_block = c_sandstonebrick; } @@ -891,7 +891,7 @@ void MapgenBasic::generateDungeons(s16 max_stone_y, MgStoneType stone_type) case MGSTONE_SANDSTONE: dp.c_wall = c_sandstonebrick; dp.c_alt_wall = CONTENT_IGNORE; - dp.c_stair = c_stair_sandstonebrick; + dp.c_stair = c_stair_sandstone_block; dp.diagonal_dirs = false; dp.holesize = v3s16(2, 2, 2); diff --git a/src/mapgen.h b/src/mapgen.h index a95e1942a..7aac1e6a0 100644 --- a/src/mapgen.h +++ b/src/mapgen.h @@ -268,7 +268,7 @@ protected: content_t c_mossycobble; content_t c_stair_desert_stone; content_t c_sandstonebrick; - content_t c_stair_sandstonebrick; + content_t c_stair_sandstone_block; int ystride; int zstride; -- cgit v1.2.3 From ec0c4d33db9e0b7b3e541757e34c04c08c3b48c9 Mon Sep 17 00:00:00 2001 From: paramat Date: Thu, 23 Mar 2017 00:18:59 +0000 Subject: Map generation limit: Make per-world The setting limits map generation but affects nothing else. Add 'mapgen_limit' to global mapgen parameters. Move 'blockpos_over_mapgen_limit()' to the only place it is called from: map.cpp. Allow teleportation to any part of the world even if over the set mapgen limit. Simplify the reading of this limit in mgvalleys. Remove the 'map_generation_limit' setting. --- builtin/game/chatcommands.lua | 2 +- builtin/settingtypes.txt | 11 ++++------- minetest.conf.example | 11 ++++------- src/defaultsettings.cpp | 2 +- src/map.cpp | 13 +++++++++++++ src/map.h | 1 + src/mapblock.h | 14 +------------- src/mapgen.cpp | 24 ++++++++++++++---------- src/mapgen.h | 3 +++ src/mapgen_valleys.cpp | 9 +++------ src/mapgen_valleys.h | 2 -- 11 files changed, 45 insertions(+), 47 deletions(-) (limited to 'src/mapgen.cpp') diff --git a/builtin/game/chatcommands.lua b/builtin/game/chatcommands.lua index b4fa4f828..16f5f3be9 100644 --- a/builtin/game/chatcommands.lua +++ b/builtin/game/chatcommands.lua @@ -303,7 +303,7 @@ core.register_chatcommand("teleport", { p.y = tonumber(p.y) p.z = tonumber(p.z) if p.x and p.y and p.z then - local lm = tonumber(minetest.setting_get("map_generation_limit") or 31000) + local lm = 31000 if p.x < -lm or p.x > lm or p.y < -lm or p.y > lm or p.z < -lm or p.z > lm then return false, "Cannot teleport out of map bounds!" end diff --git a/builtin/settingtypes.txt b/builtin/settingtypes.txt index e63697f61..c9e0f7b87 100644 --- a/builtin/settingtypes.txt +++ b/builtin/settingtypes.txt @@ -893,13 +893,10 @@ water_level (Water level) int 1 # From how far blocks are generated for clients, stated in mapblocks (16 nodes). max_block_generate_distance (Max block generate distance) int 6 -# Where the map generator stops. -# Please note: -# - Limited to 31000 (setting above has no effect) -# - The map generator works in groups of 80x80x80 nodes (5x5x5 MapBlocks). -# - Those groups have an offset of -32, -32 nodes from the origin. -# - Only groups which are within the map_generation_limit are generated -map_generation_limit (Map generation limit) int 31000 0 31000 +# Limit of map generation, in nodes, in all 6 directions from (0, 0, 0). +# Only mapchunks completely within the mapgen limit are generated. +# Value is stored per-world. +mapgen_limit (Map generation limit) int 31000 0 31000 # Global map generation attributes. # In Mapgen v6 the 'decorations' flag controls all decorations except trees diff --git a/minetest.conf.example b/minetest.conf.example index 78488432f..a45a9948a 100644 --- a/minetest.conf.example +++ b/minetest.conf.example @@ -1092,14 +1092,11 @@ server_side_occlusion_culling = true # type: int # max_block_generate_distance = 6 -# Where the map generator stops. -# Please note: -# - Limited to 31000 (setting above has no effect) -# - The map generator works in groups of 80x80x80 nodes (5x5x5 MapBlocks). -# - Those groups have an offset of -32, -32 nodes from the origin. -# - Only groups which are within the map_generation_limit are generated +# Limit of map generation, in nodes, in all 6 directions from (0, 0, 0). +# Only mapchunks completely within the mapgen limit are generated. +# Value is stored per-world. # type: int min: 0 max: 31000 -# map_generation_limit = 31000 +# mapgen_limit = 31000 # Global map generation attributes. # In Mapgen v6 the 'decorations' flag controls all decorations except trees diff --git a/src/defaultsettings.cpp b/src/defaultsettings.cpp index 5b66c583a..4b50b991b 100644 --- a/src/defaultsettings.cpp +++ b/src/defaultsettings.cpp @@ -333,10 +333,10 @@ void set_default_settings(Settings *settings) // Mapgen settings->setDefault("mg_name", "v7"); settings->setDefault("water_level", "1"); + settings->setDefault("mapgen_limit", "31000"); settings->setDefault("chunksize", "5"); settings->setDefault("mg_flags", "dungeons"); settings->setDefault("fixed_map_seed", ""); - settings->setDefault("map_generation_limit", "31000"); settings->setDefault("max_block_generate_distance", "7"); settings->setDefault("enable_mapgen_debug_info", "false"); diff --git a/src/map.cpp b/src/map.cpp index 504760d09..b690ea3b3 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -1367,6 +1367,19 @@ s16 ServerMap::getWaterLevel() return getMapgenParams()->water_level; } +bool ServerMap::blockpos_over_mapgen_limit(v3s16 p) +{ + const s16 mapgen_limit_bp = rangelim( + getMapgenParams()->mapgen_limit, 0, MAX_MAP_GENERATION_LIMIT) / + MAP_BLOCKSIZE; + return p.X < -mapgen_limit_bp || + p.X > mapgen_limit_bp || + p.Y < -mapgen_limit_bp || + p.Y > mapgen_limit_bp || + p.Z < -mapgen_limit_bp || + p.Z > mapgen_limit_bp; +} + bool ServerMap::initBlockMake(v3s16 blockpos, BlockMakeData *data) { s16 csize = getMapgenParams()->chunksize; diff --git a/src/map.h b/src/map.h index aeb05c704..ea8dc76d1 100644 --- a/src/map.h +++ b/src/map.h @@ -379,6 +379,7 @@ public: /* Blocks are generated by using these and makeBlock(). */ + bool blockpos_over_mapgen_limit(v3s16 p); bool initBlockMake(v3s16 blockpos, BlockMakeData *data); void finishBlockMake(BlockMakeData *data, std::map *changed_blocks); diff --git a/src/mapblock.h b/src/mapblock.h index be2edc791..c48f337e0 100644 --- a/src/mapblock.h +++ b/src/mapblock.h @@ -32,6 +32,7 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "modifiedstate.h" #include "util/numeric.h" // getContainerPos #include "settings.h" +#include "mapgen.h" class Map; class NodeMetadataList; @@ -689,19 +690,6 @@ inline bool blockpos_over_max_limit(v3s16 p) p.Z > max_limit_bp; } -inline bool blockpos_over_mapgen_limit(v3s16 p) -{ - const s16 mapgen_limit_bp = rangelim( - g_settings->getS16("map_generation_limit"), 0, MAX_MAP_GENERATION_LIMIT) / - MAP_BLOCKSIZE; - return p.X < -mapgen_limit_bp || - p.X > mapgen_limit_bp || - p.Y < -mapgen_limit_bp || - p.Y > mapgen_limit_bp || - p.Z < -mapgen_limit_bp || - p.Z > mapgen_limit_bp; -} - /* Returns the position of the block where the node is located */ diff --git a/src/mapgen.cpp b/src/mapgen.cpp index a0b9990b7..6f3ea7cb0 100644 --- a/src/mapgen.cpp +++ b/src/mapgen.cpp @@ -97,11 +97,12 @@ STATIC_ASSERT( Mapgen::Mapgen() { - generating = false; - id = -1; - seed = 0; - water_level = 0; - flags = 0; + generating = false; + id = -1; + seed = 0; + water_level = 0; + mapgen_limit = 0; + flags = 0; vm = NULL; ndef = NULL; @@ -114,11 +115,12 @@ Mapgen::Mapgen() Mapgen::Mapgen(int mapgenid, MapgenParams *params, EmergeManager *emerge) : gennotify(emerge->gen_notify_on, &emerge->gen_notify_on_deco_ids) { - generating = false; - id = mapgenid; - water_level = params->water_level; - flags = params->flags; - csize = v3s16(1, 1, 1) * (params->chunksize * MAP_BLOCKSIZE); + generating = false; + id = mapgenid; + water_level = params->water_level; + mapgen_limit = params->mapgen_limit; + flags = params->flags; + csize = v3s16(1, 1, 1) * (params->chunksize * MAP_BLOCKSIZE); /* We are losing half our entropy by doing this, but it is necessary to @@ -1005,6 +1007,7 @@ void MapgenParams::readParams(const Settings *settings) this->mgtype = Mapgen::getMapgenType(mg_name); settings->getS16NoEx("water_level", water_level); + settings->getS16NoEx("mapgen_limit", mapgen_limit); settings->getS16NoEx("chunksize", chunksize); settings->getFlagStrNoEx("mg_flags", flags, flagdesc_mapgen); @@ -1022,6 +1025,7 @@ void MapgenParams::writeParams(Settings *settings) const settings->set("mg_name", Mapgen::getMapgenName(mgtype)); settings->setU64("seed", seed); settings->setS16("water_level", water_level); + settings->setS16("mapgen_limit", mapgen_limit); settings->setS16("chunksize", chunksize); settings->setFlagStr("mg_flags", flags, flagdesc_mapgen, U32_MAX); diff --git a/src/mapgen.h b/src/mapgen.h index 7aac1e6a0..c4e1652e8 100644 --- a/src/mapgen.h +++ b/src/mapgen.h @@ -124,6 +124,7 @@ struct MapgenParams { s16 chunksize; u64 seed; s16 water_level; + s16 mapgen_limit; u32 flags; BiomeParams *bparams; @@ -133,6 +134,7 @@ struct MapgenParams { chunksize(5), seed(0), water_level(1), + mapgen_limit(MAX_MAP_GENERATION_LIMIT), flags(MG_CAVES | MG_LIGHT | MG_DECORATIONS), bparams(NULL) { @@ -158,6 +160,7 @@ class Mapgen { public: s32 seed; int water_level; + int mapgen_limit; u32 flags; bool generating; int id; diff --git a/src/mapgen_valleys.cpp b/src/mapgen_valleys.cpp index ccf797eff..76a7a0582 100644 --- a/src/mapgen_valleys.cpp +++ b/src/mapgen_valleys.cpp @@ -70,9 +70,6 @@ MapgenValleys::MapgenValleys(int mapgenid, MapgenValleysParams *params, EmergeMa // NOTE: MapgenValleys has a hard dependency on BiomeGenOriginal this->m_bgen = (BiomeGenOriginal *)biomegen; - this->map_gen_limit = MYMIN(MAX_MAP_GENERATION_LIMIT, - g_settings->getU16("map_generation_limit")); - BiomeParamsOriginal *bp = (BiomeParamsOriginal *)params->bparams; this->spflags = params->spflags; @@ -621,7 +618,7 @@ void MapgenValleys::generateCaves(s16 max_stone_y, s16 large_cave_depth) const float massive_cave_threshold = 0.6f; // mct: 1 = small rare caves, 0.5 1/3rd ground volume, 0 = 1/2 ground volume. - float yblmin = -map_gen_limit + massive_cave_blend * 1.5f; + float yblmin = -mapgen_limit + massive_cave_blend * 1.5f; float yblmax = massive_cave_depth - massive_cave_blend * 1.5f; bool made_a_big_one = false; @@ -646,11 +643,11 @@ void MapgenValleys::generateCaves(s16 max_stone_y, s16 large_cave_depth) // lava_depth varies between one and ten as you approach // the bottom of the world. - s16 lava_depth = ceil((lava_max_height - node_min.Y + 1) * 10.f / map_gen_limit); + s16 lava_depth = ceil((lava_max_height - node_min.Y + 1) * 10.f / mapgen_limit); // This allows random lava spawns to be less common at the surface. s16 lava_chance = MYCUBE(lava_features_lim) * lava_depth; // water_depth varies between ten and one on the way down. - s16 water_depth = ceil((map_gen_limit - abs(node_min.Y) + 1) * 10.f / map_gen_limit); + s16 water_depth = ceil((mapgen_limit - abs(node_min.Y) + 1) * 10.f / mapgen_limit); // This allows random water spawns to be more common at the surface. s16 water_chance = MYCUBE(water_features_lim) * water_depth; diff --git a/src/mapgen_valleys.h b/src/mapgen_valleys.h index 6dd7ebc47..4a7a11bcc 100644 --- a/src/mapgen_valleys.h +++ b/src/mapgen_valleys.h @@ -101,8 +101,6 @@ public: private: BiomeGenOriginal *m_bgen; - float map_gen_limit; - bool humid_rivers; bool use_altitude_chill; float humidity_adjust; -- cgit v1.2.3 From 773efc19b1d05e573d5bc811c0175d192f7c12c5 Mon Sep 17 00:00:00 2001 From: SmallJoker Date: Sat, 1 Apr 2017 10:18:13 +0200 Subject: mapgen: Fix segfault when selecting invalid mapgen (#5491) --- src/mapgen.cpp | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'src/mapgen.cpp') diff --git a/src/mapgen.cpp b/src/mapgen.cpp index 6f3ea7cb0..b6e8c0fd1 100644 --- a/src/mapgen.cpp +++ b/src/mapgen.cpp @@ -1003,8 +1003,11 @@ void MapgenParams::readParams(const Settings *settings) } std::string mg_name; - if (settings->getNoEx("mg_name", mg_name)) - this->mgtype = Mapgen::getMapgenType(mg_name); + if (settings->getNoEx("mg_name", mg_name)) { + mgtype = Mapgen::getMapgenType(mg_name); + if (mgtype == MAPGEN_INVALID) + mgtype = MAPGEN_DEFAULT; + } settings->getS16NoEx("water_level", water_level); settings->getS16NoEx("mapgen_limit", mapgen_limit); -- cgit v1.2.3 From 859141a0ce38fbd606d95ae7a2f0999acf2fbe84 Mon Sep 17 00:00:00 2001 From: paramat Date: Sun, 12 Mar 2017 13:26:09 +0000 Subject: Cavegen/Mgv5/Mgv7: Add optional giant caverns Add to MapgenBasic for use by multiple mapgens. Add to mgv5 and mgv7, enabled by default. Similar to mgvalleys caverns but half the scale. Parameters for upper y limit, distance caverns taper to full size, and noise threshold (full cavern size). As with mgvalleys caverns are generated first and classic caves are disabled in any mapchunk containing a cavern, to avoid excessive spreading volumes of liquids. This also avoids floating blobs of liquid where a large classic cave has overgenerated out into a neighbouring previously-generated mapchunk. --- builtin/settingtypes.txt | 23 ++++++++++++ minetest.conf.example | 30 +++++++++++++++ src/cavegen.cpp | 95 ++++++++++++++++++++++++++++++++++++++++++++++++ src/cavegen.h | 30 +++++++++++++++ src/mapgen.cpp | 12 ++++++ src/mapgen.h | 5 +++ src/mapgen_v5.cpp | 86 +++++++++++++++++++++++-------------------- src/mapgen_v5.h | 10 ++++- src/mapgen_v7.cpp | 53 ++++++++++++++++++++++----- src/mapgen_v7.h | 13 +++++-- 10 files changed, 303 insertions(+), 54 deletions(-) (limited to 'src/mapgen.cpp') diff --git a/builtin/settingtypes.txt b/builtin/settingtypes.txt index c9e0f7b87..bbee77749 100644 --- a/builtin/settingtypes.txt +++ b/builtin/settingtypes.txt @@ -940,12 +940,25 @@ mg_biome_np_humidity_blend (Mapgen biome humidity blend noise parameters) noise_ # Controls width of tunnels, a smaller value creates wider tunnels. mgv5_cave_width (Mapgen v5 cave width) float 0.125 +# Y-level of cavern upper limit. +mgv5_cavern_limit (Mapgen v5 cavern limit) int -256 + +# Y-distance over which caverns expand to full size. +mgv5_cavern_taper (Mapgen v5 cavern taper) int 256 + +# Defines full size of caverns, smaller values create larger caverns. +mgv5_cavern_threshold (Mapgen v5 cavern threshold) float 0.7 + mgv5_np_filler_depth (Mapgen v5 filler depth noise parameters) noise_params 0, 1, (150, 150, 150), 261, 4, 0.7, 2.0 mgv5_np_factor (Mapgen v5 factor noise parameters) noise_params 0, 1, (250, 250, 250), 920381, 3, 0.45, 2.0 mgv5_np_height (Mapgen v5 height noise parameters) noise_params 0, 10, (250, 250, 250), 84174, 4, 0.5, 2.0 mgv5_np_cave1 (Mapgen v5 cave1 noise parameters) noise_params 0, 12, (50, 50, 50), 52534, 4, 0.5, 2.0 mgv5_np_cave2 (Mapgen v5 cave2 noise parameters) noise_params 0, 12, (50, 50, 50), 10325, 4, 0.5, 2.0 +mgv5_np_cavern (Mapgen v5 cavern noise parameters) noise_params 0, 1, (384, 128, 384), 723, 5, 0.63, 2.0 # TODO +# Noise parameters in group format, unsupported by advanced settings +# menu but settable in minetest.conf. +# See documentation of noise parameter formats in minetest.conf.example. #mgv5_np_ground = { # offset = 0 # scale = 40 @@ -1007,6 +1020,15 @@ mgv7_floatland_level (Mapgen v7 floatland level) int 1280 # Y-level to which floatland shadows extend. mgv7_shadow_limit (Mapgen v7 shadow limit) int 1024 +# Y-level of cavern upper limit. +mgv7_cavern_limit (Mapgen v7 cavern limit) int -256 + +# Y-distance over which caverns expand to full size. +mgv7_cavern_taper (Mapgen v7 cavern taper) int 256 + +# Defines full size of caverns, smaller values create larger caverns. +mgv7_cavern_threshold (Mapgen v7 cavern threshold) float 0.7 + mgv7_np_terrain_base (Mapgen v7 terrain base noise parameters) noise_params 4, 70, (600, 600, 600), 82341, 5, 0.6, 2.0 mgv7_np_terrain_alt (Mapgen v7 terrain altitude noise parameters) noise_params 4, 25, (600, 600, 600), 5934, 5, 0.6, 2.0 mgv7_np_terrain_persist (Mapgen v7 terrain persistation noise parameters) noise_params 0.6, 0.1, (2000, 2000, 2000), 539, 3, 0.6, 2.0 @@ -1018,6 +1040,7 @@ mgv7_np_floatland_base (Mapgen v7 floatland base terrain noise parameters) noise mgv7_np_float_base_height (Mapgen v7 floatland base terrain height noise parameters) noise_params 48, 24, (300, 300, 300), 907, 4, 0.7, 2.0 mgv7_np_mountain (Mapgen v7 mountain noise parameters) noise_params -0.6, 1, (250, 350, 250), 5333, 5, 0.63, 2.0 mgv7_np_ridge (Mapgen v7 river channel wall noise parameters) noise_params 0, 1, (100, 100, 100), 6467, 4, 0.75, 2.0 +mgv7_np_cavern (Mapgen v7 cavern noise parameters) noise_params 0, 1, (384, 128, 384), 723, 5, 0.63, 2.0 mgv7_np_cave1 (Mapgen v7 cave1 noise parameters) noise_params 0, 12, (61, 61, 61), 52534, 3, 0.5, 2.0 mgv7_np_cave2 (Mapgen v7 cave2 noise parameters) noise_params 0, 12, (67, 67, 67), 10325, 3, 0.5, 2.0 diff --git a/minetest.conf.example b/minetest.conf.example index a45a9948a..5927cdb03 100644 --- a/minetest.conf.example +++ b/minetest.conf.example @@ -1174,6 +1174,18 @@ server_side_occlusion_culling = true # type: float # mgv5_cave_width = 0.125 +# Y-level of cavern upper limit. +# type: int +# mgv5_cavern_limit = -256 + +# Y-distance over which caverns expand to full size. +# type: int +# mgv5_cavern_taper = 256 + +# Defines full size of caverns, smaller values create larger caverns. +# type: float +# mgv5_cavern_threshold = 0.7 + # type: noise_params # mgv5_np_filler_depth = 0, 1, (150, 150, 150), 261, 4, 0.7, 2.0 @@ -1189,6 +1201,9 @@ server_side_occlusion_culling = true # type: noise_params # mgv5_np_cave2 = 0, 12, (50, 50, 50), 10325, 4, 0.5, 2.0 +# type: noise_params +# mgv5_np_cavern = 0, 1, (384, 128, 384), 723, 5, 0.63, 2.0 + # Noise parameters in group format, unsupported by advanced settings # menu but settable in minetest.conf. # See documentation of noise parameter formats above. @@ -1284,6 +1299,18 @@ server_side_occlusion_culling = true # type: int # mgv7_shadow_limit = 1024 +# Y-level of cavern upper limit. +# type: int +# mgv7_cavern_limit = -256 + +# Y-distance over which caverns expand to full size. +# type: int +# mgv7_cavern_taper = 256 + +# Defines full size of caverns, smaller values create larger caverns. +# type: float +# mgv7_cavern_threshold = 0.7 + # type: noise_params # mgv7_np_terrain_base = 4, 70, (600, 600, 600), 82341, 5, 0.6, 2.0 @@ -1317,6 +1344,9 @@ server_side_occlusion_culling = true # type: noise_params # mgv7_np_ridge = 0, 1, (100, 100, 100), 6467, 4, 0.75, 2.0 +# type: noise_params +# mgv7_np_cavern = 0, 1, (384, 128, 384), 723, 5, 0.63, 2.0 + # type: noise_params # mgv7_np_cave1 = 0, 12, (61, 61, 61), 52534, 3, 0.5, 2.0 diff --git a/src/cavegen.cpp b/src/cavegen.cpp index 1005640c1..6275c516e 100644 --- a/src/cavegen.cpp +++ b/src/cavegen.cpp @@ -150,6 +150,101 @@ void CavesNoiseIntersection::generateCaves(MMVManip *vm, } +//// +//// CavernsNoise +//// + +CavernsNoise::CavernsNoise( + INodeDefManager *nodedef, v3s16 chunksize, NoiseParams *np_cavern, + s32 seed, float cavern_limit, float cavern_taper, float cavern_threshold) +{ + assert(nodedef); + + m_ndef = nodedef; + + m_csize = chunksize; + m_cavern_limit = cavern_limit; + m_cavern_taper = cavern_taper; + m_cavern_threshold = cavern_threshold; + + m_ystride = m_csize.X; + m_zstride_1d = m_csize.X * (m_csize.Y + 1); + + // Noise is created using 1-down overgeneration + // A Nx-by-1-by-Nz-sized plane is at the bottom of the desired for + // re-carving the solid overtop placed for blocking sunlight + noise_cavern = new Noise(np_cavern, seed, m_csize.X, m_csize.Y + 1, m_csize.Z); + + c_water_source = m_ndef->getId("mapgen_water_source"); + if (c_water_source == CONTENT_IGNORE) + c_water_source = CONTENT_AIR; + + c_lava_source = m_ndef->getId("mapgen_lava_source"); + if (c_lava_source == CONTENT_IGNORE) + c_lava_source = CONTENT_AIR; +} + + +CavernsNoise::~CavernsNoise() +{ + delete noise_cavern; +} + + +bool CavernsNoise::generateCaverns(MMVManip *vm, v3s16 nmin, v3s16 nmax) +{ + assert(vm); + + // Calculate noise + noise_cavern->perlinMap3D(nmin.X, nmin.Y - 1, nmin.Z); + + // Cache cavern_amp values + float cavern_amp[m_csize.Y + 1]; + u8 cavern_amp_index = 0; // Index zero at column top + for (s16 y = nmax.Y; y >= nmin.Y - 1; y--, cavern_amp_index++) { + cavern_amp[cavern_amp_index] = + MYMIN((m_cavern_limit - y) / (float)m_cavern_taper, 1.0f); + } + + //// Place nodes + bool has_cavern = false; + v3s16 em = vm->m_area.getExtent(); + u32 index2d = 0; + + for (s16 z = nmin.Z; z <= nmax.Z; z++) + for (s16 x = nmin.X; x <= nmax.X; x++, index2d++) { + // Reset cave_amp index to column top + cavern_amp_index = 0; + // Initial voxelmanip index at column top + u32 vi = vm->m_area.index(x, nmax.Y, z); + // Initial 3D noise index at column top + u32 index3d = (z - nmin.Z) * m_zstride_1d + m_csize.Y * m_ystride + + (x - nmin.X); + // Don't excavate the overgenerated stone at node_max.Y + 1, + // this creates a 'roof' over the cavern, preventing light in + // caverns at mapchunk borders when generating mapchunks upwards. + // This 'roof' is excavated when the mapchunk above is generated. + for (s16 y = nmax.Y; y >= nmin.Y - 1; y--, + index3d -= m_ystride, + vm->m_area.add_y(em, vi, -1), + cavern_amp_index++) { + content_t c = vm->m_data[vi].getContent(); + float nabs_cavern = fabs(noise_cavern->result[index3d]); + // Caverns generate first but still remove lava and water in case + // of overgenerated classic caves. + if (nabs_cavern * cavern_amp[cavern_amp_index] > m_cavern_threshold && + (m_ndef->get(c).is_ground_content || + c == c_lava_source || c == c_water_source)) { + vm->m_data[vi] = MapNode(CONTENT_AIR); + has_cavern = true; + } + } + } + + return has_cavern; +} + + //// //// CavesRandomWalk //// diff --git a/src/cavegen.h b/src/cavegen.h index 2bf503d47..e322c181c 100644 --- a/src/cavegen.h +++ b/src/cavegen.h @@ -62,6 +62,36 @@ private: Noise *noise_cave2; }; +/* + CavernsNoise is a cave digging algorithm +*/ +class CavernsNoise { +public: + CavernsNoise(INodeDefManager *nodedef, v3s16 chunksize, NoiseParams *np_cavern, + s32 seed, float cavern_limit, float cavern_taper, float cavern_threshold); + ~CavernsNoise(); + + bool generateCaverns(MMVManip *vm, v3s16 nmin, v3s16 nmax); + +private: + INodeDefManager *m_ndef; + + // configurable parameters + v3s16 m_csize; + float m_cavern_limit; + float m_cavern_taper; + float m_cavern_threshold; + + // intermediate state variables + u16 m_ystride; + u16 m_zstride_1d; + + Noise *noise_cavern; + + content_t c_water_source; + content_t c_lava_source; +}; + /* CavesRandomWalk is an implementation of a cave-digging algorithm that operates on the principle of a "random walk" to approximate the stochiastic diff --git a/src/mapgen.cpp b/src/mapgen.cpp index b6e8c0fd1..c63c426fa 100644 --- a/src/mapgen.cpp +++ b/src/mapgen.cpp @@ -840,6 +840,18 @@ void MapgenBasic::generateCaves(s16 max_stone_y, s16 large_cave_depth) } +bool MapgenBasic::generateCaverns(s16 max_stone_y) +{ + if (node_min.Y > max_stone_y || node_min.Y > cavern_limit) + return false; + + CavernsNoise caverns_noise(ndef, csize, &np_cavern, + seed, cavern_limit, cavern_taper, cavern_threshold); + + return caverns_noise.generateCaverns(vm, node_min, node_max); +} + + void MapgenBasic::generateDungeons(s16 max_stone_y, MgStoneType stone_type) { if (max_stone_y < node_min.Y) diff --git a/src/mapgen.h b/src/mapgen.h index c4e1652e8..f738b1bce 100644 --- a/src/mapgen.h +++ b/src/mapgen.h @@ -243,6 +243,7 @@ public: virtual ~MapgenBasic(); virtual void generateCaves(s16 max_stone_y, s16 large_cave_depth); + virtual bool generateCaverns(s16 max_stone_y); virtual void generateDungeons(s16 max_stone_y, MgStoneType stone_type); virtual MgStoneType generateBiomes(); virtual void dustTopNodes(); @@ -282,7 +283,11 @@ protected: NoiseParams np_cave1; NoiseParams np_cave2; + NoiseParams np_cavern; float cave_width; + float cavern_limit; + float cavern_taper; + float cavern_threshold; }; #endif diff --git a/src/mapgen_v5.cpp b/src/mapgen_v5.cpp index 9f189e253..b983026e6 100644 --- a/src/mapgen_v5.cpp +++ b/src/mapgen_v5.cpp @@ -41,15 +41,19 @@ with this program; if not, write to the Free Software Foundation, Inc., FlagDesc flagdesc_mapgen_v5[] = { - {NULL, 0} + {"caverns", MGV5_CAVERNS}, + {NULL, 0} }; MapgenV5::MapgenV5(int mapgenid, MapgenV5Params *params, EmergeManager *emerge) : MapgenBasic(mapgenid, params, emerge) { - this->spflags = params->spflags; - this->cave_width = params->cave_width; + this->spflags = params->spflags; + this->cave_width = params->cave_width; + this->cavern_limit = params->cavern_limit; + this->cavern_taper = params->cavern_taper; + this->cavern_threshold = params->cavern_threshold; // Terrain noise noise_filler_depth = new Noise(¶ms->np_filler_depth, seed, csize.X, csize.Z); @@ -59,9 +63,10 @@ MapgenV5::MapgenV5(int mapgenid, MapgenV5Params *params, EmergeManager *emerge) // 3D terrain noise // 1-up 1-down overgeneration noise_ground = new Noise(¶ms->np_ground, seed, csize.X, csize.Y + 2, csize.Z); - - MapgenBasic::np_cave1 = params->np_cave1; - MapgenBasic::np_cave2 = params->np_cave2; + // 1 down overgeneration + MapgenBasic::np_cave1 = params->np_cave1; + MapgenBasic::np_cave2 = params->np_cave2; + MapgenBasic::np_cavern = params->np_cavern; } @@ -76,47 +81,55 @@ MapgenV5::~MapgenV5() MapgenV5Params::MapgenV5Params() { - spflags = 0; - cave_width = 0.125; + spflags = MGV5_CAVERNS; + cave_width = 0.125; + cavern_limit = -256; + cavern_taper = 256; + cavern_threshold = 0.7; np_filler_depth = NoiseParams(0, 1, v3f(150, 150, 150), 261, 4, 0.7, 2.0); np_factor = NoiseParams(0, 1, v3f(250, 250, 250), 920381, 3, 0.45, 2.0); np_height = NoiseParams(0, 10, v3f(250, 250, 250), 84174, 4, 0.5, 2.0); + np_ground = NoiseParams(0, 40, v3f(80, 80, 80), 983240, 4, 0.55, 2.0, NOISE_FLAG_EASED); np_cave1 = NoiseParams(0, 12, v3f(50, 50, 50), 52534, 4, 0.5, 2.0); np_cave2 = NoiseParams(0, 12, v3f(50, 50, 50), 10325, 4, 0.5, 2.0); - np_ground = NoiseParams(0, 40, v3f(80, 80, 80), 983240, 4, 0.55, 2.0, NOISE_FLAG_EASED); + np_cavern = NoiseParams(0, 1, v3f(384, 128, 384), 723, 5, 0.63, 2.0); } -//#define CAVE_NOISE_SCALE 12.0 -//#define CAVE_NOISE_THRESHOLD (1.5/CAVE_NOISE_SCALE) = 0.125 - - void MapgenV5Params::readParams(const Settings *settings) { - settings->getFlagStrNoEx("mgv5_spflags", spflags, flagdesc_mapgen_v5); - settings->getFloatNoEx("mgv5_cave_width", cave_width); + settings->getFlagStrNoEx("mgv5_spflags", spflags, flagdesc_mapgen_v5); + settings->getFloatNoEx("mgv5_cave_width", cave_width); + settings->getS16NoEx("mgv5_cavern_limit", cavern_limit); + settings->getS16NoEx("mgv5_cavern_taper", cavern_taper); + settings->getFloatNoEx("mgv5_cavern_threshold", cavern_threshold); settings->getNoiseParams("mgv5_np_filler_depth", np_filler_depth); settings->getNoiseParams("mgv5_np_factor", np_factor); settings->getNoiseParams("mgv5_np_height", np_height); + settings->getNoiseParams("mgv5_np_ground", np_ground); settings->getNoiseParams("mgv5_np_cave1", np_cave1); settings->getNoiseParams("mgv5_np_cave2", np_cave2); - settings->getNoiseParams("mgv5_np_ground", np_ground); + settings->getNoiseParams("mgv5_np_cavern", np_cavern); } void MapgenV5Params::writeParams(Settings *settings) const { - settings->setFlagStr("mgv5_spflags", spflags, flagdesc_mapgen_v5, U32_MAX); - settings->setFloat("mgv5_cave_width", cave_width); + settings->setFlagStr("mgv5_spflags", spflags, flagdesc_mapgen_v5, U32_MAX); + settings->setFloat("mgv5_cave_width", cave_width); + settings->setS16("mgv5_cavern_limit", cavern_limit); + settings->setS16("mgv5_cavern_taper", cavern_taper); + settings->setFloat("mgv5_cavern_threshold", cavern_threshold); settings->setNoiseParams("mgv5_np_filler_depth", np_filler_depth); settings->setNoiseParams("mgv5_np_factor", np_factor); settings->setNoiseParams("mgv5_np_height", np_height); + settings->setNoiseParams("mgv5_np_ground", np_ground); settings->setNoiseParams("mgv5_np_cave1", np_cave1); settings->setNoiseParams("mgv5_np_cave2", np_cave2); - settings->setNoiseParams("mgv5_np_ground", np_ground); + settings->setNoiseParams("mgv5_np_cavern", np_cavern); } @@ -190,9 +203,21 @@ void MapgenV5::makeChunk(BlockMakeData *data) biomegen->calcBiomeNoise(node_min); MgStoneType stone_type = generateBiomes(); - // Generate caves - if ((flags & MG_CAVES) && (stone_surface_max_y >= node_min.Y)) - generateCaves(stone_surface_max_y, MGV5_LARGE_CAVE_DEPTH); + // Generate caverns, tunnels and classic caves + if (flags & MG_CAVES) { + bool has_cavern = false; + // Generate caverns + if (spflags & MGV5_CAVERNS) + has_cavern = generateCaverns(stone_surface_max_y); + // Generate tunnels and classic caves + if (has_cavern) + // Disable classic caves in this mapchunk by setting + // 'large cave depth' to world base. Avoids excessive liquid in + // large caverns and floating blobs of overgenerated liquid. + generateCaves(stone_surface_max_y, -MAX_MAP_GENERATION_LIMIT); + else + generateCaves(stone_surface_max_y, MGV5_LARGE_CAVE_DEPTH); + } // Generate dungeons and desert temples if (flags & MG_DUNGEONS) @@ -223,23 +248,6 @@ void MapgenV5::makeChunk(BlockMakeData *data) } -//bool is_cave(u32 index) { -// double d1 = contour(noise_cave1->result[index]); -// double d2 = contour(noise_cave2->result[index]); -// return d1*d2 > CAVE_NOISE_THRESHOLD; -//} - -//bool val_is_ground(v3s16 p, u32 index, u32 index2d) { -// double f = 0.55 + noise_factor->result[index2d]; -// if(f < 0.01) -// f = 0.01; -// else if(f >= 1.0) -// f *= 1.6; -// double h = WATER_LEVEL + 10 * noise_height->result[index2d]; -// return (noise_ground->result[index] * f > (double)p.Y - h); -//} - - int MapgenV5::generateBaseTerrain() { u32 index = 0; diff --git a/src/mapgen_v5.h b/src/mapgen_v5.h index ddb090a9c..034d53560 100644 --- a/src/mapgen_v5.h +++ b/src/mapgen_v5.h @@ -25,6 +25,9 @@ with this program; if not, write to the Free Software Foundation, Inc., #define MGV5_LARGE_CAVE_DEPTH -256 +///////// Mapgen V5 flags +#define MGV5_CAVERNS 0x01 + class BiomeManager; extern FlagDesc flagdesc_mapgen_v5[]; @@ -33,12 +36,17 @@ extern FlagDesc flagdesc_mapgen_v5[]; struct MapgenV5Params : public MapgenParams { u32 spflags; float cave_width; + s16 cavern_limit; + s16 cavern_taper; + float cavern_threshold; + NoiseParams np_filler_depth; NoiseParams np_factor; NoiseParams np_height; + NoiseParams np_ground; NoiseParams np_cave1; NoiseParams np_cave2; - NoiseParams np_ground; + NoiseParams np_cavern; MapgenV5Params(); ~MapgenV5Params() {} diff --git a/src/mapgen_v7.cpp b/src/mapgen_v7.cpp index 04a9e3c16..760299fd6 100644 --- a/src/mapgen_v7.cpp +++ b/src/mapgen_v7.cpp @@ -41,10 +41,11 @@ with this program; if not, write to the Free Software Foundation, Inc., FlagDesc flagdesc_mapgen_v7[] = { - {"mountains", MGV7_MOUNTAINS}, - {"ridges", MGV7_RIDGES}, - {"floatlands", MGV7_FLOATLANDS}, - {NULL, 0} + {"mountains", MGV7_MOUNTAINS}, + {"ridges", MGV7_RIDGES}, + {"floatlands", MGV7_FLOATLANDS}, + {"caverns", MGV7_CAVERNS}, + {NULL, 0} }; @@ -60,6 +61,9 @@ MapgenV7::MapgenV7(int mapgenid, MapgenV7Params *params, EmergeManager *emerge) this->float_mount_height = params->float_mount_height; this->floatland_level = params->floatland_level; this->shadow_limit = params->shadow_limit; + this->cavern_limit = params->cavern_limit; + this->cavern_taper = params->cavern_taper; + this->cavern_threshold = params->cavern_threshold; //// Terrain noise noise_terrain_base = new Noise(¶ms->np_terrain_base, seed, csize.X, csize.Z); @@ -76,9 +80,10 @@ MapgenV7::MapgenV7(int mapgenid, MapgenV7Params *params, EmergeManager *emerge) // 1-up 1-down overgeneration noise_mountain = new Noise(¶ms->np_mountain, seed, csize.X, csize.Y + 2, csize.Z); noise_ridge = new Noise(¶ms->np_ridge, seed, csize.X, csize.Y + 2, csize.Z); - - MapgenBasic::np_cave1 = params->np_cave1; - MapgenBasic::np_cave2 = params->np_cave2; + // 1 down overgeneration + MapgenBasic::np_cave1 = params->np_cave1; + MapgenBasic::np_cave2 = params->np_cave2; + MapgenBasic::np_cavern = params->np_cavern; } @@ -100,12 +105,15 @@ MapgenV7::~MapgenV7() MapgenV7Params::MapgenV7Params() { - spflags = MGV7_MOUNTAINS | MGV7_RIDGES; + spflags = MGV7_MOUNTAINS | MGV7_RIDGES | MGV7_CAVERNS; cave_width = 0.09; float_mount_density = 0.6; float_mount_height = 128.0; floatland_level = 1280; shadow_limit = 1024; + cavern_limit = -256; + cavern_taper = 256; + cavern_threshold = 0.7; np_terrain_base = NoiseParams(4, 70, v3f(600, 600, 600), 82341, 5, 0.6, 2.0); np_terrain_alt = NoiseParams(4, 25, v3f(600, 600, 600), 5934, 5, 0.6, 2.0); @@ -118,6 +126,7 @@ MapgenV7Params::MapgenV7Params() np_float_base_height = NoiseParams(48, 24, v3f(300, 300, 300), 907, 4, 0.7, 2.0); np_mountain = NoiseParams(-0.6, 1, v3f(250, 350, 250), 5333, 5, 0.63, 2.0); np_ridge = NoiseParams(0, 1, v3f(100, 100, 100), 6467, 4, 0.75, 2.0); + np_cavern = NoiseParams(0, 1, v3f(384, 128, 384), 723, 5, 0.63, 2.0); np_cave1 = NoiseParams(0, 12, v3f(61, 61, 61), 52534, 3, 0.5, 2.0); np_cave2 = NoiseParams(0, 12, v3f(67, 67, 67), 10325, 3, 0.5, 2.0); } @@ -131,6 +140,9 @@ void MapgenV7Params::readParams(const Settings *settings) settings->getFloatNoEx("mgv7_float_mount_height", float_mount_height); settings->getS16NoEx("mgv7_floatland_level", floatland_level); settings->getS16NoEx("mgv7_shadow_limit", shadow_limit); + settings->getS16NoEx("mgv7_cavern_limit", cavern_limit); + settings->getS16NoEx("mgv7_cavern_taper", cavern_taper); + settings->getFloatNoEx("mgv7_cavern_threshold", cavern_threshold); settings->getNoiseParams("mgv7_np_terrain_base", np_terrain_base); settings->getNoiseParams("mgv7_np_terrain_alt", np_terrain_alt); @@ -143,6 +155,7 @@ void MapgenV7Params::readParams(const Settings *settings) settings->getNoiseParams("mgv7_np_float_base_height", np_float_base_height); settings->getNoiseParams("mgv7_np_mountain", np_mountain); settings->getNoiseParams("mgv7_np_ridge", np_ridge); + settings->getNoiseParams("mgv7_np_cavern", np_cavern); settings->getNoiseParams("mgv7_np_cave1", np_cave1); settings->getNoiseParams("mgv7_np_cave2", np_cave2); } @@ -156,6 +169,9 @@ void MapgenV7Params::writeParams(Settings *settings) const settings->setFloat("mgv7_float_mount_height", float_mount_height); settings->setS16("mgv7_floatland_level", floatland_level); settings->setS16("mgv7_shadow_limit", shadow_limit); + settings->setS16("mgv7_cavern_limit", cavern_limit); + settings->setS16("mgv7_cavern_taper", cavern_taper); + settings->setFloat("mgv7_cavern_threshold", cavern_threshold); settings->setNoiseParams("mgv7_np_terrain_base", np_terrain_base); settings->setNoiseParams("mgv7_np_terrain_alt", np_terrain_alt); @@ -168,6 +184,7 @@ void MapgenV7Params::writeParams(Settings *settings) const settings->setNoiseParams("mgv7_np_float_base_height", np_float_base_height); settings->setNoiseParams("mgv7_np_mountain", np_mountain); settings->setNoiseParams("mgv7_np_ridge", np_ridge); + settings->setNoiseParams("mgv7_np_cavern", np_cavern); settings->setNoiseParams("mgv7_np_cave1", np_cave1); settings->setNoiseParams("mgv7_np_cave2", np_cave2); } @@ -256,9 +273,23 @@ void MapgenV7::makeChunk(BlockMakeData *data) biomegen->calcBiomeNoise(node_min); MgStoneType stone_type = generateBiomes(); - if (flags & MG_CAVES) - generateCaves(stone_surface_max_y, water_level); + // Generate caverns, tunnels and classic caves + if (flags & MG_CAVES) { + bool has_cavern = false; + // Generate caverns + if (spflags & MGV7_CAVERNS) + has_cavern = generateCaverns(stone_surface_max_y); + // Generate tunnels and classic caves + if (has_cavern) + // Disable classic caves in this mapchunk by setting + // 'large cave depth' to world base. Avoids excessive liquid in + // large caverns and floating blobs of overgenerated liquid. + generateCaves(stone_surface_max_y, -MAX_MAP_GENERATION_LIMIT); + else + generateCaves(stone_surface_max_y, water_level); + } + // Generate dungeons if (flags & MG_DUNGEONS) generateDungeons(stone_surface_max_y, stone_type); @@ -274,8 +305,10 @@ void MapgenV7::makeChunk(BlockMakeData *data) //printf("makeChunk: %dms\n", t.stop()); + // Update liquids updateLiquid(&data->transforming_liquid, full_node_min, full_node_max); + // Calculate lighting // Limit floatland shadow bool propagate_shadow = !((spflags & MGV7_FLOATLANDS) && node_min.Y <= shadow_limit && node_max.Y >= shadow_limit); diff --git a/src/mapgen_v7.h b/src/mapgen_v7.h index 3972387a7..71a341afe 100644 --- a/src/mapgen_v7.h +++ b/src/mapgen_v7.h @@ -23,10 +23,11 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "mapgen.h" -////////////// Mapgen V7 flags -#define MGV7_MOUNTAINS 0x01 -#define MGV7_RIDGES 0x02 -#define MGV7_FLOATLANDS 0x04 +//////////// Mapgen V7 flags +#define MGV7_MOUNTAINS 0x01 +#define MGV7_RIDGES 0x02 +#define MGV7_FLOATLANDS 0x04 +#define MGV7_CAVERNS 0x08 class BiomeManager; @@ -40,6 +41,9 @@ struct MapgenV7Params : public MapgenParams { float float_mount_height; s16 floatland_level; s16 shadow_limit; + s16 cavern_limit; + s16 cavern_taper; + float cavern_threshold; NoiseParams np_terrain_base; NoiseParams np_terrain_alt; @@ -52,6 +56,7 @@ struct MapgenV7Params : public MapgenParams { NoiseParams np_float_base_height; NoiseParams np_mountain; NoiseParams np_ridge; + NoiseParams np_cavern; NoiseParams np_cave1; NoiseParams np_cave2; -- cgit v1.2.3 From b8a4c95971bff050f6fad8ce740c3be949a321a6 Mon Sep 17 00:00:00 2001 From: Paramat Date: Tue, 4 Apr 2017 06:51:58 +0100 Subject: MapgenBasic: Add lava source as commonly used content (#5512) Future mapgens are likely to use this for magma and volcanos. Remove the getting of lava source content id in mgvalleys. --- src/mapgen.cpp | 1 + src/mapgen.h | 5 +++-- src/mapgen_valleys.cpp | 3 --- src/mapgen_valleys.h | 2 -- 4 files changed, 4 insertions(+), 7 deletions(-) (limited to 'src/mapgen.cpp') diff --git a/src/mapgen.cpp b/src/mapgen.cpp index c63c426fa..bd0e94ac7 100644 --- a/src/mapgen.cpp +++ b/src/mapgen.cpp @@ -593,6 +593,7 @@ MapgenBasic::MapgenBasic(int mapgenid, MapgenParams *params, EmergeManager *emer c_sandstone = ndef->getId("mapgen_sandstone"); c_water_source = ndef->getId("mapgen_water_source"); c_river_water_source = ndef->getId("mapgen_river_water_source"); + c_lava_source = ndef->getId("mapgen_lava_source"); // Fall back to more basic content if not defined // river_water_source cannot fallback to water_source because river water diff --git a/src/mapgen.h b/src/mapgen.h index f738b1bce..653b79ed8 100644 --- a/src/mapgen.h +++ b/src/mapgen.h @@ -261,10 +261,11 @@ protected: // Content required for generateBiomes content_t c_stone; - content_t c_water_source; - content_t c_river_water_source; content_t c_desert_stone; content_t c_sandstone; + content_t c_water_source; + content_t c_river_water_source; + content_t c_lava_source; // Content required for generateDungeons content_t c_cobble; diff --git a/src/mapgen_valleys.cpp b/src/mapgen_valleys.cpp index 76a7a0582..af29eb3bd 100644 --- a/src/mapgen_valleys.cpp +++ b/src/mapgen_valleys.cpp @@ -107,9 +107,6 @@ MapgenValleys::MapgenValleys(int mapgenid, MapgenValleysParams *params, EmergeMa this->lava_max_height = water_level + MYMAX(0, lava_features_lim - 4) * 50; tcave_cache = new float[csize.Y + 2]; - - // Resolve content to be used - c_lava_source = ndef->getId("mapgen_lava_source"); } diff --git a/src/mapgen_valleys.h b/src/mapgen_valleys.h index 4a7a11bcc..0c67c3232 100644 --- a/src/mapgen_valleys.h +++ b/src/mapgen_valleys.h @@ -124,8 +124,6 @@ private: Noise *noise_valley_depth; Noise *noise_valley_profile; - content_t c_lava_source; - float terrainLevelAtPoint(s16 x, s16 z); void calculateNoise(); -- cgit v1.2.3 From 210a339dce754a6cb03d4ef82f5bacc80b63262b Mon Sep 17 00:00:00 2001 From: paramat Date: Thu, 25 May 2017 18:53:47 +0100 Subject: Mapgen files: Update and correct copyright credits --- src/mapgen.cpp | 3 ++- src/mapgen.h | 4 +++- src/mapgen_flat.cpp | 4 ++-- src/mapgen_flat.h | 4 ++-- src/mapgen_fractal.cpp | 4 ++-- src/mapgen_fractal.h | 4 ++-- src/mapgen_singlenode.cpp | 4 +++- src/mapgen_singlenode.h | 4 +++- src/mapgen_v5.cpp | 4 ++-- src/mapgen_v5.h | 4 ++-- src/mapgen_v6.cpp | 2 ++ src/mapgen_v6.h | 2 ++ src/mapgen_v7.cpp | 4 ++-- src/mapgen_v7.h | 4 ++-- src/mapgen_valleys.cpp | 5 ++--- src/mapgen_valleys.h | 5 ++--- src/mg_biome.cpp | 3 ++- src/mg_biome.h | 3 ++- src/mg_decoration.cpp | 3 ++- src/mg_decoration.h | 3 ++- src/mg_ore.cpp | 3 ++- src/mg_ore.h | 3 ++- src/mg_schematic.cpp | 3 ++- src/mg_schematic.h | 3 ++- 24 files changed, 51 insertions(+), 34 deletions(-) (limited to 'src/mapgen.cpp') diff --git a/src/mapgen.cpp b/src/mapgen.cpp index bd0e94ac7..6fd2ac580 100644 --- a/src/mapgen.cpp +++ b/src/mapgen.cpp @@ -1,7 +1,8 @@ /* Minetest -Copyright (C) 2010-2015 kwolekr, Ryan Kwolek Copyright (C) 2010-2015 celeron55, Perttu Ahola +Copyright (C) 2013-2016 kwolekr, Ryan Kwolek +Copyright (C) 2015-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen.h b/src/mapgen.h index 653b79ed8..1efd2bff7 100644 --- a/src/mapgen.h +++ b/src/mapgen.h @@ -1,6 +1,8 @@ /* Minetest -Copyright (C) 2010-2013 celeron55, Perttu Ahola +Copyright (C) 2010-2015 celeron55, Perttu Ahola +Copyright (C) 2013-2016 kwolekr, Ryan Kwolek +Copyright (C) 2015-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen_flat.cpp b/src/mapgen_flat.cpp index 0a44f71a5..604c79dd0 100644 --- a/src/mapgen_flat.cpp +++ b/src/mapgen_flat.cpp @@ -1,7 +1,7 @@ /* Minetest -Copyright (C) 2010-2015 kwolekr, Ryan Kwolek -Copyright (C) 2010-2015 paramat, Matt Gregory +Copyright (C) 2015-2017 paramat +Copyright (C) 2015-2016 kwolekr, Ryan Kwolek This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen_flat.h b/src/mapgen_flat.h index 7a6696329..18b84de76 100644 --- a/src/mapgen_flat.h +++ b/src/mapgen_flat.h @@ -1,7 +1,7 @@ /* Minetest -Copyright (C) 2010-2015 kwolekr, Ryan Kwolek -Copyright (C) 2010-2015 paramat, Matt Gregory +Copyright (C) 2015-2017 paramat +Copyright (C) 2015-2016 kwolekr, Ryan Kwolek This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen_fractal.cpp b/src/mapgen_fractal.cpp index d48d38b65..faac9e1c1 100644 --- a/src/mapgen_fractal.cpp +++ b/src/mapgen_fractal.cpp @@ -1,7 +1,7 @@ /* Minetest -Copyright (C) 2010-2015 kwolekr, Ryan Kwolek -Copyright (C) 2010-2015 paramat, Matt Gregory +Copyright (C) 2015-2017 paramat +Copyright (C) 2015-2016 kwolekr, Ryan Kwolek This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen_fractal.h b/src/mapgen_fractal.h index d049724b4..a5a09ccb9 100644 --- a/src/mapgen_fractal.h +++ b/src/mapgen_fractal.h @@ -1,7 +1,7 @@ /* Minetest -Copyright (C) 2010-2015 kwolekr, Ryan Kwolek -Copyright (C) 2010-2015 paramat, Matt Gregory +Copyright (C) 2015-2017 paramat +Copyright (C) 2015-2016 kwolekr, Ryan Kwolek Fractal formulas from http://www.bugman123.com/Hypercomplex/index.html by Paul Nylander, and from http://www.fractalforums.com, thank you. diff --git a/src/mapgen_singlenode.cpp b/src/mapgen_singlenode.cpp index ff985dd34..f49059f7f 100644 --- a/src/mapgen_singlenode.cpp +++ b/src/mapgen_singlenode.cpp @@ -1,6 +1,8 @@ /* Minetest -Copyright (C) 2010-2015 celeron55, Perttu Ahola +Copyright (C) 2013-2015 celeron55, Perttu Ahola +Copyright (C) 2013-2016 kwolekr, Ryan Kwolek +Copyright (C) 2015-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen_singlenode.h b/src/mapgen_singlenode.h index 55a503374..5171bfbca 100644 --- a/src/mapgen_singlenode.h +++ b/src/mapgen_singlenode.h @@ -1,6 +1,8 @@ /* Minetest -Copyright (C) 2010-2015 celeron55, Perttu Ahola +Copyright (C) 2013-2015 celeron55, Perttu Ahola +Copyright (C) 2013-2016 kwolekr, Ryan Kwolek +Copyright (C) 2015-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen_v5.cpp b/src/mapgen_v5.cpp index 1c4d1fd70..932677e2a 100644 --- a/src/mapgen_v5.cpp +++ b/src/mapgen_v5.cpp @@ -1,7 +1,7 @@ /* Minetest -Copyright (C) 2010-2015 kwolekr, Ryan Kwolek -Copyright (C) 2010-2015 paramat, Matt Gregory +Copyright (C) 2014-2017 paramat +Copyright (C) 2014-2016 kwolekr, Ryan Kwolek This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen_v5.h b/src/mapgen_v5.h index 1cdb33683..b742638cd 100644 --- a/src/mapgen_v5.h +++ b/src/mapgen_v5.h @@ -1,7 +1,7 @@ /* Minetest -Copyright (C) 2010-2015 kwolekr, Ryan Kwolek -Copyright (C) 2010-2015 paramat, Matt Gregory +Copyright (C) 2014-2017 paramat +Copyright (C) 2014-2016 kwolekr, Ryan Kwolek This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen_v6.cpp b/src/mapgen_v6.cpp index ff0d93496..fe2b0b36f 100644 --- a/src/mapgen_v6.cpp +++ b/src/mapgen_v6.cpp @@ -1,6 +1,8 @@ /* Minetest Copyright (C) 2010-2015 celeron55, Perttu Ahola +Copyright (C) 2013-2016 kwolekr, Ryan Kwolek +Copyright (C) 2014-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen_v6.h b/src/mapgen_v6.h index 44591e3dc..2b3b4444e 100644 --- a/src/mapgen_v6.h +++ b/src/mapgen_v6.h @@ -1,6 +1,8 @@ /* Minetest Copyright (C) 2010-2015 celeron55, Perttu Ahola +Copyright (C) 2013-2016 kwolekr, Ryan Kwolek +Copyright (C) 2014-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen_v7.cpp b/src/mapgen_v7.cpp index dbf2b02ae..5e9bc4aa3 100644 --- a/src/mapgen_v7.cpp +++ b/src/mapgen_v7.cpp @@ -1,7 +1,7 @@ /* Minetest -Copyright (C) 2010-2015 kwolekr, Ryan Kwolek -Copyright (C) 2010-2015 paramat, Matt Gregory +Copyright (C) 2013-2016 kwolekr, Ryan Kwolek +Copyright (C) 2014-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen_v7.h b/src/mapgen_v7.h index 71a341afe..a69170057 100644 --- a/src/mapgen_v7.h +++ b/src/mapgen_v7.h @@ -1,7 +1,7 @@ /* Minetest -Copyright (C) 2010-2015 kwolekr, Ryan Kwolek -Copyright (C) 2010-2015 paramat, Matt Gregory +Copyright (C) 2013-2016 kwolekr, Ryan Kwolek +Copyright (C) 2014-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mapgen_valleys.cpp b/src/mapgen_valleys.cpp index 32a32eb88..df318291c 100644 --- a/src/mapgen_valleys.cpp +++ b/src/mapgen_valleys.cpp @@ -1,8 +1,7 @@ /* Minetest Valleys C -Copyright (C) 2010-2015 kwolekr, Ryan Kwolek -Copyright (C) 2010-2015 paramat, Matt Gregory -Copyright (C) 2016 Duane Robertson +Copyright (C) 2016-2017 Duane Robertson +Copyright (C) 2016-2017 paramat Based on Valleys Mapgen by Gael de Sailly (https://forum.minetest.net/viewtopic.php?f=9&t=11430) diff --git a/src/mapgen_valleys.h b/src/mapgen_valleys.h index 0c67c3232..8a32a5a82 100644 --- a/src/mapgen_valleys.h +++ b/src/mapgen_valleys.h @@ -1,8 +1,7 @@ /* Minetest Valleys C -Copyright (C) 2010-2015 kwolekr, Ryan Kwolek -Copyright (C) 2010-2015 paramat, Matt Gregory -Copyright (C) 2016 Duane Robertson +Copyright (C) 2016-2017 Duane Robertson +Copyright (C) 2016-2017 paramat Based on Valleys Mapgen by Gael de Sailly (https://forum.minetest.net/viewtopic.php?f=9&t=11430) diff --git a/src/mg_biome.cpp b/src/mg_biome.cpp index ef7e52685..2ef2ed16a 100644 --- a/src/mg_biome.cpp +++ b/src/mg_biome.cpp @@ -1,6 +1,7 @@ /* Minetest -Copyright (C) 2010-2013 kwolekr, Ryan Kwolek +Copyright (C) 2014-2016 kwolekr, Ryan Kwolek +Copyright (C) 2014-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mg_biome.h b/src/mg_biome.h index 15088f7dd..2e07fd9cf 100644 --- a/src/mg_biome.h +++ b/src/mg_biome.h @@ -1,6 +1,7 @@ /* Minetest -Copyright (C) 2010-2013 kwolekr, Ryan Kwolek +Copyright (C) 2014-2016 kwolekr, Ryan Kwolek +Copyright (C) 2014-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mg_decoration.cpp b/src/mg_decoration.cpp index ec31a9c01..b0566e830 100644 --- a/src/mg_decoration.cpp +++ b/src/mg_decoration.cpp @@ -1,6 +1,7 @@ /* Minetest -Copyright (C) 2010-2014 kwolekr, Ryan Kwolek +Copyright (C) 2014-2016 kwolekr, Ryan Kwolek +Copyright (C) 2015-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mg_decoration.h b/src/mg_decoration.h index 986328ec3..950800ec8 100644 --- a/src/mg_decoration.h +++ b/src/mg_decoration.h @@ -1,6 +1,7 @@ /* Minetest -Copyright (C) 2010-2013 kwolekr, Ryan Kwolek +Copyright (C) 2014-2016 kwolekr, Ryan Kwolek +Copyright (C) 2015-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mg_ore.cpp b/src/mg_ore.cpp index c6c1c45a7..89319238e 100644 --- a/src/mg_ore.cpp +++ b/src/mg_ore.cpp @@ -1,6 +1,7 @@ /* Minetest -Copyright (C) 2010-2014 kwolekr, Ryan Kwolek +Copyright (C) 2014-2016 kwolekr, Ryan Kwolek +Copyright (C) 2015-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mg_ore.h b/src/mg_ore.h index e95fdd330..0503a6ca0 100644 --- a/src/mg_ore.h +++ b/src/mg_ore.h @@ -1,6 +1,7 @@ /* Minetest -Copyright (C) 2010-2013 kwolekr, Ryan Kwolek +Copyright (C) 2014-2016 kwolekr, Ryan Kwolek +Copyright (C) 2015-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mg_schematic.cpp b/src/mg_schematic.cpp index 92e138df4..67931497f 100644 --- a/src/mg_schematic.cpp +++ b/src/mg_schematic.cpp @@ -1,6 +1,7 @@ /* Minetest -Copyright (C) 2010-2014 kwolekr, Ryan Kwolek +Copyright (C) 2014-2016 kwolekr, Ryan Kwolek +Copyright (C) 2015-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by diff --git a/src/mg_schematic.h b/src/mg_schematic.h index 2f60c843b..db040343c 100644 --- a/src/mg_schematic.h +++ b/src/mg_schematic.h @@ -1,6 +1,7 @@ /* Minetest -Copyright (C) 2010-2013 kwolekr, Ryan Kwolek +Copyright (C) 2014-2016 kwolekr, Ryan Kwolek +Copyright (C) 2015-2017 paramat This program is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by -- cgit v1.2.3 From 1c69476d9f10540088ead63c8bcae91f46bc84d8 Mon Sep 17 00:00:00 2001 From: Loïc Blot Date: Thu, 1 Jun 2017 23:18:24 +0200 Subject: Show singlenode mapgen to menu (#5868) Fix #5867 --- src/mapgen.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/mapgen.cpp') diff --git a/src/mapgen.cpp b/src/mapgen.cpp index 6fd2ac580..dfe413a71 100644 --- a/src/mapgen.cpp +++ b/src/mapgen.cpp @@ -85,7 +85,7 @@ static MapgenDesc g_reg_mapgens[] = { {"flat", true}, {"fractal", true}, {"valleys", true}, - {"singlenode", false}, + {"singlenode", true}, }; STATIC_ASSERT( -- cgit v1.2.3 From c6d54411056da2dd563015c9f90c4c5c0863bc71 Mon Sep 17 00:00:00 2001 From: Loïc Blot Date: Sat, 3 Jun 2017 19:57:02 +0200 Subject: Properly remove SAO when worldedges are overtaken (#5889) * LuaEntitySAO: Remove beyond outermost mapchunk edges Based on a commit by, and with help from, nerzhul. Add 2 functions to class Mapgen: A function to calculate actual mapgen edges, called from the Mapgen constructor. A function called indirectly from content_sao.cpp per entity step to check SAO position is within mapgen edges. * Calculate borders from params not mapgen, which is not available everytime --- src/content_sao.cpp | 14 ++++++++++++++ src/map.cpp | 8 +++++--- src/map.h | 5 ++--- src/mapgen.cpp | 52 +++++++++++++++++++++++++++++++++++++++++++++++++++- src/mapgen.h | 13 ++++++++++++- 5 files changed, 84 insertions(+), 8 deletions(-) (limited to 'src/mapgen.cpp') diff --git a/src/content_sao.cpp b/src/content_sao.cpp index f435fe938..be1c52fe6 100644 --- a/src/content_sao.cpp +++ b/src/content_sao.cpp @@ -406,6 +406,20 @@ void LuaEntitySAO::step(float dtime, bool send_recommended) m_env->getScriptIface()->luaentity_Step(m_id, dtime); } + // Remove LuaEntity beyond terrain edges + { + ServerMap *map = dynamic_cast(&m_env->getMap()); + assert(map); + if (!m_pending_deactivation && + map->saoPositionOverLimit(m_base_position)) { + infostream << "Remove SAO " << m_id << "(" << m_init_name + << "), outside of limits" << std::endl; + m_pending_deactivation = true; + m_removed = true; + return; + } + } + if(send_recommended == false) return; diff --git a/src/map.cpp b/src/map.cpp index 641b7d2dd..3b02ac02f 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -1378,6 +1378,11 @@ s16 ServerMap::getWaterLevel() return getMapgenParams()->water_level; } +bool ServerMap::saoPositionOverLimit(const v3f &p) +{ + return getMapgenParams()->saoPosOverLimit(p); +} + bool ServerMap::blockpos_over_mapgen_limit(v3s16 p) { const s16 mapgen_limit_bp = rangelim( @@ -1838,9 +1843,6 @@ MapBlock *ServerMap::getBlockOrEmerge(v3s16 p3d) return block; } -void ServerMap::prepareBlock(MapBlock *block) { -} - // N.B. This requires no synchronization, since data will not be modified unless // the VoxelManipulator being updated belongs to the same thread. void ServerMap::updateVManip(v3s16 pos) diff --git a/src/map.h b/src/map.h index 41a1a246b..4b6e08f96 100644 --- a/src/map.h +++ b/src/map.h @@ -377,6 +377,8 @@ public: */ ServerMapSector *createSector(v2s16 p); + bool saoPositionOverLimit(const v3f &p); + /* Blocks are generated by using these and makeBlock(). */ @@ -409,9 +411,6 @@ public: */ MapBlock *getBlockOrEmerge(v3s16 p3d); - // Carries out any initialization necessary before block is sent - void prepareBlock(MapBlock *block); - // Helper for placing objects on ground level s16 findGroundLevel(v2s16 p2d); diff --git a/src/mapgen.cpp b/src/mapgen.cpp index dfe413a71..1f7f98621 100644 --- a/src/mapgen.cpp +++ b/src/mapgen.cpp @@ -317,7 +317,6 @@ void Mapgen::updateHeightmap(v3s16 nmin, v3s16 nmax) heightmap[index] = y; } } - //printf("updateHeightmap: %dus\n", t.stop()); } inline bool Mapgen::isLiquidHorizontallyFlowable(u32 vi, v3s16 em) @@ -1049,3 +1048,54 @@ void MapgenParams::writeParams(Settings *settings) const if (bparams) bparams->writeParams(settings); } + +// Calculate edges of outermost generated mapchunks (less than +// 'mapgen_limit'), and corresponding exact limits for SAO entities. +void MapgenParams::calcMapgenEdges() +{ + // Central chunk offset, in blocks + s16 ccoff_b = -chunksize / 2; + + // Chunksize, in nodes + s32 csize_n = chunksize * MAP_BLOCKSIZE; + + // Minp/maxp of central chunk, in nodes + s16 ccmin = ccoff_b * MAP_BLOCKSIZE; + s16 ccmax = ccmin + csize_n - 1; + // Fullminp/fullmaxp of central chunk, in nodes + s16 ccfmin = ccmin - MAP_BLOCKSIZE; + s16 ccfmax = ccmax + MAP_BLOCKSIZE; + // Effective mapgen limit, in blocks + // Uses same calculation as ServerMap::blockpos_over_mapgen_limit(v3s16 p) + s16 mapgen_limit_b = rangelim(mapgen_limit, + 0, MAX_MAP_GENERATION_LIMIT) / MAP_BLOCKSIZE; + // Effective mapgen limits, in nodes + s16 mapgen_limit_min = -mapgen_limit_b * MAP_BLOCKSIZE; + s16 mapgen_limit_max = (mapgen_limit_b + 1) * MAP_BLOCKSIZE - 1; + // Number of complete chunks from central chunk fullminp/fullmaxp + // to effective mapgen limits. + s16 numcmin = MYMAX((ccfmin - mapgen_limit_min) / csize_n, 0); + s16 numcmax = MYMAX((mapgen_limit_max - ccfmax) / csize_n, 0); + // Mapgen edges, in nodes + // These values may be useful later as additional class members + s16 mapgen_edge_min = ccmin - numcmin * csize_n; + s16 mapgen_edge_max = ccmax + numcmax * csize_n; + // SAO position limits, in Irrlicht units + m_sao_limit_min = mapgen_edge_min * BS - 3.0f; + m_sao_limit_max = mapgen_edge_max * BS + 3.0f; +} + + +bool MapgenParams::saoPosOverLimit(const v3f &p) +{ + if (!m_sao_limit_calculated) { + calcMapgenEdges(); + m_sao_limit_calculated = true; + } + return p.X < m_sao_limit_min || + p.X > m_sao_limit_max || + p.Y < m_sao_limit_min || + p.Y > m_sao_limit_max || + p.Z < m_sao_limit_min || + p.Z > m_sao_limit_max; +} diff --git a/src/mapgen.h b/src/mapgen.h index 1efd2bff7..222838011 100644 --- a/src/mapgen.h +++ b/src/mapgen.h @@ -138,7 +138,10 @@ struct MapgenParams { water_level(1), mapgen_limit(MAX_MAP_GENERATION_LIMIT), flags(MG_CAVES | MG_LIGHT | MG_DECORATIONS), - bparams(NULL) + bparams(NULL), + m_sao_limit_min(MAX_MAP_GENERATION_LIMIT * BS), + m_sao_limit_max(MAX_MAP_GENERATION_LIMIT * BS), + m_sao_limit_calculated(false) { } @@ -146,6 +149,14 @@ struct MapgenParams { virtual void readParams(const Settings *settings); virtual void writeParams(Settings *settings) const; + + bool saoPosOverLimit(const v3f &p); +private: + void calcMapgenEdges(); + + float m_sao_limit_min; + float m_sao_limit_max; + bool m_sao_limit_calculated; }; -- cgit v1.2.3