From 49ac211f87ebd104cea33794a1c51b8618c6c272 Mon Sep 17 00:00:00 2001 From: kay27 Date: Sun, 25 Apr 2021 23:31:52 +0400 Subject: [PATCH 01/21] [mapgen] Add undebugged `CORE/mcl_mapgen` mod for further integration --- mods/CORE/mcl_mapgen/API.md | 54 +++++++++++++ mods/CORE/mcl_mapgen/init.lua | 146 ++++++++++++++++++++++++++++++++++ mods/CORE/mcl_mapgen/mod.conf | 4 + 3 files changed, 204 insertions(+) create mode 100644 mods/CORE/mcl_mapgen/API.md create mode 100644 mods/CORE/mcl_mapgen/init.lua create mode 100644 mods/CORE/mcl_mapgen/mod.conf diff --git a/mods/CORE/mcl_mapgen/API.md b/mods/CORE/mcl_mapgen/API.md new file mode 100644 index 000000000..364bc3205 --- /dev/null +++ b/mods/CORE/mcl_mapgen/API.md @@ -0,0 +1,54 @@ +# mcl_mapgen +============ +This mod helps to avoid problems caused by Minetest's 'chunk-in-shell' feature of mapgen.cpp. +It also queues your generators to run them in proper order. + + +========================================================================= +## mcl_mapgen.register_chunk_generator(chunk_callback_function, priority) +========================================================================= +UNSAFE! See below. Registers callback function to be called when current chunk generation is finished. + `callback_function`: chunk callback function definition, see below; + `priority`: order number - the less, the earlier. +### Chunk callback function definition: + `function(minp, maxp, seed)`: + `minp` & `maxp`: minimum and maximum chunk position; + `seed`: seed of this mapchunk. + + +======================================================================= +## mcl_mapgen.register_chunk_generator_lvm(callback_function, priority) +======================================================================= +UNSAFE! See below. Registers callback function to be called when current chunk generation is finished. +`vm_context` passes into callback function and should be returned back. + `callback_function`: chunk callback LVM function definition, see below; + `priority`: order number - the less, the earlier. +### Chunk callback LVM function definition: + Function MUST RETURN `vm_context`. It passes into next callback function from the queue. + `function(vm_context)`: + `vm_context` is a table which already contains some LVM data and some of them can be added in callback function: + `minp` & `maxp`: minimum and maximum chunk position; + `seed`: seed of this mapchunk. + + +=================================================================== +## mcl_mapgen.register_block_generator(callback_function, priority) +=================================================================== +Registers callback function to be called when block (usually 16x16x16 nodes) generation is finished. + `callback_function`: block callback function definition, see below; + `priority`: order number - the less, the earlier. + + +======================================================================= +## mcl_mapgen.register_block_generator_lvm(callback_function, priority) +======================================================================= +Registers callback function to be called when block (usually 16x16x16 nodes) generation is finished. +`vm_context` passes into callback function and should be returned back. + `callback_function`: block callback LVM function definition, see below; + `priority`: order number - the less, the earlier. + + +=============================== +## mcl_mapgen.get_far_node(pos) +=============================== +Returns node if it is generated. Otherwise returns `{name = "ignore"}`. diff --git a/mods/CORE/mcl_mapgen/init.lua b/mods/CORE/mcl_mapgen/init.lua new file mode 100644 index 000000000..2572ce442 --- /dev/null +++ b/mods/CORE/mcl_mapgen/init.lua @@ -0,0 +1,146 @@ +mcl_mapgen = {} + +local lvm_block_queue, lvm_chunk_queue, node_block_queue, node_chunk_queue = {}, {}, {}, {} -- Generators' queues +local lvm, block, lvm_block, lvm_chunk, param2, nodes_block, nodes_chunk = 0, 0, 0, 0, 0, 0 -- Requirements: 0 means none; greater than 0 means 'required' +local lvm_buffer, lvm_param2_buffer = {}, {} -- Static buffer pointers +local BS, CS = mcl_vars.MAP_BLOCKSIZE, mcl_vars.chunksize -- Mapblock size (in nodes), Mapchunk size (in blocks) +local LAST_BLOCK, LAST_NODE = CS - 1, BS - 1 -- First mapblock in chunk (node in mapblock) has number 0, last has THIS number. It's for runtime optimization +local offset = math.floor(mcl_vars.central_chunk_offset_in_nodes / BS) -- Central mapchunk offset (in blocks) + +local DEFAULT_PRIORITY = 5000 + +local minetest_log, math_floor = minetest.log, math.floor + +function mcl_mapgen.register_chunk_generator(callback_function, priority) + nodes_chunk = nodes_chunk + 1 + node_chunk_queue[nodes_chunk] = {i = priority or DEFAULT_PRIORITY, f = callback_function} + table.sort(node_chunk_queue, function(a, b) return (a.i <= b.i) end) +end +function mcl_mapgen.register_chunk_generator_lvm(callback_function, priority) + lvm = lvm + 1 + lvm_chunk_queue[lvm_chunk] = {i = priority or DEFAULT_PRIORITY, f = callback_function} + table.sort(lvm_chunk_queue, function(a, b) return (a.i <= b.i) end) +end +function mcl_mapgen.register_block_generator(callback_function, priority) + block = block + 1 + nodes_block = nodes_block + 1 + node_block_queue[nodes_block] = {i = priority or DEFAULT_PRIORITY, f = callback_function} + table.sort(node_block_queue, function(a, b) return (a.i <= b.i) end) +end +function mcl_mapgen.register_block_generator_lvm(callback_function, priority) + block = block + 1 + lvm = lvm + 1 + lvm_block = lvm_block + 1 + lvm_block_queue[lvm_block] = {i = priority or DEFAULT_PRIORITY, f = callback_function} + table.sort(lvm_block_queue, function(a, b) return (a.i <= b.i) end) +end + + +local blocks = minetest.deserialize( storage:get_string("mapgen_blocks") or "return {}") or {} +minetest.register_on_shutdown(function() storage:set_string("mapgen_blocks", minetest.serialize(blocks)) end) + +local vm_context-- here will be many references and flags, like: param2, light_data, heightmap, biomemap, heatmap, humiditymap, gennotify, write_lvm, write_param2, shadow +local data, data2, area +local current_blocks = {} + +minetest.register_on_generated(function(minp, maxp, blockseed) + local minp, maxp, blockseed = minp, maxp, blockseed + minetest_log("verbose", "[mcl_mapgen] New chunk: minp=" .. minetest.pos_to_string(minp) .. ", maxp=" .. minetest.pos_to_string(maxp) .. ", blockseed=" .. blockseed) + + local vm, emin, emax = minetest.get_mapgen_object("voxelmanip") + + if lvm > 0 then + vm_context = {lvm_param2_buffer = lvm_param2_buffer, vm = vm, emin = emin, emax = emax, minp = minp, maxp = maxp, blockseed = blockseed} + data = vm:get_data(lvm_buffer) + vm_context.data = data + area = VoxelArea:new({MinEdge=emin, MaxEdge=emax}) + vm_context.area = area + for _, v in pairs(lvm_chunk_queue) do + vm_context = v.f(vm_context) + end + end + + if block > 0 then + local x0, y0, z0 = minp.x, minp.y, minp.z + local bx0, by0, bz0 = math_floor(x0/BS), math_floor(y0/BS), math_floor(z0/BS) + local x1, y1, z1, x2, y2, z2 = emin.x, emin.y, emin.z, emax.x, emax.y, emax.z + local x, y, z = x1, y1, z1 -- iterate 7x7x7 mapchunk, {x,y,z} - first node pos. of mapblock + local bx, by, bz -- block coords (in blocs) + local box, boy, boz -- block offsets in chunks (in blocks) + while x < x2 do + bx = math_floor(x/BS) + local block_pos_offset_removed = bx - offset + box = block_pos_offset_removed % CS + if not blocks[bx] then blocks[bx]={} end + local total_mapgen_block_writes_through_x = (box > 0 and box < LAST_BLOCK) and 4 or 8 + while y < y2 do + by = math_floor(y/BS) + block_pos_offset_removed = by - offset + boy = block_pos_offset_removed % CS + if not blocks[bx][by] then blocks[bx][by]={} end + local total_mapgen_block_writes_through_y = (boy > 0 and boy < LAST_BLOCK) and math_floor(total_mapgen_block_writes_through_x / 2) or total_mapgen_block_writes_through_x + while z < z2 do + bz = math_floor(z/BS) + block_pos_offset_removed = bz - offset + boz = block_pos_offset_removed % CS + local total_mapgen_block_writes = (boz > 0 and boz < LAST_BLOCK) and math_floor(total_mapgen_block_writes_through_y / 2) or total_mapgen_block_writes_through_y + local current_mapgen_block_writes = blocks[bx][by][bz] and (blocks[bx][by][bz] + 1) or 1 + if current_mapgen_block_writes == total_mapgen_block_writes then + -- this block shouldn't be overwritten anymore, no need to keep it in memory + blocks[bx][by][bz] = nil + vm_context.seed = blockseed + box * 7 + boy * 243 + boz * 11931 + if lvm_block > 0 then + vm_context.minp, vm_content.maxp = {x=x, y=y, z=z}, {x=x+LAST_NODE, y=y+LAST_NODE, z=z+LAST_NODE} + for _, v in pairs(lvm_block_queue) do + vm_context = v.f(vm_context) + end + end + if nodes_block > 0 then + current_blocks[#current_blocks+1] = { minp = {x=x, y=y, z=z}, maxp = {x=pos.x+LAST_NODE, y=pos.y+LAST_NODE, z=pos.z+LAST_NODE}, seed = seed } + end + else + blocks[bx][by][bz] = current_mapgen_block_writes + end + z = z + BS + end + if next(blocks[bx][by]) == nil then blocks[bx][by] = nil end + z = z1 + y = y + BS + end + if next(blocks[bx]) == nil then blocks[bx] = nil end + y = y1 + x = x + BS + end + end + + if vm_context.write then + vm:set_data(data) + end + if vm_context.write_param2 then + vm:set_param2_data(data2) + end + vm:calc_lighting(p1, p2, shadow) + vm:write_to_map() + vm:update_liquids() + + for _, v in pairs(node_chunk_queue) do + v.f(minp, maxp, blockseed) + end + + for i, b in pairs(current_blocks) do + for _, v in pairs(node_block_queue) do + v.f(b.minp, b.maxp, b.seed) + end + current_blocks[id] = nil + end +end) + +minetest.register_on_generated = mcl_mapgen.register_chunk_generator + +function mcl_mapgen.get_far_node(p) + local p = p + local node = minetest_get_node(p) + if node.name ~= "ignore" then return node end + minetest_get_voxel_manip():read_from_map(p, p) + return minetest_get_node(p) +end diff --git a/mods/CORE/mcl_mapgen/mod.conf b/mods/CORE/mcl_mapgen/mod.conf new file mode 100644 index 000000000..4f896b3cf --- /dev/null +++ b/mods/CORE/mcl_mapgen/mod.conf @@ -0,0 +1,4 @@ +name = mcl_mapgen +author = kay27 +description = MineClone 2 MapGen Basic Stuff +depends = mcl_init From abc3a1f13928c75864afc5b3d4e033e20333fe44 Mon Sep 17 00:00:00 2001 From: kay27 Date: Mon, 26 Apr 2021 03:35:54 +0400 Subject: [PATCH 02/21] [mapgen] To be continued... (this version won't run) --- mods/CORE/mcl_mapgen/init.lua | 4 +- mods/MAPGEN/mcl_mapgen_core/init.lua | 104 +++------------------------ mods/MAPGEN/mcl_mapgen_core/mod.conf | 2 +- 3 files changed, 11 insertions(+), 99 deletions(-) diff --git a/mods/CORE/mcl_mapgen/init.lua b/mods/CORE/mcl_mapgen/init.lua index 2572ce442..f6bb8fa08 100644 --- a/mods/CORE/mcl_mapgen/init.lua +++ b/mods/CORE/mcl_mapgen/init.lua @@ -1,7 +1,7 @@ mcl_mapgen = {} local lvm_block_queue, lvm_chunk_queue, node_block_queue, node_chunk_queue = {}, {}, {}, {} -- Generators' queues -local lvm, block, lvm_block, lvm_chunk, param2, nodes_block, nodes_chunk = 0, 0, 0, 0, 0, 0 -- Requirements: 0 means none; greater than 0 means 'required' +local lvm, block, lvm_block, lvm_chunk, param2, nodes_block, nodes_chunk = 0, 0, 0, 0, 0, 0, 0 -- Requirements: 0 means none; greater than 0 means 'required' local lvm_buffer, lvm_param2_buffer = {}, {} -- Static buffer pointers local BS, CS = mcl_vars.MAP_BLOCKSIZE, mcl_vars.chunksize -- Mapblock size (in nodes), Mapchunk size (in blocks) local LAST_BLOCK, LAST_NODE = CS - 1, BS - 1 -- First mapblock in chunk (node in mapblock) has number 0, last has THIS number. It's for runtime optimization @@ -35,7 +35,7 @@ function mcl_mapgen.register_block_generator_lvm(callback_function, priority) table.sort(lvm_block_queue, function(a, b) return (a.i <= b.i) end) end - +local storage = minetest.get_mod_storage() local blocks = minetest.deserialize( storage:get_string("mapgen_blocks") or "return {}") or {} minetest.register_on_shutdown(function() storage:set_string("mapgen_blocks", minetest.serialize(blocks)) end) diff --git a/mods/MAPGEN/mcl_mapgen_core/init.lua b/mods/MAPGEN/mcl_mapgen_core/init.lua index 90b272506..f46d303fd 100644 --- a/mods/MAPGEN/mcl_mapgen_core/init.lua +++ b/mods/MAPGEN/mcl_mapgen_core/init.lua @@ -1,8 +1,4 @@ mcl_mapgen_core = {} -local registered_generators = {} - -local lvm, nodes, param2 = 0, 0, 0 -local lvm_buffer = {} -- -- Aliases for map generator outputs @@ -1194,11 +1190,14 @@ local perlin_structures local perlin_vines, perlin_vines_fine, perlin_vines_upwards, perlin_vines_length, perlin_vines_density local perlin_clay -local function generate_clay(minp, maxp, blockseed, voxelmanip_data, voxelmanip_area, lvm_used) +-- Generate Clay +mcl_mapgen.register_chunk_generator_lvm(function(c) + local minp, maxp, blockseed, voxelmanip_data, voxelmanip_area, lvm_used = c.minp, c.maxp, c.blockseed, c.data, c.area, c.write or false -- TODO: Make clay generation reproducible for same seed. if maxp.y < -5 or minp.y > 0 then - return lvm_used + return c end + minetest.log("warning", "CLAY!") local pr = PseudoRandom(blockseed) @@ -1244,8 +1243,9 @@ local function generate_clay(minp, maxp, blockseed, voxelmanip_data, voxelmanip_ end end end - return lvm_used -end + c.write = lvm_used + return c +end) local function generate_end_exit_portal(pos) local dragon_entity = minetest.add_entity(vector.add(pos, vector.new(3, 11, 3)), "mobs_mc:enderdragon"):get_luaentity() @@ -1814,94 +1814,6 @@ local generate_nether_decorations = function(minp, maxp, seed) end -minetest.register_on_generated(function(minp, maxp, blockseed) - minetest.log("action", "[mcl_mapgen_core] Generating chunk " .. minetest.pos_to_string(minp) .. " ... " .. minetest.pos_to_string(maxp)) - local p1, p2 = {x=minp.x, y=minp.y, z=minp.z}, {x=maxp.x, y=maxp.y, z=maxp.z} - if lvm > 0 then - local lvm_used, shadow = false, false - local lb2 = {} -- param2 - local vm, emin, emax = minetest.get_mapgen_object("voxelmanip") - local e1, e2 = {x=emin.x, y=emin.y, z=emin.z}, {x=emax.x, y=emax.y, z=emax.z} - local data2 - local data = vm:get_data(lvm_buffer) - if param2 > 0 then - data2 = vm:get_param2_data(lb2) - end - local area = VoxelArea:new({MinEdge=e1, MaxEdge=e2}) - - for _, rec in pairs(registered_generators) do - if rec.vf then - local lvm_used0, shadow0 = rec.vf(vm, data, data2, e1, e2, area, p1, p2, blockseed) - if lvm_used0 then - lvm_used = true - end - if shadow0 then - shadow = true - end - end - end - - if lvm_used then - -- Write stuff - vm:set_data(data) - if param2 > 0 then - vm:set_param2_data(data2) - end - vm:calc_lighting(p1, p2, shadow) - vm:write_to_map() - vm:update_liquids() - end - end - - if nodes > 0 then - for _, rec in pairs(registered_generators) do - if rec.nf then - rec.nf(p1, p2, blockseed) - end - end - end - - mcl_vars.add_chunk(minp) -end) - -minetest.register_on_generated=function(node_function) - mcl_mapgen_core.register_generator("mod_"..tostring(#registered_generators+1), nil, node_function) -end - -function mcl_mapgen_core.register_generator(id, lvm_function, node_function, priority, needs_param2) - if not id then return end - - local priority = priority or 5000 - - if lvm_function then lvm = lvm + 1 end - if lvm_function then nodes = nodes + 1 end - if needs_param2 then param2 = param2 + 1 end - - local new_record = { - i = priority, - vf = lvm_function, - nf = node_function, - needs_param2 = needs_param2, - } - - registered_generators[id] = new_record - table.sort( - registered_generators, - function(a, b) - return (a.i < b.i) or ((a.i == b.i) and (a.vf ~= nil) and (b.vf == nil)) - end) -end - -function mcl_mapgen_core.unregister_generator(id) - if not registered_generators[id] then return end - local rec = registered_generators[id] - registered_generators[id] = nil - if rec.vf then lvm = lvm - 1 end - if rec.nf then nodes = nodes - 1 end - if rec.needs_param2 then param2 = param2 - 1 end - if rec.needs_level0 then level0 = level0 - 1 end -end - -- Generate basic layer-based nodes: void, bedrock, realm barrier, lava seas, etc. -- Also perform some basic node replacements. diff --git a/mods/MAPGEN/mcl_mapgen_core/mod.conf b/mods/MAPGEN/mcl_mapgen_core/mod.conf index 9f7d9ebaa..2ea3e45bb 100644 --- a/mods/MAPGEN/mcl_mapgen_core/mod.conf +++ b/mods/MAPGEN/mcl_mapgen_core/mod.conf @@ -1,5 +1,5 @@ name = mcl_mapgen_core author = Wuzzy description = The core of the MCL2 mapgen -depends = mcl_init, mcl_core, biomeinfo, mcl_worlds, mcl_cocoas, mcl_sponges, mcl_ocean, mcl_stairs, mcl_monster_eggs, mcl_structures +depends = mcl_mapgen, mcl_core, biomeinfo, mcl_worlds, mcl_cocoas, mcl_sponges, mcl_ocean, mcl_stairs, mcl_monster_eggs, mcl_structures optional_depends = mclx_core From 942d70ee623a9c5c66b451e8779d294dfdf90cd7 Mon Sep 17 00:00:00 2001 From: kay27 Date: Mon, 26 Apr 2021 04:09:14 +0400 Subject: [PATCH 03/21] [mapgen] temporarily delay chorus nodes grow --- mods/MAPGEN/mcl_biomes/init.lua | 11 ++++++----- mods/MAPGEN/mcl_dungeons/init.lua | 2 +- mods/MAPGEN/mcl_mapgen_core/init.lua | 12 ++++++++---- 3 files changed, 15 insertions(+), 10 deletions(-) diff --git a/mods/MAPGEN/mcl_biomes/init.lua b/mods/MAPGEN/mcl_biomes/init.lua index f583d87b6..9facd83b3 100644 --- a/mods/MAPGEN/mcl_biomes/init.lua +++ b/mods/MAPGEN/mcl_biomes/init.lua @@ -3971,13 +3971,14 @@ if mg_name ~= "singlenode" then -- Overworld decorations for v6 are handled in mcl_mapgen_core if deco_id_chorus_plant then - mcl_mapgen_core.register_generator("chorus_grow", nil, function(minp, maxp, blockseed) - local gennotify = minetest.get_mapgen_object("gennotify") - --local poslist = {} - for _, pos in ipairs(gennotify["decoration#"..deco_id_chorus_plant] or {}) do + mcl_mapgen.register_chunk_generator_lvm(function(c) + c.gennotify = c.gennotify or minetest.get_mapgen_object("gennotify") + local gennotify = c.gennotify + for _, pos in pairs(gennotify["decoration#"..deco_id_chorus_plant] or {}) do local realpos = { x = pos.x, y = pos.y + 1, z = pos.z } - mcl_end.grow_chorus_plant(realpos) + minetest.after(1, mcl_end.grow_chorus_plant, realpos) end + return c end) end diff --git a/mods/MAPGEN/mcl_dungeons/init.lua b/mods/MAPGEN/mcl_dungeons/init.lua index 58e23b12e..63433d08d 100644 --- a/mods/MAPGEN/mcl_dungeons/init.lua +++ b/mods/MAPGEN/mcl_dungeons/init.lua @@ -416,4 +416,4 @@ function mcl_dungeons.spawn_dungeon(p1, _, pr) emerge_area(p1, p2, ecb_spawn_dungeon, {p1=p1, p2=p2, dim=dim, pr=pr, dontcheck=true}) end -mcl_mapgen_core.register_generator("dungeons", nil, dungeons_nodes, 999999) +mcl_mapgen.register_chunk_generator(dungeons_nodes, 999999) diff --git a/mods/MAPGEN/mcl_mapgen_core/init.lua b/mods/MAPGEN/mcl_mapgen_core/init.lua index f46d303fd..031a568f7 100644 --- a/mods/MAPGEN/mcl_mapgen_core/init.lua +++ b/mods/MAPGEN/mcl_mapgen_core/init.lua @@ -1890,8 +1890,11 @@ local function set_layers(data, area, content_id, check, min, max, minp, maxp, l end -- Below the bedrock, generate air/void -local function basic(vm, data, data2, emin, emax, area, minp, maxp, blockseed) - local biomemap --ymin, ymax +local function basic(c) + local vm, data, emin, emax, area, minp, maxp, blockseed = c.vm, c.data, c.emin, c.emax, c.area, c.minp, c.maxp, c.blockseed + c.data2 = c.data2 or vm:get_data_param2(lvm_buffer_param2) + local data2 = c.data2 + local lvm_used = false local pr = PseudoRandom(blockseed) @@ -1935,7 +1938,8 @@ local function basic(vm, data, data2, emin, emax, area, minp, maxp, blockseed) -- Clay, vines, cocoas lvm_used = generate_clay(minp, maxp, blockseed, data, area, lvm_used) - biomemap = minetest.get_mapgen_object("biomemap") + c.biomemap = c.biomemap or minetest.get_mapgen_object("biomemap") + lvm_used = generate_tree_decorations(minp, maxp, blockseed, data, data2, area, biomemap, lvm_used, pr) ----- Interactive block fixing section ----- @@ -2098,5 +2102,5 @@ local function basic(vm, data, data2, emin, emax, area, minp, maxp, blockseed) return lvm_used, shadow end -mcl_mapgen_core.register_generator("main", basic, nil, 1, true) +mcl_mapgen.register_chunk_generator_lvm(basic, 1) From 269e560db1ff8e8ef21475aff7fd6e6553c7cfad Mon Sep 17 00:00:00 2001 From: kay27 Date: Mon, 26 Apr 2021 20:14:36 +0400 Subject: [PATCH 04/21] [mapgen] Fix old-style API calls, make the code runnable --- mods/MAPGEN/mcl_strongholds/init.lua | 10 ++++------ mods/MAPGEN/mcl_villages/init.lua | 2 +- mods/MAPGEN/tsm_railcorridors/init.lua | 2 +- 3 files changed, 6 insertions(+), 8 deletions(-) diff --git a/mods/MAPGEN/mcl_strongholds/init.lua b/mods/MAPGEN/mcl_strongholds/init.lua index e465b2e40..42544e1ed 100644 --- a/mods/MAPGEN/mcl_strongholds/init.lua +++ b/mods/MAPGEN/mcl_strongholds/init.lua @@ -66,8 +66,10 @@ local init_strongholds = function() strongholds_inited = true end +init_strongholds() + -- Stronghold generation for register_on_generated. -local generate_strongholds = function(minp, maxp, blockseed) +mcl_mapgen.register_chunk_generator(function(minp, maxp, blockseed) local pr = PseudoRandom(blockseed) for s=1, #strongholds do if not strongholds[s].generated then @@ -99,8 +101,4 @@ local generate_strongholds = function(minp, maxp, blockseed) end end end -end - -init_strongholds() - -mcl_mapgen_core.register_generator("strongholds", nil, generate_strongholds, 999999) +end, 999999) diff --git a/mods/MAPGEN/mcl_villages/init.lua b/mods/MAPGEN/mcl_villages/init.lua index ccc3f585d..f1b1de906 100644 --- a/mods/MAPGEN/mcl_villages/init.lua +++ b/mods/MAPGEN/mcl_villages/init.lua @@ -78,7 +78,7 @@ end -- Disable natural generation in singlenode. local mg_name = minetest.get_mapgen_setting("mg_name") if mg_name ~= "singlenode" then - mcl_mapgen_core.register_generator("villages", nil, function(minp, maxp, blockseed) + mcl_mapgen.register_chunk_generator(function(minp, maxp, blockseed) -- don't build settlement underground if maxp.y < 0 then return end -- randomly try to build settlements diff --git a/mods/MAPGEN/tsm_railcorridors/init.lua b/mods/MAPGEN/tsm_railcorridors/init.lua index 2414cc962..f5a8b4908 100644 --- a/mods/MAPGEN/tsm_railcorridors/init.lua +++ b/mods/MAPGEN/tsm_railcorridors/init.lua @@ -1089,7 +1089,7 @@ local function create_corridor_system(main_cave_coords) end -- The rail corridor algorithm starts here -mcl_mapgen_core.register_generator("railcorridors", nil, function(minp, maxp, blockseed, _pr) +mcl_mapgen.register_chunk_generator(function(minp, maxp, blockseed, _pr) -- We re-init the randomizer for every mapchunk as we start generating in the middle of each mapchunk. -- We can't use the mapgen seed as this would make the algorithm depending on the order the mapchunk generate. InitRandomizer(blockseed) From 3f20d8c1f0891010debcc7bdc79e6f3e5af6a061 Mon Sep 17 00:00:00 2001 From: kay27 Date: Mon, 26 Apr 2021 20:37:13 +0400 Subject: [PATCH 05/21] [mapgen] ... and make it unrunnable back --- mods/CORE/mcl_init/init.lua | 56 ----------------------------- mods/CORE/mcl_mapgen/init.lua | 66 +++++++++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+), 56 deletions(-) diff --git a/mods/CORE/mcl_init/init.lua b/mods/CORE/mcl_init/init.lua index 066e555df..7441267d9 100644 --- a/mods/CORE/mcl_init/init.lua +++ b/mods/CORE/mcl_init/init.lua @@ -30,62 +30,6 @@ local minecraft_height_limit = 256 local superflat = mg_name == "flat" and minetest.get_mapgen_setting("mcl_superflat_classic") == "true" local singlenode = mg_name == "singlenode" --- Calculate mapgen_edge_min/mapgen_edge_max -mcl_vars.chunksize = math.max(1, tonumber(minetest.get_mapgen_setting("chunksize")) or 5) -mcl_vars.MAP_BLOCKSIZE = math.max(1, core.MAP_BLOCKSIZE or 16) -mcl_vars.mapgen_limit = math.max(1, tonumber(minetest.get_mapgen_setting("mapgen_limit")) or 31000) -mcl_vars.MAX_MAP_GENERATION_LIMIT = math.max(1, core.MAX_MAP_GENERATION_LIMIT or 31000) -local central_chunk_offset = -math.floor(mcl_vars.chunksize / 2) -mcl_vars.central_chunk_offset_in_nodes = central_chunk_offset * mcl_vars.MAP_BLOCKSIZE -mcl_vars.chunk_size_in_nodes = mcl_vars.chunksize * mcl_vars.MAP_BLOCKSIZE -local central_chunk_min_pos = central_chunk_offset * mcl_vars.MAP_BLOCKSIZE -local central_chunk_max_pos = central_chunk_min_pos + mcl_vars.chunk_size_in_nodes - 1 -local ccfmin = central_chunk_min_pos - mcl_vars.MAP_BLOCKSIZE -- Fullminp/fullmaxp of central chunk, in nodes -local ccfmax = central_chunk_max_pos + mcl_vars.MAP_BLOCKSIZE -local mapgen_limit_b = math.floor(math.min(mcl_vars.mapgen_limit, mcl_vars.MAX_MAP_GENERATION_LIMIT) / mcl_vars.MAP_BLOCKSIZE) -local mapgen_limit_min = -mapgen_limit_b * mcl_vars.MAP_BLOCKSIZE -local mapgen_limit_max = (mapgen_limit_b + 1) * mcl_vars.MAP_BLOCKSIZE - 1 -local numcmin = math.max(math.floor((ccfmin - mapgen_limit_min) / mcl_vars.chunk_size_in_nodes), 0) -- Number of complete chunks from central chunk -local numcmax = math.max(math.floor((mapgen_limit_max - ccfmax) / mcl_vars.chunk_size_in_nodes), 0) -- fullminp/fullmaxp to effective mapgen limits. -mcl_vars.mapgen_edge_min = central_chunk_min_pos - numcmin * mcl_vars.chunk_size_in_nodes -mcl_vars.mapgen_edge_max = central_chunk_max_pos + numcmax * mcl_vars.chunk_size_in_nodes - -local function coordinate_to_block(x) - return math.floor(x / mcl_vars.MAP_BLOCKSIZE) -end - -local function coordinate_to_chunk(x) - return math.floor((coordinate_to_block(x) - central_chunk_offset) / mcl_vars.chunksize) -end - -function mcl_vars.pos_to_block(pos) - return { - x = coordinate_to_block(pos.x), - y = coordinate_to_block(pos.y), - z = coordinate_to_block(pos.z) - } -end - -function mcl_vars.pos_to_chunk(pos) - return { - x = coordinate_to_chunk(pos.x), - y = coordinate_to_chunk(pos.y), - z = coordinate_to_chunk(pos.z) - } -end - -local k_positive = math.ceil(mcl_vars.MAX_MAP_GENERATION_LIMIT / mcl_vars.chunk_size_in_nodes) -local k_positive_z = k_positive * 2 -local k_positive_y = k_positive_z * k_positive_z - -function mcl_vars.get_chunk_number(pos) -- unsigned int - local c = mcl_vars.pos_to_chunk(pos) - return - (c.y + k_positive) * k_positive_y + - (c.z + k_positive) * k_positive_z + - c.x + k_positive -end - if not superflat and not singlenode then -- Normal mode --[[ Realm stacking (h is for height) diff --git a/mods/CORE/mcl_mapgen/init.lua b/mods/CORE/mcl_mapgen/init.lua index f6bb8fa08..056da9146 100644 --- a/mods/CORE/mcl_mapgen/init.lua +++ b/mods/CORE/mcl_mapgen/init.lua @@ -144,3 +144,69 @@ function mcl_mapgen.get_far_node(p) minetest_get_voxel_manip():read_from_map(p, p) return minetest_get_node(p) end + +-- Calculate mapgen_edge_min/mapgen_edge_max +local function calculate_mapgen_basics() + mcl_mapgen.CS = math.max(1, tonumber(minetest.get_mapgen_setting("chunksize")) or 5) + mcl_mapgen.BS = math.max(1, core.MAP_BLOCKSIZE or 16) + mcl_mapgen.LIMIT = math.max(1, tonumber(minetest.get_mapgen_setting("mapgen_limit")) or 31000) + mcl_mapgen.MAX_LIMIT = math.max(1, core.MAX_MAP_GENERATION_LIMIT or 31000) + mcl_mapgen.OFFSET = - math.floor(mcl_mapgen.CS / 2) + mcl_mapgen.OFFSET_NODES = mcl_mapgen.OFFSET * mcl_mapgen.BS + mcl_mapgen.CS_NODES = mcl_mapgen.CS * mcl_mapgen.BS + + local central_chunk_min_pos = mcl_mapgen.OFFSET * mcl_mapgen.BS + local central_chunk_max_pos = central_chunk_min_pos + mcl_mapgen.CS_NODES - 1 + + local ccfmin = central_chunk_min_pos - mcl_mapgen.BS -- Fullminp/fullmaxp of central chunk, in nodes + local ccfmax = central_chunk_max_pos + mcl_mapgen.BS + + local mapgen_limit_b = math.floor(math.min(mcl_mapgen.LIMIT, mcl_mapgen.MAX_LIMIT) / mcl_mapgen.BS) + local mapgen_limit_min = - mapgen_limit_b * mcl_mapgen.BS + local mapgen_limit_max = (mapgen_limit_b + 1) * mcl_mapgen.BS - 1 + + local numcmin = math.max(math.floor((ccfmin - mapgen_limit_min) / mcl_vars.chunk_size_in_nodes), 0) -- Number of complete chunks from central chunk + local numcmax = math.max(math.floor((mapgen_limit_max - ccfmax) / mcl_vars.chunk_size_in_nodes), 0) -- fullminp/fullmaxp to effective mapgen limits. + + mcl_mapgen.EDGE_MIN = central_chunk_min_pos - numcmin * mcl_mapgen.CS_NODES + mcl_mapgen.EDGE_MAX = central_chunk_max_pos + numcmax * mcl_mapgen.CS_NODES +end + +local function coordinate_to_block(x) + return math_floor(x / mcl_mapgen.BS) +end + +local function coordinate_to_chunk(x) + return math_floor((coordinate_to_block(x) - central_chunk_offset) / mcl_vars.chunksize) +end + +function mcl_mapgen.pos_to_block(pos) + return { + x = coordinate_to_block(pos.x), + y = coordinate_to_block(pos.y), + z = coordinate_to_block(pos.z) + } +end + +function mcl_mapgen.pos_to_chunk(pos) + return { + x = coordinate_to_chunk(pos.x), + y = coordinate_to_chunk(pos.y), + z = coordinate_to_chunk(pos.z) + } +end + +calculate_mapgen_basics() + +local k_positive = math.ceil(mcl_mapgen.MAX_LIMIT / mcl_vars.chunk_size_in_nodes) +local k_positive_z = k_positive * 2 +local k_positive_y = k_positive_z * k_positive_z + +function mcl_mapgen.get_chunk_number(pos) -- unsigned int + local c = mcl_mapgen.pos_to_chunk(pos) + return + (c.y + k_positive) * k_positive_y + + (c.z + k_positive) * k_positive_z + + c.x + k_positive +end + From 29727136ac1975751c8a395e51d0653589de3f1b Mon Sep 17 00:00:00 2001 From: kay27 Date: Tue, 27 Apr 2021 01:30:07 +0400 Subject: [PATCH 06/21] [mapgen] redesign the code --- mods/CORE/mcl_init/init.lua | 174 -------- mods/CORE/mcl_mapgen/init.lua | 517 +++++++++++++---------- mods/ENTITIES/mcl_mobs/api.lua | 15 +- mods/ENTITIES/mcl_mobs/mod.conf | 2 +- mods/ITEMS/mcl_portals/mod.conf | 2 +- mods/ITEMS/mcl_portals/portal_nether.lua | 6 +- mods/MAPGEN/mcl_dungeons/init.lua | 2 +- mods/MAPGEN/mcl_dungeons/mod.conf | 2 +- mods/MAPGEN/mcl_mapgen_core/init.lua | 2 +- mods/PLAYER/mcl_spawn/init.lua | 2 +- mods/PLAYER/mcl_spawn/mod.conf | 2 +- 11 files changed, 317 insertions(+), 409 deletions(-) diff --git a/mods/CORE/mcl_init/init.lua b/mods/CORE/mcl_init/init.lua index 7441267d9..cd88b8dfc 100644 --- a/mods/CORE/mcl_init/init.lua +++ b/mods/CORE/mcl_init/init.lua @@ -24,97 +24,6 @@ mcl_vars.inventory_header = "" -- Tool wield size mcl_vars.tool_wield_scale = { x = 1.8, y = 1.8, z = 1 } --- Mapgen variables -local mg_name = minetest.get_mapgen_setting("mg_name") -local minecraft_height_limit = 256 -local superflat = mg_name == "flat" and minetest.get_mapgen_setting("mcl_superflat_classic") == "true" -local singlenode = mg_name == "singlenode" - -if not superflat and not singlenode then - -- Normal mode - --[[ Realm stacking (h is for height) - - Overworld (h>=256) - - Void (h>=1000) - - Realm Barrier (h=11), to allow escaping the End - - End (h>=256) - - Void (h>=1000) - - Nether (h=128) - - Void (h>=1000) - ]] - - -- Overworld - mcl_vars.mg_overworld_min = -62 - mcl_vars.mg_overworld_max_official = mcl_vars.mg_overworld_min + minecraft_height_limit - mcl_vars.mg_bedrock_overworld_min = mcl_vars.mg_overworld_min - mcl_vars.mg_bedrock_overworld_max = mcl_vars.mg_bedrock_overworld_min + 4 - mcl_vars.mg_lava_overworld_max = mcl_vars.mg_overworld_min + 10 - mcl_vars.mg_lava = true - mcl_vars.mg_bedrock_is_rough = true - -elseif singlenode then - mcl_vars.mg_overworld_min = -66 - mcl_vars.mg_overworld_max_official = mcl_vars.mg_overworld_min + minecraft_height_limit - mcl_vars.mg_bedrock_overworld_min = mcl_vars.mg_overworld_min - mcl_vars.mg_bedrock_overworld_max = mcl_vars.mg_bedrock_overworld_min - mcl_vars.mg_lava = false - mcl_vars.mg_lava_overworld_max = mcl_vars.mg_overworld_min - mcl_vars.mg_bedrock_is_rough = false -else - -- Classic superflat - local ground = minetest.get_mapgen_setting("mgflat_ground_level") - ground = tonumber(ground) - if not ground then - ground = 8 - end - mcl_vars.mg_overworld_min = ground - 3 - mcl_vars.mg_overworld_max_official = mcl_vars.mg_overworld_min + minecraft_height_limit - mcl_vars.mg_bedrock_overworld_min = mcl_vars.mg_overworld_min - mcl_vars.mg_bedrock_overworld_max = mcl_vars.mg_bedrock_overworld_min - mcl_vars.mg_lava = false - mcl_vars.mg_lava_overworld_max = mcl_vars.mg_overworld_min - mcl_vars.mg_bedrock_is_rough = false -end - -mcl_vars.mg_overworld_max = mcl_vars.mapgen_edge_max - --- The Nether (around Y = -29000) -mcl_vars.mg_nether_min = -29067 -- Carefully chosen to be at a mapchunk border -mcl_vars.mg_nether_max = mcl_vars.mg_nether_min + 128 -mcl_vars.mg_bedrock_nether_bottom_min = mcl_vars.mg_nether_min -mcl_vars.mg_bedrock_nether_top_max = mcl_vars.mg_nether_max -if not superflat then - mcl_vars.mg_bedrock_nether_bottom_max = mcl_vars.mg_bedrock_nether_bottom_min + 4 - mcl_vars.mg_bedrock_nether_top_min = mcl_vars.mg_bedrock_nether_top_max - 4 - mcl_vars.mg_lava_nether_max = mcl_vars.mg_nether_min + 31 -else - -- Thin bedrock in classic superflat mapgen - mcl_vars.mg_bedrock_nether_bottom_max = mcl_vars.mg_bedrock_nether_bottom_min - mcl_vars.mg_bedrock_nether_top_min = mcl_vars.mg_bedrock_nether_top_max - mcl_vars.mg_lava_nether_max = mcl_vars.mg_nether_min + 2 -end -if mg_name == "flat" then - if superflat then - mcl_vars.mg_flat_nether_floor = mcl_vars.mg_bedrock_nether_bottom_max + 4 - mcl_vars.mg_flat_nether_ceiling = mcl_vars.mg_bedrock_nether_bottom_max + 52 - else - mcl_vars.mg_flat_nether_floor = mcl_vars.mg_lava_nether_max + 4 - mcl_vars.mg_flat_nether_ceiling = mcl_vars.mg_lava_nether_max + 52 - end -end - --- The End (surface at ca. Y = -27000) -mcl_vars.mg_end_min = -27073 -- Carefully chosen to be at a mapchunk border -mcl_vars.mg_end_max_official = mcl_vars.mg_end_min + minecraft_height_limit -mcl_vars.mg_end_max = mcl_vars.mg_overworld_min - 2000 -mcl_vars.mg_end_platform_pos = { x = 100, y = mcl_vars.mg_end_min + 74, z = 0 } - --- Realm barrier used to safely separate the End from the void below the Overworld -mcl_vars.mg_realm_barrier_overworld_end_max = mcl_vars.mg_end_max -mcl_vars.mg_realm_barrier_overworld_end_min = mcl_vars.mg_end_max - 11 - --- Use MineClone 2-style dungeons -mcl_vars.mg_dungeons = true - -- Set default stack sizes minetest.nodedef_default.stack_max = 64 minetest.craftitemdef_default.stack_max = 64 @@ -122,86 +31,3 @@ minetest.craftitemdef_default.stack_max = 64 -- Set random seed for all other mods (Remember to make sure no other mod calls this function) math.randomseed(os.time()) -local chunks = {} -- intervals of chunks generated -function mcl_vars.add_chunk(pos) - local n = mcl_vars.get_chunk_number(pos) -- unsigned int - local prev - for i, d in pairs(chunks) do - if n <= d[2] then -- we've found it - if (n == d[2]) or (n >= d[1]) then return end -- already here - if n == d[1]-1 then -- right before: - if prev and (prev[2] == n-1) then - prev[2] = d[2] - table.remove(chunks, i) - return - end - d[1] = n - return - end - if prev and (prev[2] == n-1) then --join to previous - prev[2] = n - return - end - table.insert(chunks, i, {n, n}) -- insert new interval before i - return - end - prev = d - end - chunks[#chunks+1] = {n, n} -end -function mcl_vars.is_generated(pos) - local n = mcl_vars.get_chunk_number(pos) -- unsigned int - for i, d in pairs(chunks) do - if n <= d[2] then - return (n >= d[1]) - end - end - return false -end - --- "Trivial" (actually NOT) function to just read the node and some stuff to not just return "ignore", like mt 5.4 does. --- p: Position, if it's wrong, {name="error"} node will return. --- force: optional (default: false) - Do the maximum to still read the node within us_timeout. --- us_timeout: optional (default: 244 = 0.000244 s = 1/80/80/80), set it at least to 3000000 to let mapgen to finish its job. --- --- returns node definition, eg. {name="air"}. Unfortunately still can return {name="ignore"}. -function mcl_vars.get_node(p, force, us_timeout) - -- check initial circumstances - if not p or not p.x or not p.y or not p.z then return {name="error"} end - - -- try common way - local node = minetest.get_node(p) - if node.name ~= "ignore" then - return node - end - - -- copy table to get sure it won't changed by other threads - local pos = {x=p.x,y=p.y,z=p.z} - - -- try LVM - minetest.get_voxel_manip():read_from_map(pos, pos) - node = minetest.get_node(pos) - if node.name ~= "ignore" or not force then - return node - end - - -- all ways failed - need to emerge (or forceload if generated) - local us_timeout = us_timeout or 244 - if mcl_vars.is_generated(pos) then - minetest.chat_send_all("IMPOSSIBLE! Please report this to MCL2 issue tracker!") - minetest.forceload_block(pos) - else - minetest.emerge_area(pos, pos) - end - - local t = minetest.get_us_time() - - node = minetest.get_node(pos) - - while (not node or node.name == "ignore") and (minetest.get_us_time() - t < us_timeout) do - node = minetest.get_node(pos) - end - - return node - -- it still can return "ignore", LOL, even if force = true, but only after time out -end diff --git a/mods/CORE/mcl_mapgen/init.lua b/mods/CORE/mcl_mapgen/init.lua index 056da9146..f5c6a16f9 100644 --- a/mods/CORE/mcl_mapgen/init.lua +++ b/mods/CORE/mcl_mapgen/init.lua @@ -1,212 +1,305 @@ -mcl_mapgen = {} - -local lvm_block_queue, lvm_chunk_queue, node_block_queue, node_chunk_queue = {}, {}, {}, {} -- Generators' queues -local lvm, block, lvm_block, lvm_chunk, param2, nodes_block, nodes_chunk = 0, 0, 0, 0, 0, 0, 0 -- Requirements: 0 means none; greater than 0 means 'required' -local lvm_buffer, lvm_param2_buffer = {}, {} -- Static buffer pointers -local BS, CS = mcl_vars.MAP_BLOCKSIZE, mcl_vars.chunksize -- Mapblock size (in nodes), Mapchunk size (in blocks) -local LAST_BLOCK, LAST_NODE = CS - 1, BS - 1 -- First mapblock in chunk (node in mapblock) has number 0, last has THIS number. It's for runtime optimization -local offset = math.floor(mcl_vars.central_chunk_offset_in_nodes / BS) -- Central mapchunk offset (in blocks) - -local DEFAULT_PRIORITY = 5000 - -local minetest_log, math_floor = minetest.log, math.floor - -function mcl_mapgen.register_chunk_generator(callback_function, priority) - nodes_chunk = nodes_chunk + 1 - node_chunk_queue[nodes_chunk] = {i = priority or DEFAULT_PRIORITY, f = callback_function} - table.sort(node_chunk_queue, function(a, b) return (a.i <= b.i) end) -end -function mcl_mapgen.register_chunk_generator_lvm(callback_function, priority) - lvm = lvm + 1 - lvm_chunk_queue[lvm_chunk] = {i = priority or DEFAULT_PRIORITY, f = callback_function} - table.sort(lvm_chunk_queue, function(a, b) return (a.i <= b.i) end) -end -function mcl_mapgen.register_block_generator(callback_function, priority) - block = block + 1 - nodes_block = nodes_block + 1 - node_block_queue[nodes_block] = {i = priority or DEFAULT_PRIORITY, f = callback_function} - table.sort(node_block_queue, function(a, b) return (a.i <= b.i) end) -end -function mcl_mapgen.register_block_generator_lvm(callback_function, priority) - block = block + 1 - lvm = lvm + 1 - lvm_block = lvm_block + 1 - lvm_block_queue[lvm_block] = {i = priority or DEFAULT_PRIORITY, f = callback_function} - table.sort(lvm_block_queue, function(a, b) return (a.i <= b.i) end) -end - -local storage = minetest.get_mod_storage() -local blocks = minetest.deserialize( storage:get_string("mapgen_blocks") or "return {}") or {} -minetest.register_on_shutdown(function() storage:set_string("mapgen_blocks", minetest.serialize(blocks)) end) - -local vm_context-- here will be many references and flags, like: param2, light_data, heightmap, biomemap, heatmap, humiditymap, gennotify, write_lvm, write_param2, shadow -local data, data2, area -local current_blocks = {} - -minetest.register_on_generated(function(minp, maxp, blockseed) - local minp, maxp, blockseed = minp, maxp, blockseed - minetest_log("verbose", "[mcl_mapgen] New chunk: minp=" .. minetest.pos_to_string(minp) .. ", maxp=" .. minetest.pos_to_string(maxp) .. ", blockseed=" .. blockseed) - - local vm, emin, emax = minetest.get_mapgen_object("voxelmanip") - - if lvm > 0 then - vm_context = {lvm_param2_buffer = lvm_param2_buffer, vm = vm, emin = emin, emax = emax, minp = minp, maxp = maxp, blockseed = blockseed} - data = vm:get_data(lvm_buffer) - vm_context.data = data - area = VoxelArea:new({MinEdge=emin, MaxEdge=emax}) - vm_context.area = area - for _, v in pairs(lvm_chunk_queue) do - vm_context = v.f(vm_context) - end - end - - if block > 0 then - local x0, y0, z0 = minp.x, minp.y, minp.z - local bx0, by0, bz0 = math_floor(x0/BS), math_floor(y0/BS), math_floor(z0/BS) - local x1, y1, z1, x2, y2, z2 = emin.x, emin.y, emin.z, emax.x, emax.y, emax.z - local x, y, z = x1, y1, z1 -- iterate 7x7x7 mapchunk, {x,y,z} - first node pos. of mapblock - local bx, by, bz -- block coords (in blocs) - local box, boy, boz -- block offsets in chunks (in blocks) - while x < x2 do - bx = math_floor(x/BS) - local block_pos_offset_removed = bx - offset - box = block_pos_offset_removed % CS - if not blocks[bx] then blocks[bx]={} end - local total_mapgen_block_writes_through_x = (box > 0 and box < LAST_BLOCK) and 4 or 8 - while y < y2 do - by = math_floor(y/BS) - block_pos_offset_removed = by - offset - boy = block_pos_offset_removed % CS - if not blocks[bx][by] then blocks[bx][by]={} end - local total_mapgen_block_writes_through_y = (boy > 0 and boy < LAST_BLOCK) and math_floor(total_mapgen_block_writes_through_x / 2) or total_mapgen_block_writes_through_x - while z < z2 do - bz = math_floor(z/BS) - block_pos_offset_removed = bz - offset - boz = block_pos_offset_removed % CS - local total_mapgen_block_writes = (boz > 0 and boz < LAST_BLOCK) and math_floor(total_mapgen_block_writes_through_y / 2) or total_mapgen_block_writes_through_y - local current_mapgen_block_writes = blocks[bx][by][bz] and (blocks[bx][by][bz] + 1) or 1 - if current_mapgen_block_writes == total_mapgen_block_writes then - -- this block shouldn't be overwritten anymore, no need to keep it in memory - blocks[bx][by][bz] = nil - vm_context.seed = blockseed + box * 7 + boy * 243 + boz * 11931 - if lvm_block > 0 then - vm_context.minp, vm_content.maxp = {x=x, y=y, z=z}, {x=x+LAST_NODE, y=y+LAST_NODE, z=z+LAST_NODE} - for _, v in pairs(lvm_block_queue) do - vm_context = v.f(vm_context) - end - end - if nodes_block > 0 then - current_blocks[#current_blocks+1] = { minp = {x=x, y=y, z=z}, maxp = {x=pos.x+LAST_NODE, y=pos.y+LAST_NODE, z=pos.z+LAST_NODE}, seed = seed } - end - else - blocks[bx][by][bz] = current_mapgen_block_writes - end - z = z + BS - end - if next(blocks[bx][by]) == nil then blocks[bx][by] = nil end - z = z1 - y = y + BS - end - if next(blocks[bx]) == nil then blocks[bx] = nil end - y = y1 - x = x + BS - end - end - - if vm_context.write then - vm:set_data(data) - end - if vm_context.write_param2 then - vm:set_param2_data(data2) - end - vm:calc_lighting(p1, p2, shadow) - vm:write_to_map() - vm:update_liquids() - - for _, v in pairs(node_chunk_queue) do - v.f(minp, maxp, blockseed) - end - - for i, b in pairs(current_blocks) do - for _, v in pairs(node_block_queue) do - v.f(b.minp, b.maxp, b.seed) - end - current_blocks[id] = nil - end -end) - -minetest.register_on_generated = mcl_mapgen.register_chunk_generator - -function mcl_mapgen.get_far_node(p) - local p = p - local node = minetest_get_node(p) - if node.name ~= "ignore" then return node end - minetest_get_voxel_manip():read_from_map(p, p) - return minetest_get_node(p) -end - --- Calculate mapgen_edge_min/mapgen_edge_max -local function calculate_mapgen_basics() - mcl_mapgen.CS = math.max(1, tonumber(minetest.get_mapgen_setting("chunksize")) or 5) - mcl_mapgen.BS = math.max(1, core.MAP_BLOCKSIZE or 16) - mcl_mapgen.LIMIT = math.max(1, tonumber(minetest.get_mapgen_setting("mapgen_limit")) or 31000) - mcl_mapgen.MAX_LIMIT = math.max(1, core.MAX_MAP_GENERATION_LIMIT or 31000) - mcl_mapgen.OFFSET = - math.floor(mcl_mapgen.CS / 2) - mcl_mapgen.OFFSET_NODES = mcl_mapgen.OFFSET * mcl_mapgen.BS - mcl_mapgen.CS_NODES = mcl_mapgen.CS * mcl_mapgen.BS - - local central_chunk_min_pos = mcl_mapgen.OFFSET * mcl_mapgen.BS - local central_chunk_max_pos = central_chunk_min_pos + mcl_mapgen.CS_NODES - 1 - - local ccfmin = central_chunk_min_pos - mcl_mapgen.BS -- Fullminp/fullmaxp of central chunk, in nodes - local ccfmax = central_chunk_max_pos + mcl_mapgen.BS - - local mapgen_limit_b = math.floor(math.min(mcl_mapgen.LIMIT, mcl_mapgen.MAX_LIMIT) / mcl_mapgen.BS) - local mapgen_limit_min = - mapgen_limit_b * mcl_mapgen.BS - local mapgen_limit_max = (mapgen_limit_b + 1) * mcl_mapgen.BS - 1 - - local numcmin = math.max(math.floor((ccfmin - mapgen_limit_min) / mcl_vars.chunk_size_in_nodes), 0) -- Number of complete chunks from central chunk - local numcmax = math.max(math.floor((mapgen_limit_max - ccfmax) / mcl_vars.chunk_size_in_nodes), 0) -- fullminp/fullmaxp to effective mapgen limits. - - mcl_mapgen.EDGE_MIN = central_chunk_min_pos - numcmin * mcl_mapgen.CS_NODES - mcl_mapgen.EDGE_MAX = central_chunk_max_pos + numcmax * mcl_mapgen.CS_NODES -end - -local function coordinate_to_block(x) - return math_floor(x / mcl_mapgen.BS) -end - -local function coordinate_to_chunk(x) - return math_floor((coordinate_to_block(x) - central_chunk_offset) / mcl_vars.chunksize) -end - -function mcl_mapgen.pos_to_block(pos) - return { - x = coordinate_to_block(pos.x), - y = coordinate_to_block(pos.y), - z = coordinate_to_block(pos.z) - } -end - -function mcl_mapgen.pos_to_chunk(pos) - return { - x = coordinate_to_chunk(pos.x), - y = coordinate_to_chunk(pos.y), - z = coordinate_to_chunk(pos.z) - } -end - -calculate_mapgen_basics() - -local k_positive = math.ceil(mcl_mapgen.MAX_LIMIT / mcl_vars.chunk_size_in_nodes) -local k_positive_z = k_positive * 2 -local k_positive_y = k_positive_z * k_positive_z - -function mcl_mapgen.get_chunk_number(pos) -- unsigned int - local c = mcl_mapgen.pos_to_chunk(pos) - return - (c.y + k_positive) * k_positive_y + - (c.z + k_positive) * k_positive_z + - c.x + k_positive -end - +mcl_mapgen = {} + + +-- Calculate mapgen_edge_min/mapgen_edge_max +mcl_mapgen.CS = math.max(1, tonumber(minetest.get_mapgen_setting("chunksize")) or 5) +mcl_mapgen.BS = math.max(1, core.MAP_BLOCKSIZE or 16) +mcl_mapgen.LIMIT = math.max(1, tonumber(minetest.get_mapgen_setting("mapgen_limit")) or 31000) +mcl_mapgen.MAX_LIMIT = math.max(1, core.MAX_MAP_GENERATION_LIMIT or 31000) +mcl_mapgen.OFFSET = - math.floor(mcl_mapgen.CS / 2) +mcl_mapgen.OFFSET_NODES = mcl_mapgen.OFFSET * mcl_mapgen.BS +mcl_mapgen.CS_NODES = mcl_mapgen.CS * mcl_mapgen.BS + +local central_chunk_min_pos = mcl_mapgen.OFFSET * mcl_mapgen.BS +local central_chunk_max_pos = central_chunk_min_pos + mcl_mapgen.CS_NODES - 1 + +local ccfmin = central_chunk_min_pos - mcl_mapgen.BS -- Fullminp/fullmaxp of central chunk, in nodes +local ccfmax = central_chunk_max_pos + mcl_mapgen.BS + +local mapgen_limit_b = math.floor(math.min(mcl_mapgen.LIMIT, mcl_mapgen.MAX_LIMIT) / mcl_mapgen.BS) +local mapgen_limit_min = - mapgen_limit_b * mcl_mapgen.BS +local mapgen_limit_max = (mapgen_limit_b + 1) * mcl_mapgen.BS - 1 + +local numcmin = math.max(math.floor((ccfmin - mapgen_limit_min) / mcl_vars.chunk_size_in_nodes), 0) -- Number of complete chunks from central chunk +local numcmax = math.max(math.floor((mapgen_limit_max - ccfmax) / mcl_vars.chunk_size_in_nodes), 0) -- fullminp/fullmaxp to effective mapgen limits. + +mcl_mapgen.EDGE_MIN = central_chunk_min_pos - numcmin * mcl_mapgen.CS_NODES +mcl_mapgen.EDGE_MAX = central_chunk_max_pos + numcmax * mcl_mapgen.CS_NODES +------------------------------------------ + + +local lvm_block_queue, lvm_chunk_queue, node_block_queue, node_chunk_queue = {}, {}, {}, {} -- Generators' queues +local lvm, block, lvm_block, lvm_chunk, param2, nodes_block, nodes_chunk = 0, 0, 0, 0, 0, 0, 0 -- Requirements: 0 means none; greater than 0 means 'required' +local lvm_buffer, lvm_param2_buffer = {}, {} -- Static buffer pointers +local BS, CS = mcl_mapgen.BS, mcl_mapgen.CS -- Mapblock size (in nodes), Mapchunk size (in blocks) +local LAST_BLOCK, LAST_NODE = CS - 1, BS - 1 -- First mapblock in chunk (node in mapblock) has number 0, last has THIS number. It's for runtime optimization +local offset = math.floor(mcl_vars.central_chunk_offset_in_nodes / BS) -- Central mapchunk offset (in blocks) + +local DEFAULT_PRIORITY = 5000 + +local minetest_log, math_floor = minetest.log, math.floor + +function mcl_mapgen.register_chunk_generator(callback_function, priority) + nodes_chunk = nodes_chunk + 1 + node_chunk_queue[nodes_chunk] = {i = priority or DEFAULT_PRIORITY, f = callback_function} + table.sort(node_chunk_queue, function(a, b) return (a.i <= b.i) end) +end +function mcl_mapgen.register_chunk_generator_lvm(callback_function, priority) + lvm = lvm + 1 + lvm_chunk_queue[lvm_chunk] = {i = priority or DEFAULT_PRIORITY, f = callback_function} + table.sort(lvm_chunk_queue, function(a, b) return (a.i <= b.i) end) +end +function mcl_mapgen.register_block_generator(callback_function, priority) + block = block + 1 + nodes_block = nodes_block + 1 + node_block_queue[nodes_block] = {i = priority or DEFAULT_PRIORITY, f = callback_function} + table.sort(node_block_queue, function(a, b) return (a.i <= b.i) end) +end +function mcl_mapgen.register_block_generator_lvm(callback_function, priority) + block = block + 1 + lvm = lvm + 1 + lvm_block = lvm_block + 1 + lvm_block_queue[lvm_block] = {i = priority or DEFAULT_PRIORITY, f = callback_function} + table.sort(lvm_block_queue, function(a, b) return (a.i <= b.i) end) +end + +local storage = minetest.get_mod_storage() +local blocks = minetest.deserialize( storage:get_string("mapgen_blocks") or "return {}") or {} +minetest.register_on_shutdown(function() storage:set_string("mapgen_blocks", minetest.serialize(blocks)) end) + +local vm_context-- here will be many references and flags, like: param2, light_data, heightmap, biomemap, heatmap, humiditymap, gennotify, write_lvm, write_param2, shadow +local data, data2, area +local current_blocks = {} + +minetest.register_on_generated(function(minp, maxp, blockseed) + local minp, maxp, blockseed = minp, maxp, blockseed + minetest_log("verbose", "[mcl_mapgen] New chunk: minp=" .. minetest.pos_to_string(minp) .. ", maxp=" .. minetest.pos_to_string(maxp) .. ", blockseed=" .. blockseed) + + local vm, emin, emax = minetest.get_mapgen_object("voxelmanip") + + if lvm > 0 then + vm_context = {lvm_param2_buffer = lvm_param2_buffer, vm = vm, emin = emin, emax = emax, minp = minp, maxp = maxp, blockseed = blockseed} + data = vm:get_data(lvm_buffer) + vm_context.data = data + area = VoxelArea:new({MinEdge=emin, MaxEdge=emax}) + vm_context.area = area + for _, v in pairs(lvm_chunk_queue) do + vm_context = v.f(vm_context) + end + end + + if block > 0 then + local x0, y0, z0 = minp.x, minp.y, minp.z + local bx0, by0, bz0 = math_floor(x0/BS), math_floor(y0/BS), math_floor(z0/BS) + local x1, y1, z1, x2, y2, z2 = emin.x, emin.y, emin.z, emax.x, emax.y, emax.z + local x, y, z = x1, y1, z1 -- iterate 7x7x7 mapchunk, {x,y,z} - first node pos. of mapblock + local bx, by, bz -- block coords (in blocs) + local box, boy, boz -- block offsets in chunks (in blocks) + while x < x2 do + bx = math_floor(x/BS) + local block_pos_offset_removed = bx - offset + box = block_pos_offset_removed % CS + if not blocks[bx] then blocks[bx]={} end + local total_mapgen_block_writes_through_x = (box > 0 and box < LAST_BLOCK) and 4 or 8 + while y < y2 do + by = math_floor(y/BS) + block_pos_offset_removed = by - offset + boy = block_pos_offset_removed % CS + if not blocks[bx][by] then blocks[bx][by]={} end + local total_mapgen_block_writes_through_y = (boy > 0 and boy < LAST_BLOCK) and math_floor(total_mapgen_block_writes_through_x / 2) or total_mapgen_block_writes_through_x + while z < z2 do + bz = math_floor(z/BS) + block_pos_offset_removed = bz - offset + boz = block_pos_offset_removed % CS + local total_mapgen_block_writes = (boz > 0 and boz < LAST_BLOCK) and math_floor(total_mapgen_block_writes_through_y / 2) or total_mapgen_block_writes_through_y + local current_mapgen_block_writes = blocks[bx][by][bz] and (blocks[bx][by][bz] + 1) or 1 + if current_mapgen_block_writes == total_mapgen_block_writes then + -- this block shouldn't be overwritten anymore, no need to keep it in memory + blocks[bx][by][bz] = nil + vm_context.seed = blockseed + box * 7 + boy * 243 + boz * 11931 + if lvm_block > 0 then + vm_context.minp, vm_content.maxp = {x=x, y=y, z=z}, {x=x+LAST_NODE, y=y+LAST_NODE, z=z+LAST_NODE} + for _, v in pairs(lvm_block_queue) do + vm_context = v.f(vm_context) + end + end + if nodes_block > 0 then + current_blocks[#current_blocks+1] = { minp = {x=x, y=y, z=z}, maxp = {x=pos.x+LAST_NODE, y=pos.y+LAST_NODE, z=pos.z+LAST_NODE}, seed = seed } + end + else + blocks[bx][by][bz] = current_mapgen_block_writes + end + z = z + BS + end + if next(blocks[bx][by]) == nil then blocks[bx][by] = nil end + z = z1 + y = y + BS + end + if next(blocks[bx]) == nil then blocks[bx] = nil end + y = y1 + x = x + BS + end + end + + if vm_context.write then + vm:set_data(data) + end + if vm_context.write_param2 then + vm:set_param2_data(data2) + end + vm:calc_lighting(p1, p2, shadow) + vm:write_to_map() + vm:update_liquids() + + for _, v in pairs(node_chunk_queue) do + v.f(minp, maxp, blockseed) + end + + for i, b in pairs(current_blocks) do + for _, v in pairs(node_block_queue) do + v.f(b.minp, b.maxp, b.seed) + end + current_blocks[id] = nil + end +end) + +minetest.register_on_generated = mcl_mapgen.register_chunk_generator + +function mcl_mapgen.get_far_node(p) + local p = p + local node = minetest_get_node(p) + if node.name ~= "ignore" then return node end + minetest_get_voxel_manip():read_from_map(p, p) + return minetest_get_node(p) +end + +local function coordinate_to_block(x) + return math_floor(x / mcl_mapgen.BS) +end + +local function coordinate_to_chunk(x) + return math_floor((coordinate_to_block(x) - central_chunk_offset) / mcl_mapgen.CS) +end + +function mcl_mapgen.pos_to_block(pos) + return { + x = coordinate_to_block(pos.x), + y = coordinate_to_block(pos.y), + z = coordinate_to_block(pos.z) + } +end + +function mcl_mapgen.pos_to_chunk(pos) + return { + x = coordinate_to_chunk(pos.x), + y = coordinate_to_chunk(pos.y), + z = coordinate_to_chunk(pos.z) + } +end + +local k_positive = math.ceil(mcl_mapgen.MAX_LIMIT / mcl_vars.chunk_size_in_nodes) +local k_positive_z = k_positive * 2 +local k_positive_y = k_positive_z * k_positive_z + +function mcl_mapgen.get_chunk_number(pos) -- unsigned int + local c = mcl_mapgen.pos_to_chunk(pos) + return + (c.y + k_positive) * k_positive_y + + (c.z + k_positive) * k_positive_z + + c.x + k_positive +end + + + + + +-- Mapgen variables +local mg_name = minetest.get_mapgen_setting("mg_name") +local minecraft_height_limit = 256 +local superflat = mg_name == "flat" and minetest.get_mapgen_setting("mcl_superflat_classic") == "true" +local singlenode = mg_name == "singlenode" + +if not superflat and not singlenode then + -- Normal mode + --[[ Realm stacking (h is for height) + - Overworld (h>=256) + - Void (h>=1000) + - Realm Barrier (h=11), to allow escaping the End + - End (h>=256) + - Void (h>=1000) + - Nether (h=128) + - Void (h>=1000) + ]] + + -- Overworld + mcl_vars.mg_overworld_min = -62 + mcl_vars.mg_overworld_max_official = mcl_vars.mg_overworld_min + minecraft_height_limit + mcl_vars.mg_bedrock_overworld_min = mcl_vars.mg_overworld_min + mcl_vars.mg_bedrock_overworld_max = mcl_vars.mg_bedrock_overworld_min + 4 + mcl_vars.mg_lava_overworld_max = mcl_vars.mg_overworld_min + 10 + mcl_vars.mg_lava = true + mcl_vars.mg_bedrock_is_rough = true + +elseif singlenode then + mcl_vars.mg_overworld_min = -66 + mcl_vars.mg_overworld_max_official = mcl_vars.mg_overworld_min + minecraft_height_limit + mcl_vars.mg_bedrock_overworld_min = mcl_vars.mg_overworld_min + mcl_vars.mg_bedrock_overworld_max = mcl_vars.mg_bedrock_overworld_min + mcl_vars.mg_lava = false + mcl_vars.mg_lava_overworld_max = mcl_vars.mg_overworld_min + mcl_vars.mg_bedrock_is_rough = false +else + -- Classic superflat + local ground = minetest.get_mapgen_setting("mgflat_ground_level") + ground = tonumber(ground) + if not ground then + ground = 8 + end + mcl_vars.mg_overworld_min = ground - 3 + mcl_vars.mg_overworld_max_official = mcl_vars.mg_overworld_min + minecraft_height_limit + mcl_vars.mg_bedrock_overworld_min = mcl_vars.mg_overworld_min + mcl_vars.mg_bedrock_overworld_max = mcl_vars.mg_bedrock_overworld_min + mcl_vars.mg_lava = false + mcl_vars.mg_lava_overworld_max = mcl_vars.mg_overworld_min + mcl_vars.mg_bedrock_is_rough = false +end + +mcl_vars.mg_overworld_max = mcl_mapgen.EDGE_MAX + +-- The Nether (around Y = -29000) +mcl_vars.mg_nether_min = -29067 -- Carefully chosen to be at a mapchunk border +mcl_vars.mg_nether_max = mcl_vars.mg_nether_min + 128 +mcl_vars.mg_bedrock_nether_bottom_min = mcl_vars.mg_nether_min +mcl_vars.mg_bedrock_nether_top_max = mcl_vars.mg_nether_max +if not superflat then + mcl_vars.mg_bedrock_nether_bottom_max = mcl_vars.mg_bedrock_nether_bottom_min + 4 + mcl_vars.mg_bedrock_nether_top_min = mcl_vars.mg_bedrock_nether_top_max - 4 + mcl_vars.mg_lava_nether_max = mcl_vars.mg_nether_min + 31 +else + -- Thin bedrock in classic superflat mapgen + mcl_vars.mg_bedrock_nether_bottom_max = mcl_vars.mg_bedrock_nether_bottom_min + mcl_vars.mg_bedrock_nether_top_min = mcl_vars.mg_bedrock_nether_top_max + mcl_vars.mg_lava_nether_max = mcl_vars.mg_nether_min + 2 +end +if mg_name == "flat" then + if superflat then + mcl_vars.mg_flat_nether_floor = mcl_vars.mg_bedrock_nether_bottom_max + 4 + mcl_vars.mg_flat_nether_ceiling = mcl_vars.mg_bedrock_nether_bottom_max + 52 + else + mcl_vars.mg_flat_nether_floor = mcl_vars.mg_lava_nether_max + 4 + mcl_vars.mg_flat_nether_ceiling = mcl_vars.mg_lava_nether_max + 52 + end +end + +-- The End (surface at ca. Y = -27000) +mcl_vars.mg_end_min = -27073 -- Carefully chosen to be at a mapchunk border +mcl_vars.mg_end_max_official = mcl_vars.mg_end_min + minecraft_height_limit +mcl_vars.mg_end_max = mcl_vars.mg_overworld_min - 2000 +mcl_vars.mg_end_platform_pos = { x = 100, y = mcl_vars.mg_end_min + 74, z = 0 } + +-- Realm barrier used to safely separate the End from the void below the Overworld +mcl_vars.mg_realm_barrier_overworld_end_max = mcl_vars.mg_end_max +mcl_vars.mg_realm_barrier_overworld_end_min = mcl_vars.mg_end_max - 11 + +-- Use MineClone 2-style dungeons +mcl_vars.mg_dungeons = true diff --git a/mods/ENTITIES/mcl_mobs/api.lua b/mods/ENTITIES/mcl_mobs/api.lua index 3f635ece0..16ab55a28 100644 --- a/mods/ENTITIES/mcl_mobs/api.lua +++ b/mods/ENTITIES/mcl_mobs/api.lua @@ -919,19 +919,8 @@ end -- check if within physical map limits (-30911 to 30927) -local within_limits, wmin, wmax = nil, -30913, 30928 -within_limits = function(pos, radius) - if mcl_vars then - if mcl_vars.mapgen_edge_min and mcl_vars.mapgen_edge_max then - wmin, wmax = mcl_vars.mapgen_edge_min, mcl_vars.mapgen_edge_max - within_limits = function(pos, radius) - return pos - and (pos.x - radius) > wmin and (pos.x + radius) < wmax - and (pos.y - radius) > wmin and (pos.y + radius) < wmax - and (pos.z - radius) > wmin and (pos.z + radius) < wmax - end - end - end +local wmin, wmax = mcl_mapgen.EDGE_MIN, mcl_mapgen.EDGE_MAX +local function within_limits(pos, radius) return pos and (pos.x - radius) > wmin and (pos.x + radius) < wmax and (pos.y - radius) > wmin and (pos.y + radius) < wmax diff --git a/mods/ENTITIES/mcl_mobs/mod.conf b/mods/ENTITIES/mcl_mobs/mod.conf index 0d622f6a9..d6089dac6 100644 --- a/mods/ENTITIES/mcl_mobs/mod.conf +++ b/mods/ENTITIES/mcl_mobs/mod.conf @@ -1,5 +1,5 @@ name = mcl_mobs author = PilzAdam description = Adds a mob API for mods to add animals or monsters, etc. -depends = mcl_particles +depends = mcl_mapgen, mcl_particles optional_depends = mcl_weather, mcl_explosions, mcl_hunger, mcl_worlds, invisibility, lucky_block, cmi, doc_identifier, mcl_armor, mcl_portals, mcl_experience diff --git a/mods/ITEMS/mcl_portals/mod.conf b/mods/ITEMS/mcl_portals/mod.conf index d99344a76..e2ebc0385 100644 --- a/mods/ITEMS/mcl_portals/mod.conf +++ b/mods/ITEMS/mcl_portals/mod.conf @@ -1,4 +1,4 @@ name = mcl_portals description = Adds buildable portals to the Nether and End dimensions. -depends = mcl_nether, mcl_end, mcl_particles, mcl_spawn +depends = mcl_mapgen, mcl_nether, mcl_end, mcl_particles, mcl_spawn optional_depends = awards, doc diff --git a/mods/ITEMS/mcl_portals/portal_nether.lua b/mods/ITEMS/mcl_portals/portal_nether.lua index a121f719c..7fd0191fa 100644 --- a/mods/ITEMS/mcl_portals/portal_nether.lua +++ b/mods/ITEMS/mcl_portals/portal_nether.lua @@ -19,7 +19,7 @@ local W_MIN, W_MAX = 4, 23 local H_MIN, H_MAX = 5, 23 local N_MIN, N_MAX = 6, (W_MAX-2) * (H_MAX-2) local TRAVEL_X, TRAVEL_Y, TRAVEL_Z = 8, 1, 8 -local LIM_MIN, LIM_MAX = mcl_vars.mapgen_edge_min, mcl_vars.mapgen_edge_max +local LIM_MIN, LIM_MAX = mcl_mapgen.EDGE_MIN, mcl_mapgen.EDGE_MAX local PLAYER_COOLOFF, MOB_COOLOFF = 3, 14 -- for this many seconds they won't teleported again local TOUCH_CHATTER_TIME = 1 -- prevent multiple teleportation attempts caused by multiple portal touches, for this number of seconds local CHATTER_US = TOUCH_CHATTER_TIME * 1000000 @@ -522,8 +522,8 @@ local function create_portal(pos, limit1, limit2, name, obj) -- so we'll emerge single chunk only: 5x5x5 blocks, 80x80x80 nodes maximum -- and maybe one more chunk from below if (SCAN_2_MAP_CHUNKS = true) - local pos1 = add(mul(mcl_vars.pos_to_chunk(pos), mcl_vars.chunk_size_in_nodes), mcl_vars.central_chunk_offset_in_nodes) - local pos2 = add(pos1, mcl_vars.chunk_size_in_nodes - 1) + local pos1 = add(mul(mcl_mapgen.pos_to_chunk(pos), mcl_mapgen.CS_NODES), mcl_mapgen.OFFSET_NODES) + local pos2 = add(pos1, mcl_mapgen.CS_NODES - 1) if not SCAN_2_MAP_CHUNKS then if limit1 and limit1.x and limit1.y and limit1.z then diff --git a/mods/MAPGEN/mcl_dungeons/init.lua b/mods/MAPGEN/mcl_dungeons/init.lua index 63433d08d..40af11d37 100644 --- a/mods/MAPGEN/mcl_dungeons/init.lua +++ b/mods/MAPGEN/mcl_dungeons/init.lua @@ -40,7 +40,7 @@ local max_y = mcl_vars.mg_overworld_max - 1 -- Calculate the number of dungeon spawn attempts -- In Minecraft, there 8 dungeon spawn attempts Minecraft chunk (16*256*16 = 65536 blocks). -- Minetest chunks don't have this size, so scale the number accordingly. -local attempts = math_ceil(((mcl_vars.chunksize * mcl_vars.MAP_BLOCKSIZE) ^ 3) / 8192) -- 63 = 80*80*80/8192 +local attempts = math_ceil((mcl_mapgen.CS_NODES ^ 3) / 8192) -- 63 = 80*80*80/8192 local dungeonsizes = { { x=5, y=4, z=5}, diff --git a/mods/MAPGEN/mcl_dungeons/mod.conf b/mods/MAPGEN/mcl_dungeons/mod.conf index fe02286fa..e7a7d921c 100644 --- a/mods/MAPGEN/mcl_dungeons/mod.conf +++ b/mods/MAPGEN/mcl_dungeons/mod.conf @@ -1,4 +1,4 @@ name = mcl_dungeons author = Wuzzy description = Generates random dungeons in the world -depends = mcl_init, mcl_core, mcl_chests, mcl_mobs, mcl_mobspawners, mcl_mapgen_core, mobs_mc +depends = mcl_mapgen, mcl_core, mcl_chests, mcl_mobs, mcl_mobspawners, mcl_mapgen_core, mobs_mc diff --git a/mods/MAPGEN/mcl_mapgen_core/init.lua b/mods/MAPGEN/mcl_mapgen_core/init.lua index 031a568f7..b14e1c2c7 100644 --- a/mods/MAPGEN/mcl_mapgen_core/init.lua +++ b/mods/MAPGEN/mcl_mapgen_core/init.lua @@ -1899,7 +1899,7 @@ local function basic(c) local pr = PseudoRandom(blockseed) -- The Void below the Nether: - lvm_used = set_layers(data, area, c_void , nil, mcl_vars.mapgen_edge_min , mcl_vars.mg_nether_min -1, minp, maxp, lvm_used, pr) + lvm_used = set_layers(data, area, c_void , nil, mcl_mapgen.EDGE_MIN , mcl_vars.mg_nether_min -1, minp, maxp, lvm_used, pr) -- [[ THE NETHER: mcl_vars.mg_nether_min mcl_vars.mg_nether_max ]] diff --git a/mods/PLAYER/mcl_spawn/init.lua b/mods/PLAYER/mcl_spawn/init.lua index b8c746d1f..34105c094 100644 --- a/mods/PLAYER/mcl_spawn/init.lua +++ b/mods/PLAYER/mcl_spawn/init.lua @@ -81,7 +81,7 @@ local dir_step = storage:get_int("mcl_spawn_dir_step") or 0 local dir_ind = storage:get_int("mcl_spawn_dir_ind") or 1 local emerge_pos1, emerge_pos2 -local spawn_limit = mcl_vars.mapgen_edge_max +local spawn_limit = mcl_mapgen.EDGE_MAX --Functions diff --git a/mods/PLAYER/mcl_spawn/mod.conf b/mods/PLAYER/mcl_spawn/mod.conf index 954f831db..2c7953fe7 100644 --- a/mods/PLAYER/mcl_spawn/mod.conf +++ b/mods/PLAYER/mcl_spawn/mod.conf @@ -1,4 +1,4 @@ name = mcl_spawn author = Wuzzy description = Set and get the player's respawn position -depends = mcl_init +depends = mcl_mapgen From c23bb1d59dbcba9a1d1ba678591f1cdd4e620ccd Mon Sep 17 00:00:00 2001 From: kay27 Date: Wed, 28 Apr 2021 03:03:47 +0400 Subject: [PATCH 07/21] [mapgen] rebalance mapgen/init core code --- mods/CORE/mcl_mapgen/init.lua | 166 ++++++------ mods/CORE/mcl_worlds/init.lua | 32 +-- mods/ENTITIES/mobs_mc_gameconfig/init.lua | 12 +- mods/ITEMS/mcl_portals/portal_nether.lua | 16 +- mods/MAPGEN/mcl_biomes/init.lua | 306 +++++++++++----------- mods/MAPGEN/mcl_biomes/mod.conf | 2 +- mods/MAPGEN/mcl_dungeons/init.lua | 6 +- mods/MAPGEN/mcl_mapgen_core/init.lua | 88 +++---- mods/MAPGEN/mcl_structures/init.lua | 6 +- mods/MAPGEN/mcl_villages/buildings.lua | 4 +- mods/MAPGEN/mcl_villages/utils.lua | 2 +- mods/MAPGEN/tsm_railcorridors/init.lua | 2 +- 12 files changed, 316 insertions(+), 326 deletions(-) diff --git a/mods/CORE/mcl_mapgen/init.lua b/mods/CORE/mcl_mapgen/init.lua index f5c6a16f9..74461a5fa 100644 --- a/mods/CORE/mcl_mapgen/init.lua +++ b/mods/CORE/mcl_mapgen/init.lua @@ -1,12 +1,17 @@ mcl_mapgen = {} +mcl_mapgen.overworld = {} +mcl_mapgen.nether = {} +mcl_mapgen.end = {} +local minetest_log, math_floor = minetest.log, math.floor +local minetest_get_node = minetest.get_node -- Calculate mapgen_edge_min/mapgen_edge_max mcl_mapgen.CS = math.max(1, tonumber(minetest.get_mapgen_setting("chunksize")) or 5) mcl_mapgen.BS = math.max(1, core.MAP_BLOCKSIZE or 16) mcl_mapgen.LIMIT = math.max(1, tonumber(minetest.get_mapgen_setting("mapgen_limit")) or 31000) mcl_mapgen.MAX_LIMIT = math.max(1, core.MAX_MAP_GENERATION_LIMIT or 31000) -mcl_mapgen.OFFSET = - math.floor(mcl_mapgen.CS / 2) +mcl_mapgen.OFFSET = - math_floor(mcl_mapgen.CS / 2) mcl_mapgen.OFFSET_NODES = mcl_mapgen.OFFSET * mcl_mapgen.BS mcl_mapgen.CS_NODES = mcl_mapgen.CS * mcl_mapgen.BS @@ -16,15 +21,17 @@ local central_chunk_max_pos = central_chunk_min_pos + mcl_mapgen.CS_NODES - 1 local ccfmin = central_chunk_min_pos - mcl_mapgen.BS -- Fullminp/fullmaxp of central chunk, in nodes local ccfmax = central_chunk_max_pos + mcl_mapgen.BS -local mapgen_limit_b = math.floor(math.min(mcl_mapgen.LIMIT, mcl_mapgen.MAX_LIMIT) / mcl_mapgen.BS) +local mapgen_limit_b = math_floor(math.min(mcl_mapgen.LIMIT, mcl_mapgen.MAX_LIMIT) / mcl_mapgen.BS) local mapgen_limit_min = - mapgen_limit_b * mcl_mapgen.BS local mapgen_limit_max = (mapgen_limit_b + 1) * mcl_mapgen.BS - 1 -local numcmin = math.max(math.floor((ccfmin - mapgen_limit_min) / mcl_vars.chunk_size_in_nodes), 0) -- Number of complete chunks from central chunk -local numcmax = math.max(math.floor((mapgen_limit_max - ccfmax) / mcl_vars.chunk_size_in_nodes), 0) -- fullminp/fullmaxp to effective mapgen limits. +local numcmin = math.max(math_floor((ccfmin - mapgen_limit_min) / mcl_mapgen.CS_NODES), 0) -- Number of complete chunks from central chunk +local numcmax = math.max(math_floor((mapgen_limit_max - ccfmax) / mcl_mapgen.CS_NODES), 0) -- fullminp/fullmaxp to effective mapgen limits. mcl_mapgen.EDGE_MIN = central_chunk_min_pos - numcmin * mcl_mapgen.CS_NODES mcl_mapgen.EDGE_MAX = central_chunk_max_pos + numcmax * mcl_mapgen.CS_NODES + +minetest_log("action", "[mcl_mapgen] World edges are: mcl_mapgen.EDGE_MIN = " .. tostring(mcl_mapgen.EDGE_MIN) .. ", mcl_mapgen.EDGE_MAX = " .. tostring(mcl_mapgen.EDGE_MAX)) ------------------------------------------ @@ -33,12 +40,10 @@ local lvm, block, lvm_block, lvm_chunk, param2, nodes_block, nodes_chunk = 0, 0, local lvm_buffer, lvm_param2_buffer = {}, {} -- Static buffer pointers local BS, CS = mcl_mapgen.BS, mcl_mapgen.CS -- Mapblock size (in nodes), Mapchunk size (in blocks) local LAST_BLOCK, LAST_NODE = CS - 1, BS - 1 -- First mapblock in chunk (node in mapblock) has number 0, last has THIS number. It's for runtime optimization -local offset = math.floor(mcl_vars.central_chunk_offset_in_nodes / BS) -- Central mapchunk offset (in blocks) +local offset = mcl_mapgen.OFFSET -- Central mapchunk offset (in blocks) local DEFAULT_PRIORITY = 5000 -local minetest_log, math_floor = minetest.log, math.floor - function mcl_mapgen.register_chunk_generator(callback_function, priority) nodes_chunk = nodes_chunk + 1 node_chunk_queue[nodes_chunk] = {i = priority or DEFAULT_PRIORITY, f = callback_function} @@ -141,15 +146,17 @@ minetest.register_on_generated(function(minp, maxp, blockseed) end end - if vm_context.write then - vm:set_data(data) + if lvm > 0 then + if vm_context.write then + vm:set_data(data) + end + if vm_context.write_param2 then + vm:set_param2_data(data2) + end + vm:calc_lighting(minp, maxp, vm_context.shadow) -- TODO: check boundaries + vm:write_to_map() + vm:update_liquids() end - if vm_context.write_param2 then - vm:set_param2_data(data2) - end - vm:calc_lighting(p1, p2, shadow) - vm:write_to_map() - vm:update_liquids() for _, v in pairs(node_chunk_queue) do v.f(minp, maxp, blockseed) @@ -174,11 +181,11 @@ function mcl_mapgen.get_far_node(p) end local function coordinate_to_block(x) - return math_floor(x / mcl_mapgen.BS) + return math_floor(x / BS) end local function coordinate_to_chunk(x) - return math_floor((coordinate_to_block(x) - central_chunk_offset) / mcl_mapgen.CS) + return math_floor((coordinate_to_block(x) - offset) / CS) end function mcl_mapgen.pos_to_block(pos) @@ -197,7 +204,7 @@ function mcl_mapgen.pos_to_chunk(pos) } end -local k_positive = math.ceil(mcl_mapgen.MAX_LIMIT / mcl_vars.chunk_size_in_nodes) +local k_positive = math.ceil(mcl_mapgen.MAX_LIMIT / mcl_mapgen.CS_NODES) local k_positive_z = k_positive * 2 local k_positive_y = k_positive_z * k_positive_z @@ -210,96 +217,79 @@ function mcl_mapgen.get_chunk_number(pos) -- unsigned int end - - - -- Mapgen variables -local mg_name = minetest.get_mapgen_setting("mg_name") -local minecraft_height_limit = 256 -local superflat = mg_name == "flat" and minetest.get_mapgen_setting("mcl_superflat_classic") == "true" -local singlenode = mg_name == "singlenode" +mcl_mapgen.name = minetest.get_mapgen_setting("mg_name") +mcl_mapgen.superflat = mcl_mapgen.name == "flat" and minetest.get_mapgen_setting("mcl_superflat_classic") == "true" +mcl_mapgen.singlenode = mcl_mapgen.name == "singlenode" +mcl_mapgen.normal = not mcl_mapgen.superflat and not mcl_mapgen.singlenode +local superflat, singlenode, normal = mcl_mapgen.superflat, mcl_mapgen.singlenode, mcl_mapgen.normal -if not superflat and not singlenode then - -- Normal mode - --[[ Realm stacking (h is for height) - - Overworld (h>=256) - - Void (h>=1000) - - Realm Barrier (h=11), to allow escaping the End - - End (h>=256) - - Void (h>=1000) - - Nether (h=128) - - Void (h>=1000) - ]] +minetest_log("action", "[mcl_mapgen] Mapgen mode: " .. normal and "normal" or (superflat and "superflat" or "singlenode")) - -- Overworld - mcl_vars.mg_overworld_min = -62 - mcl_vars.mg_overworld_max_official = mcl_vars.mg_overworld_min + minecraft_height_limit - mcl_vars.mg_bedrock_overworld_min = mcl_vars.mg_overworld_min - mcl_vars.mg_bedrock_overworld_max = mcl_vars.mg_bedrock_overworld_min + 4 - mcl_vars.mg_lava_overworld_max = mcl_vars.mg_overworld_min + 10 - mcl_vars.mg_lava = true - mcl_vars.mg_bedrock_is_rough = true +mcl_mapgen.minecraft_height_limit = 256 -elseif singlenode then - mcl_vars.mg_overworld_min = -66 - mcl_vars.mg_overworld_max_official = mcl_vars.mg_overworld_min + minecraft_height_limit - mcl_vars.mg_bedrock_overworld_min = mcl_vars.mg_overworld_min - mcl_vars.mg_bedrock_overworld_max = mcl_vars.mg_bedrock_overworld_min - mcl_vars.mg_lava = false - mcl_vars.mg_lava_overworld_max = mcl_vars.mg_overworld_min - mcl_vars.mg_bedrock_is_rough = false -else - -- Classic superflat - local ground = minetest.get_mapgen_setting("mgflat_ground_level") - ground = tonumber(ground) - if not ground then - ground = 8 - end - mcl_vars.mg_overworld_min = ground - 3 - mcl_vars.mg_overworld_max_official = mcl_vars.mg_overworld_min + minecraft_height_limit - mcl_vars.mg_bedrock_overworld_min = mcl_vars.mg_overworld_min - mcl_vars.mg_bedrock_overworld_max = mcl_vars.mg_bedrock_overworld_min - mcl_vars.mg_lava = false - mcl_vars.mg_lava_overworld_max = mcl_vars.mg_overworld_min - mcl_vars.mg_bedrock_is_rough = false +mcl_mapgen.bedrock_is_rough = normal + +--[[ Realm stacking (h is for height) +- Overworld (h>=256) +- Void (h>=1000) +- Realm Barrier (h=11), to allow escaping the End +- End (h>=256) +- Void (h>=1000) +- Nether (h=128) +- Void (h>=1000) +]] + +-- Overworld +mcl_mapgen.overworld.min = -62 +if superflat then + mcl_mapgen.ground = tonumber(minetest.get_mapgen_setting("mgflat_ground_level")) or 8 + mcl_mapgen.overworld.min = ground - 3 end +-- if singlenode then mcl_mapgen.overworld.min = -66 end -- DONT KNOW WHY +mcl_mapgen.overworld.max = mcl_mapgen.EDGE_MAX + +mcl_mapgen.overworld.bedrock_min = mcl_mapgen.overworld.min +mcl_mapgen.overworld.bedrock_max = mcl_mapgen.overworld.bedrock_min + (mcl_mapgen.bedrock_is_rough and 4 or 0) + +mcl_mapgen.lava = normal +mcl_mapgen.lava_overworld_max = mcl_mapgen.overworld.min + (normal and 10 or 0) -mcl_vars.mg_overworld_max = mcl_mapgen.EDGE_MAX -- The Nether (around Y = -29000) -mcl_vars.mg_nether_min = -29067 -- Carefully chosen to be at a mapchunk border -mcl_vars.mg_nether_max = mcl_vars.mg_nether_min + 128 -mcl_vars.mg_bedrock_nether_bottom_min = mcl_vars.mg_nether_min -mcl_vars.mg_bedrock_nether_top_max = mcl_vars.mg_nether_max +mcl_mapgen.nether.min = -29067 -- Carefully chosen to be at a mapchunk border +mcl_mapgen.nether.max = mcl_mapgen.nether.min + 128 +mcl_mapgen.nether.bedrock_bottom_min = mcl_mapgen.nether.min +mcl_mapgen.nether.bedrock_top_max = mcl_mapgen.nether.max if not superflat then - mcl_vars.mg_bedrock_nether_bottom_max = mcl_vars.mg_bedrock_nether_bottom_min + 4 - mcl_vars.mg_bedrock_nether_top_min = mcl_vars.mg_bedrock_nether_top_max - 4 - mcl_vars.mg_lava_nether_max = mcl_vars.mg_nether_min + 31 + mcl_mapgen.nether.bedrock_bottom_max = mcl_vars.mg_bedrock_nether_bottom_min + 4 + mcl_mapgen.nether.bedrock_top_min = mcl_vars.mg_bedrock_nether_top_max - 4 + mcl_mapgen.nether.lava_max = mcl_mapgen.nether.min + 31 else -- Thin bedrock in classic superflat mapgen - mcl_vars.mg_bedrock_nether_bottom_max = mcl_vars.mg_bedrock_nether_bottom_min - mcl_vars.mg_bedrock_nether_top_min = mcl_vars.mg_bedrock_nether_top_max - mcl_vars.mg_lava_nether_max = mcl_vars.mg_nether_min + 2 + mcl_mapgen.nether.bedrock_bottom_max = mcl_vars.mg_bedrock_nether_bottom_min + mcl_mapgen.nether.bedrock_top_min = mcl_vars.mg_bedrock_nether_top_max + mcl_mapgen.nether.lava_max = mcl_mapgen.nether.min + 2 end -if mg_name == "flat" then +if mcl_mapgen.name == "flat" then if superflat then - mcl_vars.mg_flat_nether_floor = mcl_vars.mg_bedrock_nether_bottom_max + 4 - mcl_vars.mg_flat_nether_ceiling = mcl_vars.mg_bedrock_nether_bottom_max + 52 + mcl_mapgen.nether.flat_nether_floor = mcl_mapgen.nether.bedrock_nether_bottom_max + 4 + mcl_mapgen.nether.flat_nether_ceiling = mcl_mapgen.nether.bedrock_nether_bottom_max + 52 else - mcl_vars.mg_flat_nether_floor = mcl_vars.mg_lava_nether_max + 4 - mcl_vars.mg_flat_nether_ceiling = mcl_vars.mg_lava_nether_max + 52 + mcl_mapgen.nether.flat_nether_floor = mcl_mapgen.nether.lava_nether_max + 4 + mcl_mapgen.nether.flat_nether_ceiling = mcl_mapgen.nether.lava_nether_max + 52 end end -- The End (surface at ca. Y = -27000) -mcl_vars.mg_end_min = -27073 -- Carefully chosen to be at a mapchunk border -mcl_vars.mg_end_max_official = mcl_vars.mg_end_min + minecraft_height_limit -mcl_vars.mg_end_max = mcl_vars.mg_overworld_min - 2000 -mcl_vars.mg_end_platform_pos = { x = 100, y = mcl_vars.mg_end_min + 74, z = 0 } +mcl_mapgen.end.min = -27073 -- Carefully chosen to be at a mapchunk border +mcl_mapgen.end.max_official = mcl_mapgen.end.min + mcl_mapgen.minecraft_height_limit +mcl_mapgen.end.max = mcl_mapgen.overworld.min - 2000 +mcl_vars.mg_end_platform_pos = { x = 100, y = mcl_mapgen.end.min + 74, z = 0 } -- Realm barrier used to safely separate the End from the void below the Overworld -mcl_vars.mg_realm_barrier_overworld_end_max = mcl_vars.mg_end_max -mcl_vars.mg_realm_barrier_overworld_end_min = mcl_vars.mg_end_max - 11 +mcl_vars.mg_realm_barrier_overworld_end_max = mcl_mapgen.end.max +mcl_vars.mg_realm_barrier_overworld_end_min = mcl_mapgen.end.max - 11 -- Use MineClone 2-style dungeons mcl_vars.mg_dungeons = true diff --git a/mods/CORE/mcl_worlds/init.lua b/mods/CORE/mcl_worlds/init.lua index 6cdeaab7e..a9d9ea050 100644 --- a/mods/CORE/mcl_worlds/init.lua +++ b/mods/CORE/mcl_worlds/init.lua @@ -3,25 +3,25 @@ mcl_worlds = {} -- For a given position, returns a 2-tuple: -- 1st return value: true if pos is in void -- 2nd return value: true if it is in the deadly part of the void +local min1, min2, min3 = mcl_mapgen.overworld.min, mcl_mapgen.end.min, mcl_mapgen.nether.min +local max1, max2, max3 = mcl_mapgen.overworld.max, mcl_mapgen.end.max, mcl_mapgen.nether.max+128 function mcl_worlds.is_in_void(pos) - local void = - not ((pos.y < mcl_vars.mg_overworld_max and pos.y > mcl_vars.mg_overworld_min) or - (pos.y < mcl_vars.mg_nether_max+128 and pos.y > mcl_vars.mg_nether_min) or - (pos.y < mcl_vars.mg_end_max and pos.y > mcl_vars.mg_end_min)) + local y = pos.y + local void = not ((y < max1 and y > min1) or (y < max2 and y > min2) or (y < max3 and y > min3)) local void_deadly = false local deadly_tolerance = 64 -- the player must be this many nodes “deep” into the void to be damaged if void then -- Overworld → Void → End → Void → Nether → Void - if pos.y < mcl_vars.mg_overworld_min and pos.y > mcl_vars.mg_end_max then - void_deadly = pos.y < mcl_vars.mg_overworld_min - deadly_tolerance - elseif pos.y < mcl_vars.mg_end_min and pos.y > mcl_vars.mg_nether_max+128 then + if y < mcl_vars.min1 and y > max2 then + void_deadly = y < min1 - deadly_tolerance + elseif y < min2 and y > max3 then -- The void between End and Nether. Like usual, but here, the void -- *above* the Nether also has a small tolerance area, so player -- can fly above the Nether without getting hurt instantly. - void_deadly = (pos.y < mcl_vars.mg_end_min - deadly_tolerance) and (pos.y > mcl_vars.mg_nether_max+128 + deadly_tolerance) - elseif pos.y < mcl_vars.mg_nether_min then - void_deadly = pos.y < mcl_vars.mg_nether_min - deadly_tolerance + void_deadly = (y < min2 - deadly_tolerance) and (y > max3 + deadly_tolerance) + elseif y < min3 then + void_deadly = y < min3 - deadly_tolerance end end return void, void_deadly @@ -33,12 +33,12 @@ end -- If the Y coordinate is not located in any dimension, it will return: -- nil, "void" function mcl_worlds.y_to_layer(y) - if y >= mcl_vars.mg_overworld_min then - return y - mcl_vars.mg_overworld_min, "overworld" - elseif y >= mcl_vars.mg_nether_min and y <= mcl_vars.mg_nether_max+128 then - return y - mcl_vars.mg_nether_min, "nether" - elseif y >= mcl_vars.mg_end_min and y <= mcl_vars.mg_end_max then - return y - mcl_vars.mg_end_min, "end" + if y >= min1 then + return y - min1, "overworld" + elseif y >= min3 and y <= max3 then + return y - min3, "nether" + elseif y >= min2 and y <= max2 then + return y - min2, "end" else return nil, "void" end diff --git a/mods/ENTITIES/mobs_mc_gameconfig/init.lua b/mods/ENTITIES/mobs_mc_gameconfig/init.lua index 06d7eb87f..dd310c1b3 100644 --- a/mods/ENTITIES/mobs_mc_gameconfig/init.lua +++ b/mods/ENTITIES/mobs_mc_gameconfig/init.lua @@ -233,15 +233,15 @@ mobs_mc.override.spawn_height = { water = tonumber(minetest.settings:get("water_level")) or 0, -- Water level in the Overworld -- Overworld boundaries (inclusive) - overworld_min = mcl_vars.mg_overworld_min, - overworld_max = mcl_vars.mg_overworld_max, + overworld_min = mcl_mapgen.overworld.min, + overworld_max = mcl_mapgen.overworld.max, -- Nether boundaries (inclusive) - nether_min = mcl_vars.mg_nether_min, - nether_max = mcl_vars.mg_nether_max, + nether_min = mcl_mapgen.nether.min, + nether_max = mcl_mapgen.nether.max, -- End boundaries (inclusive) - end_min = mcl_vars.mg_end_min, - end_max = mcl_vars.mg_end_max, + end_min = mcl_mapgen.end.min, + end_max = mcl_mapgen.end.max, } diff --git a/mods/ITEMS/mcl_portals/portal_nether.lua b/mods/ITEMS/mcl_portals/portal_nether.lua index 7fd0191fa..ee38264da 100644 --- a/mods/ITEMS/mcl_portals/portal_nether.lua +++ b/mods/ITEMS/mcl_portals/portal_nether.lua @@ -27,7 +27,7 @@ local DELAY = 3 -- seconds before teleporting in Nether portal in Survival mo local DISTANCE_MAX = 128 local PORTAL = "mcl_portals:portal" local OBSIDIAN = "mcl_core:obsidian" -local O_Y_MIN, O_Y_MAX = max(mcl_vars.mg_overworld_min, -31), min(mcl_vars.mg_overworld_max, 2048) +local O_Y_MIN, O_Y_MAX = max(mcl_mapgen.overworld.min, -31), min(mcl_mapgen.overworld.max, 2048) local N_Y_MIN, N_Y_MAX = mcl_vars.mg_bedrock_nether_bottom_min, mcl_vars.mg_bedrock_nether_top_min - H_MIN -- Alpha and particles @@ -66,7 +66,7 @@ minetest.register_on_shutdown(function() storage:set_string("nether_exits_keys", minetest.serialize(keys)) end) -local get_node = mcl_vars.get_node +local get_node = mcl_mapgen.get_far_node local set_node = minetest.set_node local registered_nodes = minetest.registered_nodes local is_protected = minetest.is_protected @@ -414,7 +414,7 @@ local function create_portal_2(pos1, name, obj) end local exit = build_nether_portal(pos1, W_MIN-2, H_MIN-2, orientation, name) finalize_teleport(obj, exit) - local cn = mcl_vars.get_chunk_number(pos1) + local cn = mcl_mapgen.get_chunk_number(pos1) chunks[cn] = nil if queue[cn] then for next_obj, _ in pairs(queue[cn]) do @@ -428,9 +428,9 @@ end local function get_lava_level(pos, pos1, pos2) if pos.y > -1000 then - return max(min(mcl_vars.mg_lava_overworld_max, pos2.y-1), pos1.y+1) + return max(min(mcl_mapgen.overworld.lava_max, pos2.y-1), pos1.y+1) end - return max(min(mcl_vars.mg_lava_nether_max, pos2.y-1), pos1.y+1) + return max(min(mcl_mapgen.nether.lava_max, pos2.y-1), pos1.y+1) end local function ecb_scan_area_2(blockpos, action, calls_remaining, param) @@ -509,7 +509,7 @@ local function ecb_scan_area_2(blockpos, action, calls_remaining, param) end local function create_portal(pos, limit1, limit2, name, obj) - local cn = mcl_vars.get_chunk_number(pos) + local cn = mcl_mapgen.get_chunk_number(pos) if chunks[cn] then local q = queue[cn] or {} q[obj] = true @@ -537,8 +537,8 @@ local function create_portal(pos, limit1, limit2, name, obj) end -- Basically the copy of code above, with minor additions to continue the search in single additional chunk below: - local next_chunk_1 = {x = pos1.x, y = pos1.y - mcl_vars.chunk_size_in_nodes, z = pos1.z} - local next_chunk_2 = add(next_chunk_1, mcl_vars.chunk_size_in_nodes - 1) + local next_chunk_1 = {x = pos1.x, y = pos1.y - mcl_mapgen.CS_NODES, z = pos1.z} + local next_chunk_2 = add(next_chunk_1, mcl_mapgen.CS_NODES - 1) local next_pos = {x = pos.x, y=max(next_chunk_2.y, limit1.y), z = pos.z} if limit1 and limit1.x and limit1.y and limit1.z then pos1 = {x = max(min(limit1.x, pos.x), pos1.x), y = max(min(limit1.y, pos.y), pos1.y), z = max(min(limit1.z, pos.z), pos1.z)} diff --git a/mods/MAPGEN/mcl_biomes/init.lua b/mods/MAPGEN/mcl_biomes/init.lua index 9facd83b3..3cfeea048 100644 --- a/mods/MAPGEN/mcl_biomes/init.lua +++ b/mods/MAPGEN/mcl_biomes/init.lua @@ -32,8 +32,8 @@ local function register_classic_superflat_biome() node_filler = "mcl_core:dirt", depth_filler = 3, node_stone = "mcl_core:dirt", - y_min = mcl_vars.mg_overworld_min - 512, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min - 512, + y_max = mcl_mapgen.overworld.max, humidity_point = 50, heat_point = 50, _mcl_biome_type = "medium", @@ -136,7 +136,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 24, heat_point = -5, _mcl_biome_type = "snowy", @@ -170,7 +170,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 3, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 58, heat_point = 8, _mcl_biome_type = "snowy", @@ -241,7 +241,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 76, heat_point = 10, _mcl_biome_type = "cold", @@ -273,7 +273,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 100, heat_point = 8, _mcl_biome_type = "cold", @@ -306,7 +306,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 4, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 10, heat_point = 45, _mcl_biome_type = "cold", @@ -356,7 +356,7 @@ local function register_biomes() node_riverbed = "mcl_core:gravel", depth_riverbed = 3, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 0, heat_point = 25, _mcl_biome_type = "cold", @@ -409,7 +409,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 4, y_min = 42, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 24, heat_point = 25, _mcl_biome_type = "cold", @@ -439,7 +439,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 1, y_min = -7, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 0, heat_point = 8, _mcl_biome_type = "cold", @@ -475,7 +475,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 24, heat_point = 8, _mcl_biome_type = "snowy", @@ -507,7 +507,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 3, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 39, heat_point = 58, _mcl_biome_type = "medium", @@ -554,7 +554,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 28, heat_point = 45, _mcl_biome_type = "medium", @@ -586,7 +586,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 58, heat_point = 22, _mcl_biome_type = "cold", @@ -633,7 +633,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 61, heat_point = 45, _mcl_biome_type = "medium", @@ -680,7 +680,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 3, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 44, heat_point = 32, _mcl_biome_type = "medium", @@ -727,7 +727,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 78, heat_point = 31, _mcl_biome_type = "medium", @@ -759,7 +759,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 77, heat_point = 27, _mcl_biome_type = "medium", @@ -792,7 +792,7 @@ local function register_biomes() depth_riverbed = 2, node_stone = "mcl_core:sandstone", y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 26, heat_point = 94, _mcl_biome_type = "hot", @@ -824,7 +824,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 94, heat_point = 27, _mcl_biome_type = "medium", @@ -857,7 +857,7 @@ local function register_biomes() depth_riverbed = 1, node_stone = "mcl_colorblocks:hardened_clay", y_min = 11, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 0, heat_point = 100, _mcl_biome_type = "hot", @@ -907,7 +907,7 @@ local function register_biomes() depth_riverbed = 1, node_stone = "mcl_colorblocks:hardened_clay", y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = -5, heat_point = 100, _mcl_biome_type = "hot", @@ -979,7 +979,7 @@ local function register_biomes() depth_riverbed = 1, node_stone = "mcl_colorblocks:hardened_clay", y_min = 30, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 0, heat_point = 60, _mcl_biome_type = "hot", @@ -1049,7 +1049,7 @@ local function register_biomes() depth_riverbed = 1, node_stone = "mcl_colorblocks:hardened_clay", y_min = 30, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = -5, heat_point = 60, _mcl_biome_type = "hot", @@ -1101,7 +1101,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 36, heat_point = 79, _mcl_biome_type = "hot", @@ -1150,7 +1150,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 48, heat_point = 100, _mcl_biome_type = "hot", @@ -1182,7 +1182,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 88, heat_point = 81, _mcl_biome_type = "medium", @@ -1231,7 +1231,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 92, heat_point = 81, _mcl_biome_type = "medium", @@ -1279,7 +1279,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 88, heat_point = 76, _mcl_biome_type = "medium", @@ -1314,7 +1314,7 @@ local function register_biomes() node_riverbed = "mcl_core:sand", depth_riverbed = 2, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, humidity_point = 90, heat_point = 79, _mcl_biome_type = "medium", @@ -1464,7 +1464,7 @@ local function register_biomes() name = biome .. "_underground", heat_point = minetest.registered_biomes[biome].heat_point, humidity_point = minetest.registered_biomes[biome].humidity_point, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = DEEP_OCEAN_MIN - 1, _mcl_biome_type = minetest.registered_biomes[biome]._mcl_biome_type, _mcl_palette_index = minetest.registered_biomes[biome]._mcl_palette_index, @@ -1485,10 +1485,10 @@ local function register_dimension_biomes() node_water = "air", node_river_water = "air", node_cave_liquid = "air", - y_min = mcl_vars.mg_nether_min, + y_min = mcl_mapgen.nether.min, -- FIXME: For some reason the Nether stops generating early if this constant is not added. -- Figure out why. - y_max = mcl_vars.mg_nether_max + 80, + y_max = mcl_mapgen.nether.max + 80, heat_point = 100, humidity_point = 0, _mcl_biome_type = "hot", @@ -1505,8 +1505,8 @@ local function register_dimension_biomes() node_cave_liquid = "air", -- FIXME: For some reason the End stops generating early if this constant is not added. -- Figure out why. - y_min = mcl_vars.mg_end_min, - y_max = mcl_vars.mg_end_max + 80, + y_min = mcl_mapgen.end.min, + y_max = mcl_mapgen.end.max + 80, heat_point = 50, humidity_point = 50, _mcl_biome_type = "medium", @@ -1551,7 +1551,7 @@ local function register_biome_ores() clust_scarcity = monster_egg_scarcity, clust_num_ores = 3, clust_size = 2, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(61), biomes = { "ExtremeHills", "ExtremeHills_beach", "ExtremeHills_ocean", "ExtremeHills_deep_ocean", "ExtremeHills_underground", @@ -1590,8 +1590,8 @@ local function register_biomelike_ores() clust_scarcity = 1, clust_num_ores = 12, clust_size = 10, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_threshold = 0.2, noise_params = {offset=0, scale=15, spread={x=130, y=130, z=130}, seed=24, octaves=3, persist=0.70}, biomes = { "MegaTaiga" }, @@ -1603,8 +1603,8 @@ local function register_biomelike_ores() wherein = {"mcl_core:dirt_with_grass", "mcl_core:dirt"}, column_height_max = 1, column_midpoint_factor = 0.0, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_threshold = 0.0, noise_params = {offset=0, scale=15, spread={x=250, y=250, z=250}, seed=24, octaves=3, persist=0.70}, biomes = { "MesaPlateauF_grasstop" }, @@ -1616,8 +1616,8 @@ local function register_biomelike_ores() clust_scarcity = 1500, clust_num_ores = 25, clust_size = 7, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_params = { offset = 0, scale = 1, @@ -1636,8 +1636,8 @@ local function register_biomelike_ores() wherein = {"mcl_core:dirt_with_grass", "mcl_core:dirt"}, column_height_max = 1, column_midpoint_factor = 0.0, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_threshold = -2.5, noise_params = {offset=1, scale=15, spread={x=250, y=250, z=250}, seed=24, octaves=3, persist=0.80}, biomes = { "MesaPlateauFM_grasstop" }, @@ -1649,8 +1649,8 @@ local function register_biomelike_ores() clust_scarcity = 1800, clust_num_ores = 65, clust_size = 15, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_params = { offset = 0, scale = 1, @@ -1670,8 +1670,8 @@ local function register_biomelike_ores() wherein = {"group:hardened_clay", "group:sand","mcl_core:coarse_dirt"}, clust_scarcity = 4000, clust_size = 5, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_params = { offset = 0, scale = 1, @@ -1690,8 +1690,8 @@ local function register_biomelike_ores() wherein = {"mcl_colorblocks:hardened_clay_orange"}, clust_scarcity = 300, clust_size = 8, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_params = { offset = 0, scale = 1, @@ -1712,8 +1712,8 @@ local function register_biomelike_ores() clust_scarcity = 1, clust_num_ores = 12, clust_size = 10, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_threshold = 0.1, noise_params = {offset=0, scale=15, spread={x=130, y=130, z=130}, seed=95, octaves=3, persist=0.70}, biomes = { "MesaPlateauFM" }, @@ -1724,8 +1724,8 @@ local function register_biomelike_ores() wherein = {"group:hardened_clay"}, clust_scarcity = 1500, clust_size = 4, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_params = { offset = 0, scale = 1, @@ -1748,8 +1748,8 @@ local function register_biomelike_ores() clust_scarcity = 5000, clust_num_ores = 12, clust_size = 4, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_threshold = 0.2, noise_params = {offset=0, scale=5, spread={x=250, y=250, z=250}, seed=64, octaves=3, persist=0.60}, biomes = { "ExtremeHillsM" }, @@ -1947,7 +1947,7 @@ local function register_dimension_ores() wherein = {"mcl_nether:netherrack", "mcl_core:stone"}, clust_scarcity = 13 * 13 * 13, clust_size = 5, - y_min = mcl_vars.mg_nether_min, + y_min = mcl_mapgen.nether.min, y_max = mcl_worlds.layer_to_y(64, "nether"), noise_threshold = 0.0, noise_params = { @@ -2010,7 +2010,7 @@ local function register_dimension_ores() clust_scarcity = 26 * 26 * 26, clust_size = 5, y_min = mcl_vars.mg_lava_nether_max + 10, - y_max = mcl_vars.mg_nether_max, + y_max = mcl_mapgen.nether.max, noise_threshold = 0.0, noise_params = { offset = 0.5, @@ -2053,8 +2053,8 @@ local function register_dimension_ores() clust_scarcity = 850, clust_num_ores = 4, -- MC cluster amount: 4-10 clust_size = 3, - y_min = mcl_vars.mg_nether_min, - y_max = mcl_vars.mg_nether_max, + y_min = mcl_mapgen.nether.min, + y_max = mcl_mapgen.nether.max, }) minetest.register_ore({ ore_type = "scatter", @@ -2063,8 +2063,8 @@ local function register_dimension_ores() clust_scarcity = 1650, clust_num_ores = 8, -- MC cluster amount: 4-10 clust_size = 4, - y_min = mcl_vars.mg_nether_min, - y_max = mcl_vars.mg_nether_max, + y_min = mcl_mapgen.nether.min, + y_max = mcl_mapgen.nether.max, }) end @@ -2076,7 +2076,7 @@ local function register_dimension_ores() clust_scarcity = 500, clust_num_ores = 1, clust_size = 1, - y_min = mcl_vars.mg_nether_min, + y_min = mcl_mapgen.nether.min, y_max = mcl_vars.mg_lava_nether_max + 1, }) @@ -2109,7 +2109,7 @@ local function register_dimension_ores() clust_num_ores = 1, clust_size = 1, y_min = mcl_vars.mg_lava_nether_max + 49, - y_max = mcl_vars.mg_nether_max, + y_max = mcl_mapgen.nether.max, }) --[[ THE END ]] @@ -2129,11 +2129,11 @@ local function register_dimension_ores() ore_type = "stratum", ore = "mcl_end:end_stone", wherein = end_wherein, - y_min = mcl_vars.mg_end_min+64, - y_max = mcl_vars.mg_end_min+80, + y_min = mcl_mapgen.end.min+64, + y_max = mcl_mapgen.end.min+80, noise_params = { - offset = mcl_vars.mg_end_min+70, + offset = mcl_mapgen.end.min+70, scale = -1, spread = {x=126, y=126, z=126}, seed = mg_seed+9999, @@ -2156,11 +2156,11 @@ local function register_dimension_ores() ore_type = "stratum", ore = "mcl_end:end_stone", wherein = end_wherein, - y_min = mcl_vars.mg_end_min+64, - y_max = mcl_vars.mg_end_min+80, + y_min = mcl_mapgen.end.min+64, + y_max = mcl_mapgen.end.min+80, noise_params = { - offset = mcl_vars.mg_end_min+72, + offset = mcl_mapgen.end.min+72, scale = -3, spread = {x=84, y=84, z=84}, seed = mg_seed+999, @@ -2182,11 +2182,11 @@ local function register_dimension_ores() ore_type = "stratum", ore = "mcl_end:end_stone", wherein = end_wherein, - y_min = mcl_vars.mg_end_min+64, - y_max = mcl_vars.mg_end_min+80, + y_min = mcl_mapgen.end.min+64, + y_max = mcl_mapgen.end.min+80, noise_params = { - offset = mcl_vars.mg_end_min+70, + offset = mcl_mapgen.end.min+70, scale = -2, spread = {x=84, y=84, z=84}, seed = mg_seed+99, @@ -2239,7 +2239,7 @@ local function register_grass_decoration(grasstype, offset, scale, biomes) noise_params = noise, biomes = { biomes[b] }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = node, param2 = param2, }) @@ -2306,7 +2306,7 @@ local function register_decorations() }, biomes = {"IcePlainsSpikes"}, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_ice_spike_large.mts", rotation = "random", flags = "place_center_x, place_center_z", @@ -2327,7 +2327,7 @@ local function register_decorations() }, biomes = {"IcePlainsSpikes"}, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_ice_spike_small.mts", rotation = "random", flags = "place_center_x, place_center_z", @@ -2350,7 +2350,7 @@ local function register_decorations() }, biomes = {"Forest"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_large_"..i..".mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2370,7 +2370,7 @@ local function register_decorations() }, biomes = {"ExtremeHills", "ExtremeHillsM", "ExtremeHills+", "ExtremeHills+_snowtop"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_large_"..i..".mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2391,7 +2391,7 @@ local function register_decorations() }, biomes = {"Forest"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_classic.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2410,7 +2410,7 @@ local function register_decorations() }, biomes = {"FlowerForest"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_classic.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2429,7 +2429,7 @@ local function register_decorations() }, biomes = {"ExtremeHills", "ExtremeHillsM", "ExtremeHills+", "ExtremeHills+_snowtop"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_classic.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2449,7 +2449,7 @@ local function register_decorations() }, biomes = {"ExtremeHills+", "ExtremeHills+_snowtop"}, y_min = 50, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_classic.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2468,7 +2468,7 @@ local function register_decorations() }, biomes = {"MesaPlateauF_grasstop"}, y_min = 30, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_classic.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2487,7 +2487,7 @@ local function register_decorations() }, biomes = {"MesaPlateauFM_grasstop"}, y_min = 30, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_classic.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2507,7 +2507,7 @@ local function register_decorations() }, biomes = {"IcePlains"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_classic.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2519,7 +2519,7 @@ local function register_decorations() fill_ratio = 0.004, biomes = {"Jungle", "JungleM"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_classic.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2531,7 +2531,7 @@ local function register_decorations() fill_ratio = 0.0004, biomes = {"JungleEdge", "JungleEdgeM", "Savanna"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_classic.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2553,7 +2553,7 @@ local function register_decorations() }, biomes = {"Forest"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_balloon.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2574,7 +2574,7 @@ local function register_decorations() }, biomes = {"Swampland", "Swampland_shore"}, y_min = 0, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_oak_swamp.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2591,7 +2591,7 @@ local function register_decorations() fill_ratio = 0.00125, biomes = {"Jungle"}, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_jungle_tree_huge_"..i..".mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2603,7 +2603,7 @@ local function register_decorations() fill_ratio = 0.004, biomes = {"JungleM"}, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_jungle_tree_huge_"..i..".mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2618,7 +2618,7 @@ local function register_decorations() fill_ratio = 0.045, biomes = {"Jungle"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_jungle_tree.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2630,7 +2630,7 @@ local function register_decorations() fill_ratio = 0.0045, biomes = {"JungleEdge", "JungleEdgeM"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_jungle_tree.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2643,7 +2643,7 @@ local function register_decorations() fill_ratio = 0.09, biomes = {"JungleM"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_jungle_tree.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2668,7 +2668,7 @@ local function register_decorations() }, biomes = biomes, y_min = y, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/"..sprucename, flags = "place_center_x, place_center_z", }) @@ -2722,7 +2722,7 @@ local function register_decorations() }, biomes = {"Taiga", "ColdTaiga"}, y_min = 2, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_spruce_lollipop.mts", flags = "place_center_x, place_center_z", }) @@ -2742,7 +2742,7 @@ local function register_decorations() }, biomes = {"Taiga", "ColdTaiga"}, y_min = 3, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_spruce_matchstick.mts", flags = "place_center_x, place_center_z", }) @@ -2762,7 +2762,7 @@ local function register_decorations() }, biomes = {"IcePlains"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_spruce_5.mts", flags = "place_center_x, place_center_z", }) @@ -2776,7 +2776,7 @@ local function register_decorations() fill_ratio = 0.0002, biomes = {"Savanna", "SavannaM"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_acacia_"..a..".mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2798,7 +2798,7 @@ local function register_decorations() }, biomes = {"BirchForest"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_birch.mts", flags = "place_center_x, place_center_z", }) @@ -2816,7 +2816,7 @@ local function register_decorations() }, biomes = {"BirchForestM"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_birch_tall.mts", flags = "place_center_x, place_center_z", }) @@ -2835,7 +2835,7 @@ local function register_decorations() }, biomes = {"Forest", "FlowerForest"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_birch.mts", flags = "place_center_x, place_center_z", }) @@ -2855,7 +2855,7 @@ local function register_decorations() }, biomes = {"RoofedForest"}, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_core").."/schematics/mcl_core_dark_oak.mts", flags = "place_center_x, place_center_z", rotation = "random", @@ -2877,7 +2877,7 @@ local function register_decorations() fill_ratio = ratio_mushroom_huge, biomes = { "RoofedForest" }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_mushrooms").."/schematics/mcl_mushrooms_huge_brown.mts", flags = "place_center_x, place_center_z", rotation = "0", @@ -2889,7 +2889,7 @@ local function register_decorations() fill_ratio = ratio_mushroom_giant, biomes = { "RoofedForest" }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_mushrooms").."/schematics/mcl_mushrooms_giant_brown.mts", flags = "place_center_x, place_center_z", rotation = "0", @@ -2902,7 +2902,7 @@ local function register_decorations() fill_ratio = ratio_mushroom_mycelium_huge, biomes = { "MushroomIsland", "MushroomIslandShore" }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_mushrooms").."/schematics/mcl_mushrooms_huge_brown.mts", flags = "place_center_x, place_center_z", rotation = "0", @@ -2914,7 +2914,7 @@ local function register_decorations() fill_ratio = ratio_mushroom_mycelium_giant, biomes = { "MushroomIsland", "MushroomIslandShore" }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_mushrooms").."/schematics/mcl_mushrooms_giant_brown.mts", flags = "place_center_x, place_center_z", rotation = "0", @@ -2928,7 +2928,7 @@ local function register_decorations() fill_ratio = ratio_mushroom_huge, biomes = { "RoofedForest" }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_mushrooms").."/schematics/mcl_mushrooms_huge_red.mts", flags = "place_center_x, place_center_z", rotation = "0", @@ -2940,7 +2940,7 @@ local function register_decorations() fill_ratio = ratio_mushroom_giant, biomes = { "RoofedForest" }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_mushrooms").."/schematics/mcl_mushrooms_giant_red.mts", flags = "place_center_x, place_center_z", rotation = "0", @@ -2953,7 +2953,7 @@ local function register_decorations() fill_ratio = ratio_mushroom_mycelium_huge, biomes = { "MushroomIsland", "MushroomIslandShore" }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_mushrooms").."/schematics/mcl_mushrooms_huge_red.mts", flags = "place_center_x, place_center_z", rotation = "0", @@ -2965,7 +2965,7 @@ local function register_decorations() fill_ratio = ratio_mushroom_mycelium_giant, biomes = { "MushroomIsland", "MushroomIslandShore" }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_mushrooms").."/schematics/mcl_mushrooms_giant_red.mts", flags = "place_center_x, place_center_z", rotation = "0", @@ -2986,7 +2986,7 @@ local function register_decorations() }, biomes = {"MegaTaiga", "MegaSpruceTaiga"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_boulder.mts", flags = "place_center_x, place_center_z", }) @@ -3006,7 +3006,7 @@ local function register_decorations() }, biomes = {"MegaTaiga", "MegaSpruceTaiga"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_boulder_small.mts", flags = "place_center_x, place_center_z", }) @@ -3025,7 +3025,7 @@ local function register_decorations() persist = 0.6 }, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_core:cactus", biomes = {"Desert", "Mesa","Mesa_sandlevel", @@ -3049,7 +3049,7 @@ local function register_decorations() persist = 0.7 }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_core:reeds", height = 1, height_max = 3, @@ -3070,7 +3070,7 @@ local function register_decorations() }, biomes = {"Swampland", "Swampland_shore"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_core:reeds", height = 1, height_max = 3, @@ -3104,7 +3104,7 @@ local function register_decorations() persist = 0.6, }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, biomes = { biomes[b] }, }) end @@ -3139,7 +3139,7 @@ local function register_decorations() persist = 0.66, }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, biomes = biomes[b], }) end @@ -3188,7 +3188,7 @@ local function register_decorations() persist = 0.62, }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, flags = "", biomes = b, }) @@ -3216,7 +3216,7 @@ local function register_decorations() }, biomes = {"Jungle"}, y_min = 3, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = jungle_bush_schematic, flags = "place_center_x, place_center_z", }) @@ -3234,7 +3234,7 @@ local function register_decorations() }, biomes = {"JungleM"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = jungle_bush_schematic, flags = "place_center_x, place_center_z", }) @@ -3252,7 +3252,7 @@ local function register_decorations() }, biomes = {"JungleEdge", "JungleEdgeM"}, y_min = 3, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = jungle_bush_schematic, flags = "place_center_x, place_center_z", }) @@ -3275,7 +3275,7 @@ local function register_decorations() }, biomes = {"MegaTaiga", "MegaSpruceTaiga", "Taiga"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = { size = {x = 3, y = 3, z = 1}, data = { @@ -3308,7 +3308,7 @@ local function register_decorations() }, biomes = {"ColdTaiga"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = { size = {x = 3, y = 3, z = 1}, data = { @@ -3341,7 +3341,7 @@ local function register_decorations() }, biomes = {"BirchForest", "BirchForestM",}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = { size = {x = 3, y = 3, z = 1}, data = { @@ -3367,7 +3367,7 @@ local function register_decorations() fill_ratio = 0.005, biomes = {"Jungle", "JungleM"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = { size = {x = 3, y = 3, z = 1}, data = { @@ -3400,7 +3400,7 @@ local function register_decorations() }, biomes = {"Forest"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = { size = {x = 3, y = 3, z = 1}, data = { @@ -3473,7 +3473,7 @@ local function register_decorations() persist = 0.6 }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_farming:melon", biomes = { "Jungle" }, }) @@ -3490,7 +3490,7 @@ local function register_decorations() persist = 0.6 }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_farming:melon", biomes = { "JungleM" }, }) @@ -3507,7 +3507,7 @@ local function register_decorations() persist = 0.6 }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_farming:melon", biomes = { "JungleEdge", "JungleEdgeM" }, }) @@ -3526,7 +3526,7 @@ local function register_decorations() persist = 0.6 }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_farming:melon", biomes = { "JungleEdgeM" }, }) @@ -3548,7 +3548,7 @@ local function register_decorations() persist = 0.666 }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, }) -- Grasses and ferns @@ -3623,7 +3623,7 @@ local function register_decorations() persist = 0.666 }, flags = "force_placement", - y_min = mcl_vars.mg_lava_overworld_max + 5, + y_min = mcl_mapgen.overworld.lava_max + 5, y_max = -20, }) @@ -3642,7 +3642,7 @@ local function register_decorations() }, biomes = {"IcePlains"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = { size = { x=1, y=2, z=1 }, data = { @@ -3665,7 +3665,7 @@ local function register_decorations() }, biomes = {"ExtremeHills+_snowtop"}, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, schematic = { size = { x=1, y=2, z=1 }, data = { @@ -3690,7 +3690,7 @@ local function register_decorations() persist = 0.6 }, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, biomes = {"Desert", "Mesa", "Mesa_sandlevel", "MesaPlateauF", "MesaPlateauF_sandlevel", "MesaPlateauF_grasstop","MesaBryce","Taiga", "MegaTaiga"}, decoration = "mcl_core:deadbush", height = 1, @@ -3708,7 +3708,7 @@ local function register_decorations() persist = 0.6 }, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, biomes = {"MesaPlateauFM_grasstop"}, decoration = "mcl_core:deadbush", height = 1, @@ -3726,7 +3726,7 @@ local function register_decorations() persist = 0.6 }, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, biomes = {"MesaPlateauFM","MesaPlateauFM_sandlevel"}, decoration = "mcl_core:deadbush", height = 1, @@ -3744,7 +3744,7 @@ local function register_decorations() persist = 0.6 }, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, biomes = {"MesaPlateauFM", "MesaPlateauFM_sandlevel", "MesaPlateauFM_grasstop"}, decoration = "mcl_core:deadbush", height = 1, @@ -3758,8 +3758,8 @@ local function register_decorations() fill_ratio = 0.009, biomes = {"MushroomIsland", "MushroomIslandShore"}, noise_threshold = 2.0, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_mushrooms:mushroom_red", }) minetest.register_decoration({ @@ -3768,8 +3768,8 @@ local function register_decorations() sidelen = 80, fill_ratio = 0.009, biomes = {"MushroomIsland", "MushroomIslandShore"}, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_mushrooms:mushroom_brown", }) @@ -3780,8 +3780,8 @@ local function register_decorations() sidelen = 80, fill_ratio = 0.003, biomes = {"Taiga", "MegaTaiga", "MegaSpruceTaiga"}, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_mushrooms:mushroom_red", }) minetest.register_decoration({ @@ -3790,8 +3790,8 @@ local function register_decorations() sidelen = 80, fill_ratio = 0.003, biomes = {"Taiga", "MegaTaiga", "MegaSpruceTaiga"}, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_mushrooms:mushroom_brown", }) @@ -3814,7 +3814,7 @@ local function register_decorations() persist = 0.66, }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = mushrooms[m], spawn_by = { "mcl_core:tree", "mcl_core:sprucetree", "mcl_core:darktree", "mcl_core:birchtree" }, num_spawn_by = 1, @@ -3834,7 +3834,7 @@ local function register_decorations() persist = 0.6, }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = mushrooms[m], biomes = { "Swampland"}, spawn_by = { "mcl_core:tree", "mcl_core:sprucetree", "mcl_core:darktree", "mcl_core:birchtree" }, @@ -3859,7 +3859,7 @@ local function register_decorations() persist = 0.6 }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, biomes = biomes, decoration = "mcl_flowers:"..name, }) @@ -3878,7 +3878,7 @@ local function register_decorations() persist = 0.6, }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, biomes = {"FlowerForest"}, decoration = "mcl_flowers:"..name, }) @@ -3925,8 +3925,8 @@ local function register_dimension_decorations() octaves = 3, persist = 0.6 }, - y_min = mcl_vars.mg_end_min, - y_max = mcl_vars.mg_end_max, + y_min = mcl_mapgen.end.min, + y_max = mcl_mapgen.end.max, decoration = "mcl_end:chorus_flower", height = 1, biomes = { "End" }, diff --git a/mods/MAPGEN/mcl_biomes/mod.conf b/mods/MAPGEN/mcl_biomes/mod.conf index 0c6095f3d..d389640a8 100644 --- a/mods/MAPGEN/mcl_biomes/mod.conf +++ b/mods/MAPGEN/mcl_biomes/mod.conf @@ -1,4 +1,4 @@ name = mcl_biomes author = maikerumine description = Adds the various biomes and biome-related things for non-v6 map generators. -depends = mcl_init, mcl_mapgen_core, mcl_core, mcl_worlds, mcl_farming, mcl_flowers, mcl_end, mcl_ocean +depends = mcl_mapgen, mcl_mapgen_core, mcl_core, mcl_worlds, mcl_farming, mcl_flowers, mcl_end, mcl_ocean diff --git a/mods/MAPGEN/mcl_dungeons/init.lua b/mods/MAPGEN/mcl_dungeons/init.lua index 40af11d37..b52a72ee6 100644 --- a/mods/MAPGEN/mcl_dungeons/init.lua +++ b/mods/MAPGEN/mcl_dungeons/init.lua @@ -32,11 +32,11 @@ local math_max = math.max local math_ceil = math.ceil --custom mcl_vars -local get_node = mcl_vars.get_node +local get_node = mcl_mapgen.get_far_node -local min_y = math_max(mcl_vars.mg_overworld_min, mcl_vars.mg_bedrock_overworld_max) + 1 -local max_y = mcl_vars.mg_overworld_max - 1 +local min_y = math_max(mcl_mapgen.overworld.min, mcl_vars.mg_bedrock_overworld_max) + 1 +local max_y = mcl_mapgen.overworld.max - 1 -- Calculate the number of dungeon spawn attempts -- In Minecraft, there 8 dungeon spawn attempts Minecraft chunk (16*256*16 = 65536 blocks). -- Minetest chunks don't have this size, so scale the number accordingly. diff --git a/mods/MAPGEN/mcl_mapgen_core/init.lua b/mods/MAPGEN/mcl_mapgen_core/init.lua index b14e1c2c7..563b62050 100644 --- a/mods/MAPGEN/mcl_mapgen_core/init.lua +++ b/mods/MAPGEN/mcl_mapgen_core/init.lua @@ -97,8 +97,8 @@ for s=1, #specialstones do clust_scarcity = 15*15*15, clust_num_ores = 33, clust_size = 5, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_params = { offset = 0, scale = 1, @@ -117,8 +117,8 @@ for s=1, #specialstones do clust_scarcity = 10*10*10, clust_num_ores = 58, clust_size = 7, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_params = { offset = 0, scale = 1, @@ -142,8 +142,8 @@ minetest.register_ore({ clust_scarcity = 15*15*15, clust_num_ores = 33, clust_size = 4, - y_min = mcl_vars.mg_overworld_min, - y_max = mcl_vars.mg_overworld_max, + y_min = mcl_mapgen.overworld.min, + y_max = mcl_mapgen.overworld.max, noise_params = { offset = 0, scale = 1, @@ -164,7 +164,7 @@ minetest.register_ore({ clust_scarcity = 14*14*14, clust_num_ores = 33, clust_size = 5, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(111), noise_params = { offset = 0, @@ -191,7 +191,7 @@ if minetest.settings:get_bool("mcl_generate_ores", true) then clust_scarcity = 525*3, clust_num_ores = 5, clust_size = 3, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(50), }) minetest.register_ore({ @@ -201,7 +201,7 @@ if minetest.settings:get_bool("mcl_generate_ores", true) then clust_scarcity = 510*3, clust_num_ores = 8, clust_size = 3, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(50), }) minetest.register_ore({ @@ -211,7 +211,7 @@ if minetest.settings:get_bool("mcl_generate_ores", true) then clust_scarcity = 500*3, clust_num_ores = 12, clust_size = 3, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(50), }) @@ -289,7 +289,7 @@ if minetest.settings:get_bool("mcl_generate_ores", true) then clust_scarcity = 830, clust_num_ores = 5, clust_size = 3, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(39), }) minetest.register_ore({ @@ -315,7 +315,7 @@ if minetest.settings:get_bool("mcl_generate_ores", true) then clust_scarcity = 4775, clust_num_ores = 5, clust_size = 3, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(30), }) minetest.register_ore({ @@ -325,7 +325,7 @@ if minetest.settings:get_bool("mcl_generate_ores", true) then clust_scarcity = 6560, clust_num_ores = 7, clust_size = 3, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(30), }) @@ -353,7 +353,7 @@ if minetest.settings:get_bool("mcl_generate_ores", true) then clust_scarcity = 10000, clust_num_ores = 4, clust_size = 3, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(12), }) minetest.register_ore({ @@ -363,7 +363,7 @@ if minetest.settings:get_bool("mcl_generate_ores", true) then clust_scarcity = 5000, clust_num_ores = 2, clust_size = 2, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(12), }) minetest.register_ore({ @@ -373,7 +373,7 @@ if minetest.settings:get_bool("mcl_generate_ores", true) then clust_scarcity = 10000, clust_num_ores = 8, clust_size = 3, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(12), }) @@ -411,7 +411,7 @@ if minetest.settings:get_bool("mcl_generate_ores", true) then clust_scarcity = 500, clust_num_ores = 4, clust_size = 3, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(13), }) minetest.register_ore({ @@ -421,7 +421,7 @@ if minetest.settings:get_bool("mcl_generate_ores", true) then clust_scarcity = 800, clust_num_ores = 7, clust_size = 4, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(13), }) @@ -462,7 +462,7 @@ if minetest.settings:get_bool("mcl_generate_ores", true) then clust_scarcity = 14340, clust_num_ores = 1, clust_size = 1, - y_min = mcl_vars.mg_overworld_min, + y_min = mcl_mapgen.overworld.min, y_max = mcl_worlds.layer_to_y(29), }) -- Rare spawn @@ -678,7 +678,7 @@ local function register_mgv6_decorations() persist = 0.6 }, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_core:cactus", height = 1, height_max = 3, @@ -698,7 +698,7 @@ local function register_mgv6_decorations() persist = 0.7 }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_core:reeds", height = 1, height_max = 3, @@ -728,7 +728,7 @@ local function register_mgv6_decorations() persist = 0.0, }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, }) -- Large ferns @@ -757,7 +757,7 @@ local function register_mgv6_decorations() persist = 0.66, }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, }) -- Large flowers @@ -1006,7 +1006,7 @@ local function register_mgv6_decorations() persist = 0.666 }, flags = "force_placement", - y_min = mcl_vars.mg_lava_overworld_max + 5, + y_min = mcl_mapgen.overworld.lava_max + 5, y_max = -20, }) @@ -1038,7 +1038,7 @@ local function register_mgv6_decorations() persist = 0.6 }, y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = mushrooms[m], spawn_by = { "mcl_core:tree", "mcl_core:sprucetree", "mcl_core:darktree", "mcl_core:birchtree", }, num_spawn_by = 1, @@ -1059,7 +1059,7 @@ local function register_mgv6_decorations() persist = 0.6 }, y_min = 4, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_core:deadbush", }) @@ -1068,7 +1068,7 @@ local function register_mgv6_decorations() offset = 0 end if y_max == nil then - y_max = mcl_vars.mg_overworld_max + y_max = mcl_mapgen.overworld.max end minetest.register_decoration({ deco_type = "simple", @@ -1111,7 +1111,7 @@ local function register_mgv6_decorations() sidelen = 16, fill_ratio = 11.0, -- complete coverage y_min = 1, - y_max = mcl_vars.mg_overworld_max, + y_max = mcl_mapgen.overworld.max, decoration = "mcl_core:snow", }) @@ -1719,7 +1719,7 @@ local generate_underground_mushrooms = function(minp, maxp, seed) local pr_shroom = PseudoRandom(seed-24359) -- Generate rare underground mushrooms -- TODO: Make them appear in groups, use Perlin noise - local min, max = mcl_vars.mg_lava_overworld_max + 4, 0 + local min, max = mcl_mapgen.overworld.lava_max + 4, 0 if minp.y > max or maxp.y < min then return end @@ -1752,7 +1752,7 @@ end local generate_nether_decorations = function(minp, maxp, seed) local pr_nether = PseudoRandom(seed+667) - if minp.y > mcl_vars.mg_nether_max or maxp.y < mcl_vars.mg_nether_min then + if minp.y > mcl_mapgen.nether.max or maxp.y < mcl_mapgen.nether.min then return end @@ -1899,23 +1899,23 @@ local function basic(c) local pr = PseudoRandom(blockseed) -- The Void below the Nether: - lvm_used = set_layers(data, area, c_void , nil, mcl_mapgen.EDGE_MIN , mcl_vars.mg_nether_min -1, minp, maxp, lvm_used, pr) + lvm_used = set_layers(data, area, c_void , nil, mcl_mapgen.EDGE_MIN , mcl_mapgen.nether.min -1, minp, maxp, lvm_used, pr) - -- [[ THE NETHER: mcl_vars.mg_nether_min mcl_vars.mg_nether_max ]] + -- [[ THE NETHER: mcl_mapgen.nether.min mcl_mapgen.nether.max ]] -- The Air on the Nether roof, https://git.minetest.land/MineClone2/MineClone2/issues/1186 - lvm_used = set_layers(data, area, c_air , nil, mcl_vars.mg_nether_max +1, mcl_vars.mg_nether_max + 128 , minp, maxp, lvm_used, pr) + lvm_used = set_layers(data, area, c_air , nil, mcl_mapgen.nether.max +1, mcl_mapgen.nether.max + 128 , minp, maxp, lvm_used, pr) -- The Void above the Nether below the End: - lvm_used = set_layers(data, area, c_void , nil, mcl_vars.mg_nether_max + 128 +1, mcl_vars.mg_end_min -1, minp, maxp, lvm_used, pr) + lvm_used = set_layers(data, area, c_void , nil, mcl_mapgen.nether.max + 128 +1, mcl_mapgen.end.min -1, minp, maxp, lvm_used, pr) - -- [[ THE END: mcl_vars.mg_end_min mcl_vars.mg_end_max ]] + -- [[ THE END: mcl_mapgen.end.min mcl_mapgen.end.max ]] -- The Void above the End below the Realm barrier: - lvm_used = set_layers(data, area, c_void , nil, mcl_vars.mg_end_max +1, mcl_vars.mg_realm_barrier_overworld_end_min-1, minp, maxp, lvm_used, pr) + lvm_used = set_layers(data, area, c_void , nil, mcl_mapgen.end.max +1, mcl_vars.mg_realm_barrier_overworld_end_min-1, minp, maxp, lvm_used, pr) -- Realm barrier between the Overworld void and the End lvm_used = set_layers(data, area, c_realm_barrier, nil, mcl_vars.mg_realm_barrier_overworld_end_min , mcl_vars.mg_realm_barrier_overworld_end_max , minp, maxp, lvm_used, pr) -- The Void above Realm barrier below the Overworld: - lvm_used = set_layers(data, area, c_void , nil, mcl_vars.mg_realm_barrier_overworld_end_max+1, mcl_vars.mg_overworld_min -1, minp, maxp, lvm_used, pr) + lvm_used = set_layers(data, area, c_void , nil, mcl_vars.mg_realm_barrier_overworld_end_max+1, mcl_mapgen.overworld.min -1, minp, maxp, lvm_used, pr) if mg_name ~= "singlenode" then @@ -1931,8 +1931,8 @@ local function basic(c) -- Big lava seas by replacing air below a certain height if mcl_vars.mg_lava then - lvm_used = set_layers(data, area, c_lava, c_air, mcl_vars.mg_overworld_min, mcl_vars.mg_lava_overworld_max, minp, maxp, lvm_used, pr) - lvm_used = set_layers(data, area, c_nether_lava, c_air, mcl_vars.mg_nether_min, mcl_vars.mg_lava_nether_max, minp, maxp, lvm_used, pr) + lvm_used = set_layers(data, area, c_lava, c_air, mcl_mapgen.overworld.min, mcl_mapgen.overworld.lava_max, minp, maxp, lvm_used, pr) + lvm_used = set_layers(data, area, c_nether_lava, c_air, mcl_mapgen.nether.min, mcl_vars.mg_lava_nether_max, minp, maxp, lvm_used, pr) end -- Clay, vines, cocoas @@ -1948,7 +1948,7 @@ local function basic(c) -- Snow and sand fixes. This code implements snow consistency -- and fixes floating sand and cut plants. -- A snowy grass block must be below a top snow or snow block at all times. - if minp.y <= mcl_vars.mg_overworld_max and maxp.y >= mcl_vars.mg_overworld_min then + if minp.y <= mcl_mapgen.overworld.max and maxp.y >= mcl_mapgen.overworld.min then -- v6 mapgen: if mg_name == "v6" then @@ -2014,7 +2014,7 @@ local function basic(c) -- Nether block fixes: -- * Replace water with Nether lava. -- * Replace stone, sand dirt in v6 so the Nether works in v6. - elseif emin.y <= mcl_vars.mg_nether_max and emax.y >= mcl_vars.mg_nether_min then + elseif emin.y <= mcl_mapgen.nether.max and emax.y >= mcl_mapgen.nether.min then if mg_name == "v6" then local nodes = minetest.find_nodes_in_area(emin, emax, {"mcl_core:water_source", "mcl_core:stone", "mcl_core:sand", "mcl_core:dirt"}) for n=1, #nodes do @@ -2041,7 +2041,7 @@ local function basic(c) -- * Replace water with end stone or air (depending on height). -- * Remove stone, sand, dirt in v6 so our End map generator works in v6. -- * Generate spawn platform (End portal destination) - elseif minp.y <= mcl_vars.mg_end_max and maxp.y >= mcl_vars.mg_end_min then + elseif minp.y <= mcl_mapgen.end.max and maxp.y >= mcl_mapgen.end.min then local nodes if mg_name == "v6" then nodes = minetest.find_nodes_in_area(emin, emax, {"mcl_core:water_source", "mcl_core:stone", "mcl_core:sand", "mcl_core:dirt"}) @@ -2083,11 +2083,11 @@ local function basic(c) -- Final hackery: Set sun light level in the End. -- -26912 is at a mapchunk border. local shadow = true - if minp.y >= -26912 and maxp.y <= mcl_vars.mg_end_max then + if minp.y >= -26912 and maxp.y <= mcl_mapgen.end.max then vm:set_lighting({day=15, night=15}) lvm_used = true end - if minp.y >= mcl_vars.mg_end_min and maxp.y <= -26911 then + if minp.y >= mcl_mapgen.end.min and maxp.y <= -26911 then shadow = false lvm_used = true end diff --git a/mods/MAPGEN/mcl_structures/init.lua b/mods/MAPGEN/mcl_structures/init.lua index e3f6b4829..8304061af 100644 --- a/mods/MAPGEN/mcl_structures/init.lua +++ b/mods/MAPGEN/mcl_structures/init.lua @@ -110,14 +110,14 @@ mcl_structures.generate_igloo = function(pos, rotation, pr) if r == 1 then -- Select basement depth local dim = mcl_worlds.pos_to_dimension(pos) - --local buffer = pos.y - (mcl_vars.mg_lava_overworld_max + 10) + --local buffer = pos.y - (mcl_mapgen.overworld.lava_max + 10) local buffer if dim == "nether" then buffer = pos.y - (mcl_vars.mg_lava_nether_max + 10) elseif dim == "end" then buffer = pos.y - (mcl_vars.mg_end_min + 1) elseif dim == "overworld" then - buffer = pos.y - (mcl_vars.mg_lava_overworld_max + 10) + buffer = pos.y - (mcl_mapgen.overworld.lava_max + 10) else return success end @@ -277,7 +277,7 @@ local function hut_placement_callback(p1, p2, size, orientation, pr) if not p1 or not p2 then return end local legs = minetest.find_nodes_in_area(p1, p2, "mcl_core:tree") for i = 1, #legs do - while minetest.get_item_group(mcl_vars.get_node({x=legs[i].x, y=legs[i].y-1, z=legs[i].z}, true, 333333).name, "water") ~= 0 do + while minetest.get_item_group(mcl_mapgen.get_far_node({x=legs[i].x, y=legs[i].y-1, z=legs[i].z}, true, 333333).name, "water") ~= 0 do legs[i].y = legs[i].y - 1 minetest.swap_node(legs[i], {name = "mcl_core:tree", param2 = 2}) end diff --git a/mods/MAPGEN/mcl_villages/buildings.lua b/mods/MAPGEN/mcl_villages/buildings.lua index 9d8e7580f..b9c4f8e85 100644 --- a/mods/MAPGEN/mcl_villages/buildings.lua +++ b/mods/MAPGEN/mcl_villages/buildings.lua @@ -88,7 +88,7 @@ function settlements.create_site_plan(maxp, minp, pr) -- find center_surface of chunk local center_surface , surface_material = settlements.find_surface(center, true) local chunks = {} - chunks[mcl_vars.get_chunk_number(center)] = true + chunks[mcl_mapgen.get_chunk_number(center)] = true -- go build settlement around center if not center_surface then return false end @@ -124,7 +124,7 @@ function settlements.create_site_plan(maxp, minp, pr) ptx = settlements.round(ptx, 0) ptz = settlements.round(ptz, 0) local pos1 = { x=ptx, y=center_surface.y+50, z=ptz} - local chunk_number = mcl_vars.get_chunk_number(pos1) + local chunk_number = mcl_mapgen.get_chunk_number(pos1) local pos_surface, surface_material if chunks[chunk_number] then pos_surface, surface_material = settlements.find_surface(pos1) diff --git a/mods/MAPGEN/mcl_villages/utils.lua b/mods/MAPGEN/mcl_villages/utils.lua index 993de11c4..87473cc80 100644 --- a/mods/MAPGEN/mcl_villages/utils.lua +++ b/mods/MAPGEN/mcl_villages/utils.lua @@ -1,4 +1,4 @@ -local get_node = mcl_vars.get_node +local get_node = mcl_mapgen.get_far_node ------------------------------------------------------------------------------- -- function to copy tables diff --git a/mods/MAPGEN/tsm_railcorridors/init.lua b/mods/MAPGEN/tsm_railcorridors/init.lua index f5a8b4908..ad8c6d99f 100644 --- a/mods/MAPGEN/tsm_railcorridors/init.lua +++ b/mods/MAPGEN/tsm_railcorridors/init.lua @@ -94,7 +94,7 @@ end -- Max. and min. heights between rail corridors are generated local height_min if mcl_vars.mg_lava then - height_min = mcl_vars.mg_lava_overworld_max + 2 + height_min = mcl_mapgen.overworld.lava_max + 2 else height_min = mcl_vars.mg_bedrock_overworld_max + 2 end From 3c5bf8c9b21f36b95e01b659ca9634be2832e5b1 Mon Sep 17 00:00:00 2001 From: kay27 Date: Thu, 29 Apr 2021 00:53:48 +0400 Subject: [PATCH 08/21] [mapgen] Use more readable constants, increase max_block_generate_distance --- minetest.conf | 2 + mods/CORE/mcl_mapgen/init.lua | 87 +++++++++++++---------- mods/CORE/mcl_worlds/init.lua | 18 ++--- mods/CORE/mcl_worlds/mod.conf | 3 +- mods/ENTITIES/mobs_mc_gameconfig/init.lua | 4 +- mods/ITEMS/mcl_portals/portal_end.lua | 8 +-- mods/ITEMS/mcl_portals/portal_nether.lua | 2 +- mods/MAPGEN/mcl_biomes/init.lua | 58 +++++++-------- mods/MAPGEN/mcl_dungeons/init.lua | 8 +-- mods/MAPGEN/mcl_mapgen_core/init.lua | 12 ++-- mods/MAPGEN/mcl_strongholds/init.lua | 9 ++- mods/MAPGEN/tsm_railcorridors/init.lua | 7 +- 12 files changed, 113 insertions(+), 105 deletions(-) diff --git a/minetest.conf b/minetest.conf index 223587f4d..1745bffb3 100644 --- a/minetest.conf +++ b/minetest.conf @@ -27,6 +27,8 @@ movement_gravity = 10.4 # Mapgen stuff +max_block_generate_distance = 13 + # altitude_chill and altitude_dry doesn't go well together with MCL2 biomes # which already include "snowed" variants as you go higher. # humid_rivers would cause the MushroomIsland biome to appear frequently around rivers. diff --git a/mods/CORE/mcl_mapgen/init.lua b/mods/CORE/mcl_mapgen/init.lua index 74461a5fa..6d3793a46 100644 --- a/mods/CORE/mcl_mapgen/init.lua +++ b/mods/CORE/mcl_mapgen/init.lua @@ -1,10 +1,7 @@ mcl_mapgen = {} -mcl_mapgen.overworld = {} -mcl_mapgen.nether = {} -mcl_mapgen.end = {} local minetest_log, math_floor = minetest.log, math.floor -local minetest_get_node = minetest.get_node +local minetest_get_node, minetest_get_voxel_manip = minetest.get_node, minetest.get_voxel_manip -- Calculate mapgen_edge_min/mapgen_edge_max mcl_mapgen.CS = math.max(1, tonumber(minetest.get_mapgen_setting("chunksize")) or 5) @@ -88,14 +85,14 @@ minetest.register_on_generated(function(minp, maxp, blockseed) vm_context.data = data area = VoxelArea:new({MinEdge=emin, MaxEdge=emax}) vm_context.area = area - for _, v in pairs(lvm_chunk_queue) do - vm_context = v.f(vm_context) - end end + local chunk_is_ready = true + if block > 0 then local x0, y0, z0 = minp.x, minp.y, minp.z local bx0, by0, bz0 = math_floor(x0/BS), math_floor(y0/BS), math_floor(z0/BS) + local bx1, by1, bz1 = bx0 + LAST_BLOCK, by0 + LAST_BLOCK, bz0 + LAST_BLOCK -- only for entire chunk check local x1, y1, z1, x2, y2, z2 = emin.x, emin.y, emin.z, emax.x, emax.y, emax.z local x, y, z = x1, y1, z1 -- iterate 7x7x7 mapchunk, {x,y,z} - first node pos. of mapblock local bx, by, bz -- block coords (in blocs) @@ -133,6 +130,7 @@ minetest.register_on_generated(function(minp, maxp, blockseed) end else blocks[bx][by][bz] = current_mapgen_block_writes + chunk_is_ready = chunk_is_ready and (bx < bx0 or bx > bx1 or by < by0 or by > by1 or bz < bz0 or bz > bz1) end z = z + BS end @@ -147,6 +145,11 @@ minetest.register_on_generated(function(minp, maxp, blockseed) end if lvm > 0 then + if chunk_is_ready then + for _, v in pairs(lvm_chunk_queue) do + vm_context = v.f(vm_context) + end + end if vm_context.write then vm:set_data(data) end @@ -158,8 +161,10 @@ minetest.register_on_generated(function(minp, maxp, blockseed) vm:update_liquids() end - for _, v in pairs(node_chunk_queue) do - v.f(minp, maxp, blockseed) + if chunk_is_ready then + for _, v in pairs(node_chunk_queue) do + v.f(minp, maxp, blockseed) + end end for i, b in pairs(current_blocks) do @@ -218,13 +223,16 @@ end -- Mapgen variables +local overworld, end_, nether = {}, {}, {} +mcl_mapgen.seed = minetest.get_mapgen_setting("seed") mcl_mapgen.name = minetest.get_mapgen_setting("mg_name") +mcl_mapgen.v6 = mcl_mapgen.name == "v6" mcl_mapgen.superflat = mcl_mapgen.name == "flat" and minetest.get_mapgen_setting("mcl_superflat_classic") == "true" mcl_mapgen.singlenode = mcl_mapgen.name == "singlenode" mcl_mapgen.normal = not mcl_mapgen.superflat and not mcl_mapgen.singlenode local superflat, singlenode, normal = mcl_mapgen.superflat, mcl_mapgen.singlenode, mcl_mapgen.normal -minetest_log("action", "[mcl_mapgen] Mapgen mode: " .. normal and "normal" or (superflat and "superflat" or "singlenode")) +minetest_log("action", "[mcl_mapgen] Mapgen mode: " .. (normal and "normal" or (superflat and "superflat" or "singlenode"))) mcl_mapgen.minecraft_height_limit = 256 @@ -241,55 +249,58 @@ mcl_mapgen.bedrock_is_rough = normal ]] -- Overworld -mcl_mapgen.overworld.min = -62 +overworld.min = -62 if superflat then mcl_mapgen.ground = tonumber(minetest.get_mapgen_setting("mgflat_ground_level")) or 8 - mcl_mapgen.overworld.min = ground - 3 + overworld.min = ground - 3 end -- if singlenode then mcl_mapgen.overworld.min = -66 end -- DONT KNOW WHY -mcl_mapgen.overworld.max = mcl_mapgen.EDGE_MAX +overworld.max = mcl_mapgen.EDGE_MAX -mcl_mapgen.overworld.bedrock_min = mcl_mapgen.overworld.min -mcl_mapgen.overworld.bedrock_max = mcl_mapgen.overworld.bedrock_min + (mcl_mapgen.bedrock_is_rough and 4 or 0) +overworld.bedrock_min = overworld.min +overworld.bedrock_max = overworld.bedrock_min + (mcl_mapgen.bedrock_is_rough and 4 or 0) mcl_mapgen.lava = normal -mcl_mapgen.lava_overworld_max = mcl_mapgen.overworld.min + (normal and 10 or 0) +overworld.lava_max = overworld.min + (normal and 10 or 0) -- The Nether (around Y = -29000) -mcl_mapgen.nether.min = -29067 -- Carefully chosen to be at a mapchunk border -mcl_mapgen.nether.max = mcl_mapgen.nether.min + 128 -mcl_mapgen.nether.bedrock_bottom_min = mcl_mapgen.nether.min -mcl_mapgen.nether.bedrock_top_max = mcl_mapgen.nether.max +nether.min = -29067 -- Carefully chosen to be at a mapchunk border +nether.max = nether.min + 128 +nether.bedrock_bottom_min = nether.min +nether.bedrock_top_max = nether.max if not superflat then - mcl_mapgen.nether.bedrock_bottom_max = mcl_vars.mg_bedrock_nether_bottom_min + 4 - mcl_mapgen.nether.bedrock_top_min = mcl_vars.mg_bedrock_nether_top_max - 4 - mcl_mapgen.nether.lava_max = mcl_mapgen.nether.min + 31 + nether.bedrock_bottom_max = nether.bedrock_bottom_min + 4 + nether.bedrock_top_min = nether.bedrock_top_max - 4 + nether.lava_max = nether.min + 31 else -- Thin bedrock in classic superflat mapgen - mcl_mapgen.nether.bedrock_bottom_max = mcl_vars.mg_bedrock_nether_bottom_min - mcl_mapgen.nether.bedrock_top_min = mcl_vars.mg_bedrock_nether_top_max - mcl_mapgen.nether.lava_max = mcl_mapgen.nether.min + 2 + nether.bedrock_bottom_max = nether.bedrock_bottom_min + nether.bedrock_top_min = nether.bedrock_top_max + nether.lava_max = nether.min + 2 end if mcl_mapgen.name == "flat" then if superflat then - mcl_mapgen.nether.flat_nether_floor = mcl_mapgen.nether.bedrock_nether_bottom_max + 4 - mcl_mapgen.nether.flat_nether_ceiling = mcl_mapgen.nether.bedrock_nether_bottom_max + 52 + nether.flat_nether_floor = nether.bedrock_bottom_max + 4 + nether.flat_nether_ceiling = nether.bedrock_bottom_max + 52 else - mcl_mapgen.nether.flat_nether_floor = mcl_mapgen.nether.lava_nether_max + 4 - mcl_mapgen.nether.flat_nether_ceiling = mcl_mapgen.nether.lava_nether_max + 52 + nether.flat_nether_floor = nether.lava_max + 4 + nether.flat_nether_ceiling = nether.lava_max + 52 end end -- The End (surface at ca. Y = -27000) -mcl_mapgen.end.min = -27073 -- Carefully chosen to be at a mapchunk border -mcl_mapgen.end.max_official = mcl_mapgen.end.min + mcl_mapgen.minecraft_height_limit -mcl_mapgen.end.max = mcl_mapgen.overworld.min - 2000 -mcl_vars.mg_end_platform_pos = { x = 100, y = mcl_mapgen.end.min + 74, z = 0 } +end_.min = -27073 -- Carefully chosen to be at a mapchunk border +end_.max = overworld.min - 2000 +end_.platform_pos = { x = 100, y = end_.min + 74, z = 0 } -- Realm barrier used to safely separate the End from the void below the Overworld -mcl_vars.mg_realm_barrier_overworld_end_max = mcl_mapgen.end.max -mcl_vars.mg_realm_barrier_overworld_end_min = mcl_mapgen.end.max - 11 +mcl_mapgen.realm_barrier_overworld_end_max = end_.max +mcl_mapgen.realm_barrier_overworld_end_min = end_.max - 11 --- Use MineClone 2-style dungeons -mcl_vars.mg_dungeons = true +-- Use MineClone 2-style dungeons for normal mapgen +mcl_mapgen.dungeons = normal + +mcl_mapgen.overworld = overworld +mcl_mapgen.end_ = end_ +mcl_mapgen.nether = nether diff --git a/mods/CORE/mcl_worlds/init.lua b/mods/CORE/mcl_worlds/init.lua index a9d9ea050..cc5ba756a 100644 --- a/mods/CORE/mcl_worlds/init.lua +++ b/mods/CORE/mcl_worlds/init.lua @@ -3,8 +3,8 @@ mcl_worlds = {} -- For a given position, returns a 2-tuple: -- 1st return value: true if pos is in void -- 2nd return value: true if it is in the deadly part of the void -local min1, min2, min3 = mcl_mapgen.overworld.min, mcl_mapgen.end.min, mcl_mapgen.nether.min -local max1, max2, max3 = mcl_mapgen.overworld.max, mcl_mapgen.end.max, mcl_mapgen.nether.max+128 +local min1, min2, min3 = mcl_mapgen.overworld.min, mcl_mapgen.end_.min, mcl_mapgen.nether.min +local max1, max2, max3 = mcl_mapgen.overworld.max, mcl_mapgen.end_.max, mcl_mapgen.nether.max+128 function mcl_worlds.is_in_void(pos) local y = pos.y local void = not ((y < max1 and y > min1) or (y < max2 and y > min2) or (y < max3 and y > min3)) @@ -13,7 +13,7 @@ function mcl_worlds.is_in_void(pos) local deadly_tolerance = 64 -- the player must be this many nodes “deep” into the void to be damaged if void then -- Overworld → Void → End → Void → Nether → Void - if y < mcl_vars.min1 and y > max2 then + if y < min1 and y > max2 then void_deadly = y < min1 - deadly_tolerance elseif y < min2 and y > max3 then -- The void between End and Nether. Like usual, but here, the void @@ -56,24 +56,24 @@ end -- mc_dimension is one of "overworld", "nether", "end" (default: "overworld"). function mcl_worlds.layer_to_y(layer, mc_dimension) if mc_dimension == "overworld" or mc_dimension == nil then - return layer + mcl_vars.mg_overworld_min + return layer + min1 elseif mc_dimension == "nether" then - return layer + mcl_vars.mg_nether_min + return layer + min3 elseif mc_dimension == "end" then - return layer + mcl_vars.mg_end_min + return layer + min2 end end -- Takes a position and returns true if this position can have weather function mcl_worlds.has_weather(pos) -- Weather in the Overworld and the high part of the void below - return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64 + return pos.y <= max1 and pos.y >= min1 - 64 end -- Takes a position and returns true if this position can have Nether dust function mcl_worlds.has_dust(pos) -- Weather in the Overworld and the high part of the void below - return pos.y <= mcl_vars.mg_nether_max + 138 and pos.y >= mcl_vars.mg_nether_min - 10 + return pos.y <= max3 + 138 and pos.y >= min3 - 10 end -- Takes a position (pos) and returns true if compasses are working here @@ -83,7 +83,7 @@ function mcl_worlds.compass_works(pos) if dim == "nether" or dim == "end" then return false elseif dim == "void" then - return pos.y <= mcl_vars.mg_overworld_max and pos.y >= mcl_vars.mg_overworld_min - 64 + return pos.y <= max1 and pos.y >= min1 - 64 else return true end diff --git a/mods/CORE/mcl_worlds/mod.conf b/mods/CORE/mcl_worlds/mod.conf index 4b979b4fe..8a44f4e01 100644 --- a/mods/CORE/mcl_worlds/mod.conf +++ b/mods/CORE/mcl_worlds/mod.conf @@ -1,5 +1,4 @@ name = mcl_worlds author = Wuzzy description = Utility functions for worlds and the “dimensions”. -depends = mcl_init - +depends = mcl_mapgen diff --git a/mods/ENTITIES/mobs_mc_gameconfig/init.lua b/mods/ENTITIES/mobs_mc_gameconfig/init.lua index dd310c1b3..703b9536c 100644 --- a/mods/ENTITIES/mobs_mc_gameconfig/init.lua +++ b/mods/ENTITIES/mobs_mc_gameconfig/init.lua @@ -241,7 +241,7 @@ mobs_mc.override.spawn_height = { nether_max = mcl_mapgen.nether.max, -- End boundaries (inclusive) - end_min = mcl_mapgen.end.min, - end_max = mcl_mapgen.end.max, + end_min = mcl_mapgen.end_.min, + end_max = mcl_mapgen.end_.max, } diff --git a/mods/ITEMS/mcl_portals/portal_end.lua b/mods/ITEMS/mcl_portals/portal_end.lua index 192f5001c..1b36d093d 100644 --- a/mods/ITEMS/mcl_portals/portal_end.lua +++ b/mods/ITEMS/mcl_portals/portal_end.lua @@ -1,10 +1,10 @@ local S = minetest.get_translator("mcl_portals") -- Parameters -local SPAWN_MIN = mcl_vars.mg_end_min+70 -local SPAWN_MAX = mcl_vars.mg_end_min+98 +local SPAWN_MIN = mcl_mapgen.end_.min+70 +local SPAWN_MAX = mcl_mapgen.end_.min+98 -local mg_name = minetest.get_mapgen_setting("mg_name") +local mg_name = mcl_mapgen.name local destroy_portal = function(pos) local neighbors = { @@ -178,7 +178,7 @@ function mcl_portals.end_teleport(obj, pos) -- Teleport to the End at a fixed position and generate a -- 5×5 obsidian platform below. - local platform_pos = mcl_vars.mg_end_platform_pos + local platform_pos = mcl_mapgen.end_.platform_pos -- force emerge of target1 area minetest.get_voxel_manip():read_from_map(platform_pos, platform_pos) if not minetest.get_node_or_nil(platform_pos) then diff --git a/mods/ITEMS/mcl_portals/portal_nether.lua b/mods/ITEMS/mcl_portals/portal_nether.lua index ee38264da..a06b2f8c7 100644 --- a/mods/ITEMS/mcl_portals/portal_nether.lua +++ b/mods/ITEMS/mcl_portals/portal_nether.lua @@ -28,7 +28,7 @@ local DISTANCE_MAX = 128 local PORTAL = "mcl_portals:portal" local OBSIDIAN = "mcl_core:obsidian" local O_Y_MIN, O_Y_MAX = max(mcl_mapgen.overworld.min, -31), min(mcl_mapgen.overworld.max, 2048) -local N_Y_MIN, N_Y_MAX = mcl_vars.mg_bedrock_nether_bottom_min, mcl_vars.mg_bedrock_nether_top_min - H_MIN +local N_Y_MIN, N_Y_MAX = mcl_mapgen.nether.bedrock_bottom_min, mcl_mapgen.nether.bedrock_top_min - H_MIN -- Alpha and particles local node_particles_allowed = minetest.settings:get("mcl_node_particles") or "none" diff --git a/mods/MAPGEN/mcl_biomes/init.lua b/mods/MAPGEN/mcl_biomes/init.lua index 3cfeea048..a35183c15 100644 --- a/mods/MAPGEN/mcl_biomes/init.lua +++ b/mods/MAPGEN/mcl_biomes/init.lua @@ -1,8 +1,7 @@ -local mg_name = minetest.get_mapgen_setting("mg_name") -local mg_seed = minetest.get_mapgen_setting("seed") +local mg_seed = mcl_mapgen.seed -- Some mapgen settings -local superflat = mg_name == "flat" and minetest.get_mapgen_setting("mcl_superflat_classic") == "true" +local superflat = mcl_mapgen.superflat local generate_fallen_logs = minetest.settings:get_bool("mcl_generate_fallen_logs", false) @@ -1505,8 +1504,8 @@ local function register_dimension_biomes() node_cave_liquid = "air", -- FIXME: For some reason the End stops generating early if this constant is not added. -- Figure out why. - y_min = mcl_mapgen.end.min, - y_max = mcl_mapgen.end.max + 80, + y_min = mcl_mapgen.end_.min, + y_max = mcl_mapgen.end_.max + 80, heat_point = 50, humidity_point = 50, _mcl_biome_type = "medium", @@ -1539,7 +1538,7 @@ local function register_biome_ores() -- Rarely replace stone with stone monster eggs. -- In v6 this can happen anywhere, in other mapgens only in Extreme Hills. local monster_egg_scarcity - if mg_name == "v6" then + if mcl_mapgen.v6 then monster_egg_scarcity = 28 * 28 * 28 else monster_egg_scarcity = 26 * 26 * 26 @@ -1561,7 +1560,7 @@ local function register_biome_ores() }) -- Bonus gold spawn in Mesa - if mg_name ~= "v6" then + if not mcl_mapgen.v6 then minetest.register_ore({ ore_type = "scatter", ore = "mcl_core:stone_with_gold", @@ -2009,7 +2008,7 @@ local function register_dimension_ores() wherein = {"mcl_nether:netherrack", "mcl_core:stone"}, clust_scarcity = 26 * 26 * 26, clust_size = 5, - y_min = mcl_vars.mg_lava_nether_max + 10, + y_min = mcl_mapgen.nether.lava_max + 10, y_max = mcl_mapgen.nether.max, noise_threshold = 0.0, noise_params = { @@ -2077,7 +2076,7 @@ local function register_dimension_ores() clust_num_ores = 1, clust_size = 1, y_min = mcl_mapgen.nether.min, - y_max = mcl_vars.mg_lava_nether_max + 1, + y_max = mcl_mapgen.nether.lava_max + 1, }) minetest.register_ore({ @@ -2087,8 +2086,8 @@ local function register_dimension_ores() clust_scarcity = 1000, clust_num_ores = 1, clust_size = 1, - y_min = mcl_vars.mg_lava_nether_max + 2, - y_max = mcl_vars.mg_lava_nether_max + 12, + y_min = mcl_mapgen.nether.lava_max + 2, + y_max = mcl_mapgen.nether.lava_max + 12, }) minetest.register_ore({ @@ -2098,8 +2097,8 @@ local function register_dimension_ores() clust_scarcity = 2000, clust_num_ores = 1, clust_size = 1, - y_min = mcl_vars.mg_lava_nether_max + 13, - y_max = mcl_vars.mg_lava_nether_max + 48, + y_min = mcl_mapgen.nether.lava_max + 13, + y_max = mcl_mapgen.nether.lava_max + 48, }) minetest.register_ore({ ore_type = "scatter", @@ -2108,7 +2107,7 @@ local function register_dimension_ores() clust_scarcity = 3500, clust_num_ores = 1, clust_size = 1, - y_min = mcl_vars.mg_lava_nether_max + 49, + y_min = mcl_mapgen.nether.lava_max + 49, y_max = mcl_mapgen.nether.max, }) @@ -2119,7 +2118,7 @@ local function register_dimension_ores() -- FIXME: Broken lighting in v6 mapgen local end_wherein - if mg_name == "v6" then + if mcl_mapgen.v6 then end_wherein = {"air", "mcl_core:stone"} else end_wherein = {"air"} @@ -2129,11 +2128,11 @@ local function register_dimension_ores() ore_type = "stratum", ore = "mcl_end:end_stone", wherein = end_wherein, - y_min = mcl_mapgen.end.min+64, - y_max = mcl_mapgen.end.min+80, + y_min = mcl_mapgen.end_.min+64, + y_max = mcl_mapgen.end_.min+80, noise_params = { - offset = mcl_mapgen.end.min+70, + offset = mcl_mapgen.end_.min+70, scale = -1, spread = {x=126, y=126, z=126}, seed = mg_seed+9999, @@ -2156,11 +2155,11 @@ local function register_dimension_ores() ore_type = "stratum", ore = "mcl_end:end_stone", wherein = end_wherein, - y_min = mcl_mapgen.end.min+64, - y_max = mcl_mapgen.end.min+80, + y_min = mcl_mapgen.end_.min+64, + y_max = mcl_mapgen.end_.min+80, noise_params = { - offset = mcl_mapgen.end.min+72, + offset = mcl_mapgen.end_.min+72, scale = -3, spread = {x=84, y=84, z=84}, seed = mg_seed+999, @@ -2182,11 +2181,11 @@ local function register_dimension_ores() ore_type = "stratum", ore = "mcl_end:end_stone", wherein = end_wherein, - y_min = mcl_mapgen.end.min+64, - y_max = mcl_mapgen.end.min+80, + y_min = mcl_mapgen.end_.min+64, + y_max = mcl_mapgen.end_.min+80, noise_params = { - offset = mcl_mapgen.end.min+70, + offset = mcl_mapgen.end_.min+70, scale = -2, spread = {x=84, y=84, z=84}, seed = mg_seed+99, @@ -3925,8 +3924,8 @@ local function register_dimension_decorations() octaves = 3, persist = 0.6 }, - y_min = mcl_mapgen.end.min, - y_max = mcl_mapgen.end.max, + y_min = mcl_mapgen.end_.min, + y_max = mcl_mapgen.end_.max, decoration = "mcl_end:chorus_flower", height = 1, biomes = { "End" }, @@ -3943,14 +3942,15 @@ end -- -- Detect mapgen to select functions -- -if mg_name ~= "singlenode" then + +if not mcl_mapgen.singlenode then if not superflat then - if mg_name ~= "v6" then + if not mcl_mapgen.v6 then register_biomes() register_biomelike_ores() end register_biome_ores() - if mg_name ~= "v6" then + if not mcl_mapgen.v6 then register_decorations() end else diff --git a/mods/MAPGEN/mcl_dungeons/init.lua b/mods/MAPGEN/mcl_dungeons/init.lua index b52a72ee6..d2458939e 100644 --- a/mods/MAPGEN/mcl_dungeons/init.lua +++ b/mods/MAPGEN/mcl_dungeons/init.lua @@ -2,10 +2,8 @@ mcl_dungeons = {} -local mg_name = minetest.get_mapgen_setting("mg_name") - -- Are dungeons disabled? -if mcl_vars.mg_dungeons == false or mg_name == "singlenode" then +if mcl_mapgen.dungeons == false or mcl_mapgen.singlenode == true then return end @@ -35,7 +33,7 @@ local math_ceil = math.ceil local get_node = mcl_mapgen.get_far_node -local min_y = math_max(mcl_mapgen.overworld.min, mcl_vars.mg_bedrock_overworld_max) + 1 +local min_y = math_max(mcl_mapgen.overworld.min, mcl_mapgen.overworld.bedrock_max) + 1 local max_y = mcl_mapgen.overworld.max - 1 -- Calculate the number of dungeon spawn attempts -- In Minecraft, there 8 dungeon spawn attempts Minecraft chunk (16*256*16 = 65536 blocks). @@ -358,7 +356,7 @@ local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param) } -- Bonus loot for v6 mapgen: Otherwise unobtainable saplings. - if mg_name == "v6" then + if mcl_mapgen.v6 then table_insert(loottable, { stacks_min = 1, stacks_max = 3, diff --git a/mods/MAPGEN/mcl_mapgen_core/init.lua b/mods/MAPGEN/mcl_mapgen_core/init.lua index 563b62050..da92c4e49 100644 --- a/mods/MAPGEN/mcl_mapgen_core/init.lua +++ b/mods/MAPGEN/mcl_mapgen_core/init.lua @@ -1906,12 +1906,12 @@ local function basic(c) -- The Air on the Nether roof, https://git.minetest.land/MineClone2/MineClone2/issues/1186 lvm_used = set_layers(data, area, c_air , nil, mcl_mapgen.nether.max +1, mcl_mapgen.nether.max + 128 , minp, maxp, lvm_used, pr) -- The Void above the Nether below the End: - lvm_used = set_layers(data, area, c_void , nil, mcl_mapgen.nether.max + 128 +1, mcl_mapgen.end.min -1, minp, maxp, lvm_used, pr) + lvm_used = set_layers(data, area, c_void , nil, mcl_mapgen.nether.max + 128 +1, mcl_mapgen.end_.min -1, minp, maxp, lvm_used, pr) - -- [[ THE END: mcl_mapgen.end.min mcl_mapgen.end.max ]] + -- [[ THE END: mcl_mapgen.end_.min mcl_mapgen.end_.max ]] -- The Void above the End below the Realm barrier: - lvm_used = set_layers(data, area, c_void , nil, mcl_mapgen.end.max +1, mcl_vars.mg_realm_barrier_overworld_end_min-1, minp, maxp, lvm_used, pr) + lvm_used = set_layers(data, area, c_void , nil, mcl_mapgen.end_.max +1, mcl_vars.mg_realm_barrier_overworld_end_min-1, minp, maxp, lvm_used, pr) -- Realm barrier between the Overworld void and the End lvm_used = set_layers(data, area, c_realm_barrier, nil, mcl_vars.mg_realm_barrier_overworld_end_min , mcl_vars.mg_realm_barrier_overworld_end_max , minp, maxp, lvm_used, pr) -- The Void above Realm barrier below the Overworld: @@ -2041,7 +2041,7 @@ local function basic(c) -- * Replace water with end stone or air (depending on height). -- * Remove stone, sand, dirt in v6 so our End map generator works in v6. -- * Generate spawn platform (End portal destination) - elseif minp.y <= mcl_mapgen.end.max and maxp.y >= mcl_mapgen.end.min then + elseif minp.y <= mcl_mapgen.end_.max and maxp.y >= mcl_mapgen.end_.min then local nodes if mg_name == "v6" then nodes = minetest.find_nodes_in_area(emin, emax, {"mcl_core:water_source", "mcl_core:stone", "mcl_core:sand", "mcl_core:dirt"}) @@ -2083,11 +2083,11 @@ local function basic(c) -- Final hackery: Set sun light level in the End. -- -26912 is at a mapchunk border. local shadow = true - if minp.y >= -26912 and maxp.y <= mcl_mapgen.end.max then + if minp.y >= -26912 and maxp.y <= mcl_mapgen.end_.max then vm:set_lighting({day=15, night=15}) lvm_used = true end - if minp.y >= mcl_mapgen.end.min and maxp.y <= -26911 then + if minp.y >= mcl_mapgen.end_.min and maxp.y <= -26911 then shadow = false lvm_used = true end diff --git a/mods/MAPGEN/mcl_strongholds/init.lua b/mods/MAPGEN/mcl_strongholds/init.lua index 42544e1ed..e4bbdb974 100644 --- a/mods/MAPGEN/mcl_strongholds/init.lua +++ b/mods/MAPGEN/mcl_strongholds/init.lua @@ -18,8 +18,7 @@ local stronghold_rings = { local strongholds = {} local strongholds_inited = false -local mg_name = minetest.get_mapgen_setting("mg_name") -local superflat = mg_name == "flat" and minetest.get_mapgen_setting("mcl_superflat_classic") == "true" +local superflat = mcl_mapgen.superflat -- Determine the stronghold positions and store them into the strongholds table. -- The stronghold positions are based on the world seed. @@ -30,7 +29,7 @@ local init_strongholds = function() return end -- Don't generate strongholds in singlenode - if mg_name == "singlenode" then + if mcl_mapgen.singlenode then strongholds_inited = true return end @@ -47,9 +46,9 @@ local init_strongholds = function() local dist = pr:next(ring.min, ring.max) local y if superflat then - y = mcl_vars.mg_bedrock_overworld_max + 3 + y = mcl_mapgen.overworld.bedrock_max + 3 else - y = pr:next(mcl_vars.mg_bedrock_overworld_max+1, mcl_vars.mg_overworld_min+48) + y = pr:next(mcl_mapgen.overworld.bedrock_max+1, mcl_mapgen.overworld.bedrock_min+48) end local pos = { x = math.cos(angle) * dist, y = y, z = math.sin(angle) * dist } pos = vector.round(pos) diff --git a/mods/MAPGEN/tsm_railcorridors/init.lua b/mods/MAPGEN/tsm_railcorridors/init.lua index ad8c6d99f..a971f203e 100644 --- a/mods/MAPGEN/tsm_railcorridors/init.lua +++ b/mods/MAPGEN/tsm_railcorridors/init.lua @@ -16,8 +16,7 @@ end local probability_railcaves_in_mapchunk = P(0.33333) setting = tonumber(minetest.settings:get("tsm_railcorridors_probability_railcaves_in_mapchunk")) -- Extra check to prevent mod griefing in singlenode, mcimported worlds. -local mg_name = minetest.get_mapgen_setting("mg_name") -if mg_name == "singlenode" then +if mcl_mapgen.singlenode then probability_railcaves_in_mapchunk = P(0) elseif setting then probability_railcaves_in_mapchunk = P(setting) @@ -93,10 +92,10 @@ end -- Max. and min. heights between rail corridors are generated local height_min -if mcl_vars.mg_lava then +if mcl_mapgen.lava then height_min = mcl_mapgen.overworld.lava_max + 2 else - height_min = mcl_vars.mg_bedrock_overworld_max + 2 + height_min = mcl_mapgen.overworld.bedrock_max + 2 end local height_max = mcl_worlds.layer_to_y(60) From f38c8daab7c78a1898cc52d4f629058f8861edd8 Mon Sep 17 00:00:00 2001 From: kay27 Date: Sun, 2 May 2021 02:26:41 +0400 Subject: [PATCH 09/21] [mapgen] Add safe chunk calculation --- mods/CORE/mcl_mapgen/init.lua | 81 ++++++++++++++++++++++++----------- 1 file changed, 57 insertions(+), 24 deletions(-) diff --git a/mods/CORE/mcl_mapgen/init.lua b/mods/CORE/mcl_mapgen/init.lua index 6d3793a46..8859c0b0a 100644 --- a/mods/CORE/mcl_mapgen/init.lua +++ b/mods/CORE/mcl_mapgen/init.lua @@ -1,13 +1,17 @@ mcl_mapgen = {} -local minetest_log, math_floor = minetest.log, math.floor -local minetest_get_node, minetest_get_voxel_manip = minetest.get_node, minetest.get_voxel_manip +local math_floor = math.floor +local math_max = math.max +local minetest_get_node = minetest.get_node +local minetest_get_voxel_manip = minetest.get_voxel_manip +local minetest_log = minetest.log +local minetest_pos_to_string = minetest.pos_to_string -- Calculate mapgen_edge_min/mapgen_edge_max -mcl_mapgen.CS = math.max(1, tonumber(minetest.get_mapgen_setting("chunksize")) or 5) -mcl_mapgen.BS = math.max(1, core.MAP_BLOCKSIZE or 16) -mcl_mapgen.LIMIT = math.max(1, tonumber(minetest.get_mapgen_setting("mapgen_limit")) or 31000) -mcl_mapgen.MAX_LIMIT = math.max(1, core.MAX_MAP_GENERATION_LIMIT or 31000) +mcl_mapgen.CS = math_max(1, tonumber(minetest.get_mapgen_setting("chunksize")) or 5) +mcl_mapgen.BS = math_max(1, core.MAP_BLOCKSIZE or 16) +mcl_mapgen.LIMIT = math_max(1, tonumber(minetest.get_mapgen_setting("mapgen_limit")) or 31000) +mcl_mapgen.MAX_LIMIT = math_max(1, core.MAX_MAP_GENERATION_LIMIT or 31000) -- might be set to 31000 or removed, see https://github.com/minetest/minetest/issues/10428 mcl_mapgen.OFFSET = - math_floor(mcl_mapgen.CS / 2) mcl_mapgen.OFFSET_NODES = mcl_mapgen.OFFSET * mcl_mapgen.BS mcl_mapgen.CS_NODES = mcl_mapgen.CS * mcl_mapgen.BS @@ -22,8 +26,8 @@ local mapgen_limit_b = math_floor(math.min(mcl_mapgen.LIMIT, mcl_mapgen.MAX_LIMI local mapgen_limit_min = - mapgen_limit_b * mcl_mapgen.BS local mapgen_limit_max = (mapgen_limit_b + 1) * mcl_mapgen.BS - 1 -local numcmin = math.max(math_floor((ccfmin - mapgen_limit_min) / mcl_mapgen.CS_NODES), 0) -- Number of complete chunks from central chunk -local numcmax = math.max(math_floor((mapgen_limit_max - ccfmax) / mcl_mapgen.CS_NODES), 0) -- fullminp/fullmaxp to effective mapgen limits. +local numcmin = math_max(math_floor((ccfmin - mapgen_limit_min) / mcl_mapgen.CS_NODES), 0) -- Number of complete chunks from central chunk +local numcmax = math_max(math_floor((mapgen_limit_max - ccfmax) / mcl_mapgen.CS_NODES), 0) -- fullminp/fullmaxp to effective mapgen limits. mcl_mapgen.EDGE_MIN = central_chunk_min_pos - numcmin * mcl_mapgen.CS_NODES mcl_mapgen.EDGE_MAX = central_chunk_max_pos + numcmax * mcl_mapgen.CS_NODES @@ -39,6 +43,8 @@ local BS, CS = mcl_mapgen.BS, mcl_mapgen.CS -- Mapblock size (in nodes), Mapchun local LAST_BLOCK, LAST_NODE = CS - 1, BS - 1 -- First mapblock in chunk (node in mapblock) has number 0, last has THIS number. It's for runtime optimization local offset = mcl_mapgen.OFFSET -- Central mapchunk offset (in blocks) +local CS_3D = CS * CS * CS + local DEFAULT_PRIORITY = 5000 function mcl_mapgen.register_chunk_generator(callback_function, priority) @@ -66,18 +72,22 @@ function mcl_mapgen.register_block_generator_lvm(callback_function, priority) end local storage = minetest.get_mod_storage() -local blocks = minetest.deserialize( storage:get_string("mapgen_blocks") or "return {}") or {} -minetest.register_on_shutdown(function() storage:set_string("mapgen_blocks", minetest.serialize(blocks)) end) +local blocks = minetest.deserialize(storage:get_string("mapgen_blocks") or "return {}") or {} +local chunks = minetest.deserialize(storage:get_string("mapgen_chunks") or "return {}") or {} +minetest.register_on_shutdown(function() + storage:set_string("mapgen_chunks", minetest.serialize(chunks)) + storage:set_string("mapgen_blocks", minetest.serialize(blocks)) +end) local vm_context-- here will be many references and flags, like: param2, light_data, heightmap, biomemap, heatmap, humiditymap, gennotify, write_lvm, write_param2, shadow local data, data2, area local current_blocks = {} +local current_chunks = {} minetest.register_on_generated(function(minp, maxp, blockseed) local minp, maxp, blockseed = minp, maxp, blockseed - minetest_log("verbose", "[mcl_mapgen] New chunk: minp=" .. minetest.pos_to_string(minp) .. ", maxp=" .. minetest.pos_to_string(maxp) .. ", blockseed=" .. blockseed) - local vm, emin, emax = minetest.get_mapgen_object("voxelmanip") + minetest_log("warning", "[mcl_mapgen] New_chunk=" .. minetest_pos_to_string(minp) .. "..." .. minetest_pos_to_string(maxp) .. ", shall=" .. minetest_pos_to_string(emin) .. "..." .. minetest_pos_to_string(emax) .. ", blockseed=" .. tostring(blockseed)) if lvm > 0 then vm_context = {lvm_param2_buffer = lvm_param2_buffer, vm = vm, emin = emin, emax = emax, minp = minp, maxp = maxp, blockseed = blockseed} @@ -87,12 +97,21 @@ minetest.register_on_generated(function(minp, maxp, blockseed) vm_context.area = area end - local chunk_is_ready = true - - if block > 0 then + if safe_functions > 0 then local x0, y0, z0 = minp.x, minp.y, minp.z local bx0, by0, bz0 = math_floor(x0/BS), math_floor(y0/BS), math_floor(z0/BS) local bx1, by1, bz1 = bx0 + LAST_BLOCK, by0 + LAST_BLOCK, bz0 + LAST_BLOCK -- only for entire chunk check + + -- Keep `blockseed` in `chunks[cx][cy][cz].seed` for further safe usage: + local cx0, cy0, cz0 = math_floor((bx0-offset)/CS), math_floor((by0-offset)/CS), math_floor((bz0-offset)/CS) + if not chunks[cx0] then chunks[cx0] = {} end + if not chunks[cx0][cy0] then chunks[cx0][cy0] = {} end + if not chunks[cx0][cy0][cz0] then + chunks[cx0][cy0][cz0] = {seed = blockseed, counter = 0} + else + chunks[cx0][cy0][cz0].seed = blockseed + end + local x1, y1, z1, x2, y2, z2 = emin.x, emin.y, emin.z, emax.x, emax.y, emax.z local x, y, z = x1, y1, z1 -- iterate 7x7x7 mapchunk, {x,y,z} - first node pos. of mapblock local bx, by, bz -- block coords (in blocs) @@ -100,24 +119,43 @@ minetest.register_on_generated(function(minp, maxp, blockseed) while x < x2 do bx = math_floor(x/BS) local block_pos_offset_removed = bx - offset + local cx = math_floor(block_pos_offset_removed / CS) box = block_pos_offset_removed % CS if not blocks[bx] then blocks[bx]={} end local total_mapgen_block_writes_through_x = (box > 0 and box < LAST_BLOCK) and 4 or 8 while y < y2 do by = math_floor(y/BS) block_pos_offset_removed = by - offset + local cy = math_floor(block_pos_offset_removed / CS) boy = block_pos_offset_removed % CS if not blocks[bx][by] then blocks[bx][by]={} end local total_mapgen_block_writes_through_y = (boy > 0 and boy < LAST_BLOCK) and math_floor(total_mapgen_block_writes_through_x / 2) or total_mapgen_block_writes_through_x while z < z2 do bz = math_floor(z/BS) block_pos_offset_removed = bz - offset + local cz = math_floor(block_pos_offset_removed / CS) boz = block_pos_offset_removed % CS local total_mapgen_block_writes = (boz > 0 and boz < LAST_BLOCK) and math_floor(total_mapgen_block_writes_through_y / 2) or total_mapgen_block_writes_through_y local current_mapgen_block_writes = blocks[bx][by][bz] and (blocks[bx][by][bz] + 1) or 1 if current_mapgen_block_writes == total_mapgen_block_writes then -- this block shouldn't be overwritten anymore, no need to keep it in memory blocks[bx][by][bz] = nil + if not chunks[cx][cy][cz] then + if not chunks[cx] then chunks[cx] = {} end + if not chunks[cx][cy] then chunks[cx][cy] = {} end + if not chunks[cx][cy][cz] then chunks[cx][cy][cz] = {counter = 1} end + else + chunks[cx][cy][cz].counter = chunks[cx][cy][cz].counter + 1 + if chunks[cx][cy][cz].counter >= CS_3D then + -- this chunk shouldn't be overwritten anymore, no need to keep it in memory + local chunkseed = chunks[cx][cy][cz].seed + process_generated_chunk(cx, cy, cz, chunkseed) + + chunks[cx][cy][cz] = nil + if next(chunks[cx][cy]) == nil then chunks[cx][cy] = nil end + if next(chunks[cx]) == nil then chunks[cx] = nil end + end + end vm_context.seed = blockseed + box * 7 + boy * 243 + boz * 11931 if lvm_block > 0 then vm_context.minp, vm_content.maxp = {x=x, y=y, z=z}, {x=x+LAST_NODE, y=y+LAST_NODE, z=z+LAST_NODE} @@ -130,7 +168,6 @@ minetest.register_on_generated(function(minp, maxp, blockseed) end else blocks[bx][by][bz] = current_mapgen_block_writes - chunk_is_ready = chunk_is_ready and (bx < bx0 or bx > bx1 or by < by0 or by > by1 or bz < bz0 or bz > bz1) end z = z + BS end @@ -145,10 +182,8 @@ minetest.register_on_generated(function(minp, maxp, blockseed) end if lvm > 0 then - if chunk_is_ready then - for _, v in pairs(lvm_chunk_queue) do - vm_context = v.f(vm_context) - end + for _, v in pairs(lvm_chunk_queue) do + vm_context = v.f(vm_context) end if vm_context.write then vm:set_data(data) @@ -161,10 +196,8 @@ minetest.register_on_generated(function(minp, maxp, blockseed) vm:update_liquids() end - if chunk_is_ready then - for _, v in pairs(node_chunk_queue) do - v.f(minp, maxp, blockseed) - end + for _, v in pairs(node_chunk_queue) do + v.f(minp, maxp, blockseed) end for i, b in pairs(current_blocks) do From f4a28cfab0c686c9b750e0c0f53e287a8d7b667f Mon Sep 17 00:00:00 2001 From: kay27 Date: Sun, 2 May 2021 03:56:55 +0400 Subject: [PATCH 10/21] [mapgen] GETTING RID OF EMERGE AREAS! Currently for dungeons and villages, and it works --- mods/CORE/mcl_mapgen/init.lua | 29 +++++++++++++++-------- mods/MAPGEN/mcl_dungeons/init.lua | 22 ++++++++++------- mods/MAPGEN/mcl_villages/init.lua | 33 +++++++++++++++++--------- mods/MAPGEN/mcl_villages/utils.lua | 38 ------------------------------ 4 files changed, 54 insertions(+), 68 deletions(-) diff --git a/mods/CORE/mcl_mapgen/init.lua b/mods/CORE/mcl_mapgen/init.lua index 8859c0b0a..5be3ac488 100644 --- a/mods/CORE/mcl_mapgen/init.lua +++ b/mods/CORE/mcl_mapgen/init.lua @@ -37,11 +37,12 @@ minetest_log("action", "[mcl_mapgen] World edges are: mcl_mapgen.EDGE_MIN = " .. local lvm_block_queue, lvm_chunk_queue, node_block_queue, node_chunk_queue = {}, {}, {}, {} -- Generators' queues -local lvm, block, lvm_block, lvm_chunk, param2, nodes_block, nodes_chunk = 0, 0, 0, 0, 0, 0, 0 -- Requirements: 0 means none; greater than 0 means 'required' +local lvm, block, lvm_block, lvm_chunk, param2, nodes_block, nodes_chunk, safe_functions = 0, 0, 0, 0, 0, 0, 0, 0 -- Requirements: 0 means none; greater than 0 means 'required' local lvm_buffer, lvm_param2_buffer = {}, {} -- Static buffer pointers local BS, CS = mcl_mapgen.BS, mcl_mapgen.CS -- Mapblock size (in nodes), Mapchunk size (in blocks) local LAST_BLOCK, LAST_NODE = CS - 1, BS - 1 -- First mapblock in chunk (node in mapblock) has number 0, last has THIS number. It's for runtime optimization local offset = mcl_mapgen.OFFSET -- Central mapchunk offset (in blocks) +local CS_NODES = mcl_mapgen.CS_NODES -- 80 local CS_3D = CS * CS * CS @@ -49,6 +50,7 @@ local DEFAULT_PRIORITY = 5000 function mcl_mapgen.register_chunk_generator(callback_function, priority) nodes_chunk = nodes_chunk + 1 + safe_functions = safe_functions + 1 node_chunk_queue[nodes_chunk] = {i = priority or DEFAULT_PRIORITY, f = callback_function} table.sort(node_chunk_queue, function(a, b) return (a.i <= b.i) end) end @@ -60,6 +62,7 @@ end function mcl_mapgen.register_block_generator(callback_function, priority) block = block + 1 nodes_block = nodes_block + 1 + safe_functions = safe_functions + 1 node_block_queue[nodes_block] = {i = priority or DEFAULT_PRIORITY, f = callback_function} table.sort(node_block_queue, function(a, b) return (a.i <= b.i) end) end @@ -87,7 +90,7 @@ local current_chunks = {} minetest.register_on_generated(function(minp, maxp, blockseed) local minp, maxp, blockseed = minp, maxp, blockseed local vm, emin, emax = minetest.get_mapgen_object("voxelmanip") - minetest_log("warning", "[mcl_mapgen] New_chunk=" .. minetest_pos_to_string(minp) .. "..." .. minetest_pos_to_string(maxp) .. ", shall=" .. minetest_pos_to_string(emin) .. "..." .. minetest_pos_to_string(emax) .. ", blockseed=" .. tostring(blockseed)) + minetest_log("warning", "[mcl_mapgen] New_chunk=" .. minetest_pos_to_string(minp) .. "..." .. minetest_pos_to_string(maxp) .. ", shell=" .. minetest_pos_to_string(emin) .. "..." .. minetest_pos_to_string(emax) .. ", blockseed=" .. tostring(blockseed)) if lvm > 0 then vm_context = {lvm_param2_buffer = lvm_param2_buffer, vm = vm, emin = emin, emax = emax, minp = minp, maxp = maxp, blockseed = blockseed} @@ -140,17 +143,15 @@ minetest.register_on_generated(function(minp, maxp, blockseed) if current_mapgen_block_writes == total_mapgen_block_writes then -- this block shouldn't be overwritten anymore, no need to keep it in memory blocks[bx][by][bz] = nil + if not chunks[cx] then chunks[cx] = {} end + if not chunks[cx][cy] then chunks[cx][cy] = {} end if not chunks[cx][cy][cz] then - if not chunks[cx] then chunks[cx] = {} end - if not chunks[cx][cy] then chunks[cx][cy] = {} end if not chunks[cx][cy][cz] then chunks[cx][cy][cz] = {counter = 1} end else chunks[cx][cy][cz].counter = chunks[cx][cy][cz].counter + 1 if chunks[cx][cy][cz].counter >= CS_3D then + current_chunks[#current_chunks+1] = { x = cx, y = cy, z = cz, s = chunks[cx][cy][cz].seed } -- this chunk shouldn't be overwritten anymore, no need to keep it in memory - local chunkseed = chunks[cx][cy][cz].seed - process_generated_chunk(cx, cy, cz, chunkseed) - chunks[cx][cy][cz] = nil if next(chunks[cx][cy]) == nil then chunks[cx][cy] = nil end if next(chunks[cx]) == nil then chunks[cx] = nil end @@ -196,15 +197,23 @@ minetest.register_on_generated(function(minp, maxp, blockseed) vm:update_liquids() end - for _, v in pairs(node_chunk_queue) do - v.f(minp, maxp, blockseed) + for i, b in pairs(current_chunks) do + local cx, cy, cz, seed = b.x, b.y, b.z, b.s + local bx, by, bz = cx * CS + offset, cy * CS + offset, cz * CS + offset + local x, y, z = bx * BS, by * BS, bz * BS + local minp = {x = x, y = y, z = z} + local maxp = {x = x + CS_NODES - 1, y = y + CS_NODES - 1, z = z + CS_NODES - 1} + for _, v in pairs(node_chunk_queue) do + v.f(minp, maxp, seed) + end + current_chunks[i] = nil end for i, b in pairs(current_blocks) do for _, v in pairs(node_block_queue) do v.f(b.minp, b.maxp, b.seed) end - current_blocks[id] = nil + current_blocks[i] = nil end end) diff --git a/mods/MAPGEN/mcl_dungeons/init.lua b/mods/MAPGEN/mcl_dungeons/init.lua index d2458939e..a24e4dc9d 100644 --- a/mods/MAPGEN/mcl_dungeons/init.lua +++ b/mods/MAPGEN/mcl_dungeons/init.lua @@ -14,7 +14,7 @@ local swap_node = minetest.swap_node local set_node = minetest.set_node local dir_to_facedir = minetest.dir_to_facedir local get_meta = minetest.get_meta -local emerge_area = minetest.emerge_area +-- local emerge_area = minetest.emerge_area --vector local vector_add = vector.add @@ -61,12 +61,14 @@ local surround_vectors = { { x=0, y=0, z=1 }, } -local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param) - if calls_remaining >= 1 then return end +--local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param) +-- if calls_remaining >= 1 then return end +-- local p1, _, dim, pr = param.p1, param.p2, param.dim, param.pr +-- local check = not (param.dontcheck or false) +local function spawn_dungeon(p1, p2, dim, pr, dontcheck) - local p1, _, dim, pr = param.p1, param.p2, param.dim, param.pr local x, y, z = p1.x, p1.y, p1.z - local check = not (param.dontcheck or false) + local check = not (dontcheck or false) -- Check floor and ceiling: Must be *completely* solid local y_floor = y @@ -401,8 +403,9 @@ local function dungeons_nodes(minp, maxp, blockseed) local z = pr:next(minp.z, maxp.z-dim.z-1) local p1 = {x=x,y=y,z=z} local p2 = {x = x+dim.x+1, y = y+dim.y+1, z = z+dim.z+1} - minetest.log("verbose","[mcl_dungeons] size=" ..minetest.pos_to_string(dim) .. ", emerge from "..minetest.pos_to_string(p1) .. " to " .. minetest.pos_to_string(p2)) - emerge_area(p1, p2, ecb_spawn_dungeon, {p1=p1, p2=p2, dim=dim, pr=pr}) + -- minetest.log("verbose","[mcl_dungeons] size=" ..minetest.pos_to_string(dim) .. ", emerge from "..minetest.pos_to_string(p1) .. " to " .. minetest.pos_to_string(p2)) + -- emerge_area(p1, p2, ecb_spawn_dungeon, {p1=p1, p2=p2, dim=dim, pr=pr}) + spawn_dungeon(p1, p2, dim, pr) end end @@ -410,8 +413,9 @@ function mcl_dungeons.spawn_dungeon(p1, _, pr) if not p1 or not pr or not p1.x or not p1.y or not p1.z then return end local dim = dungeonsizes[pr:next(1, #dungeonsizes)] local p2 = {x = p1.x+dim.x+1, y = p1.y+dim.y+1, z = p1.z+dim.z+1} - minetest.log("verbose","[mcl_dungeons] size=" ..minetest.pos_to_string(dim) .. ", emerge from "..minetest.pos_to_string(p1) .. " to " .. minetest.pos_to_string(p2)) - emerge_area(p1, p2, ecb_spawn_dungeon, {p1=p1, p2=p2, dim=dim, pr=pr, dontcheck=true}) +-- minetest.log("verbose","[mcl_dungeons] size=" ..minetest.pos_to_string(dim) .. ", emerge from "..minetest.pos_to_string(p1) .. " to " .. minetest.pos_to_string(p2)) +-- emerge_area(p1, p2, ecb_spawn_dungeon, {p1=p1, p2=p2, dim=dim, pr=pr, dontcheck=true}) + spawn_dungeon(p1, p2, dim, pr, true) end mcl_mapgen.register_chunk_generator(dungeons_nodes, 999999) diff --git a/mods/MAPGEN/mcl_villages/init.lua b/mods/MAPGEN/mcl_villages/init.lua index f1b1de906..2b7109451 100644 --- a/mods/MAPGEN/mcl_villages/init.lua +++ b/mods/MAPGEN/mcl_villages/init.lua @@ -1,6 +1,8 @@ settlements = {} settlements.modpath = minetest.get_modpath("mcl_villages") +local minetest_get_spawn_level = minetest.get_spawn_level + dofile(settlements.modpath.."/const.lua") dofile(settlements.modpath.."/utils.lua") dofile(settlements.modpath.."/foundation.lua") @@ -53,6 +55,7 @@ end -- on map generation, try to build a settlement -- local function build_a_settlement(minp, maxp, blockseed) + minetest.log("action","[mcl_villages] Building village at mapchunk " .. minetest.pos_to_string(minp) .. "..." .. minetest.pos_to_string(maxp) .. ", blockseed = " .. tostring(blockseed)) local pr = PseudoRandom(blockseed) -- fill settlement_info with buildings and their data @@ -69,28 +72,36 @@ local function build_a_settlement(minp, maxp, blockseed) settlements.place_schematics(settlement_info, pr) end -local function ecb_village(blockpos, action, calls_remaining, param) - if calls_remaining >= 1 then return end - local minp, maxp, blockseed = param.minp, param.maxp, param.blockseed - build_a_settlement(minp, maxp, blockseed) -end - -- Disable natural generation in singlenode. local mg_name = minetest.get_mapgen_setting("mg_name") if mg_name ~= "singlenode" then mcl_mapgen.register_chunk_generator(function(minp, maxp, blockseed) + -- local str1 = (maxp.y >= 0 and blockseed % 77 == 17) and "YES" or "no" + -- minetest.log("action","[mcl_villages] " .. str1 .. ": minp=" .. minetest.pos_to_string(minp) .. ", maxp=" .. minetest.pos_to_string(maxp) .. ", blockseed=" .. tostring(blockseed)) -- don't build settlement underground if maxp.y < 0 then return end -- randomly try to build settlements if blockseed % 77 ~= 17 then return end - -- needed for manual and automated settlement building + -- don't build settlements on (too) uneven terrain - --local heightmap = minetest.get_mapgen_object("heightmap") - local height_difference = settlements.evaluate_heightmap() + + -- lame and quick replacement of `heightmap` by kay27 - we maybe need to restore `heightmap` analysis if there will be a way for the engine to avoid cavegen conflicts: + -------------------------------------------------------------------------- + local height_difference, min, max + local pr1=PseudoRandom(blockseed) + for i=1,pr1:next(5,10) do + local x = pr1:next(0, 40) + minp.x + 19 + local z = pr1:next(0, 40) + minp.z + 19 + local y = minetest_get_spawn_level(x, z) + if y < (min or y+1) then min = y end + if y > (max or y-1) then max = y end + end + height_difference = max - min + 1 + -------------------------------------------------------------------------- + if height_difference > max_height_difference then return end - local param={minp=vector.new(minp), maxp=vector.new(maxp), blockseed=blockseed} - minetest.emerge_area(minp, maxp, ecb_village, param) + build_a_settlement(minp, maxp, blockseed) end) end -- manually place villages diff --git a/mods/MAPGEN/mcl_villages/utils.lua b/mods/MAPGEN/mcl_villages/utils.lua index 87473cc80..1d94ead0c 100644 --- a/mods/MAPGEN/mcl_villages/utils.lua +++ b/mods/MAPGEN/mcl_villages/utils.lua @@ -207,44 +207,6 @@ function shuffle(tbl, pr) return table end ------------------------------------------------------------------------------- --- evaluate heightmap -------------------------------------------------------------------------------- -function settlements.evaluate_heightmap() - local heightmap = minetest.get_mapgen_object("heightmap") - -- max height and min height, initialize with impossible values for easier first time setting - local max_y = -50000 - local min_y = 50000 - -- only evaluate the center square of heightmap 40 x 40 - local square_start = 1621 - local square_end = 1661 - for j = 1 , 40, 1 do - for i = square_start, square_end, 1 do - -- skip buggy heightmaps, return high value - if heightmap[i] == -31000 or heightmap[i] == 31000 then - return max_height_difference + 1 - end - if heightmap[i] < min_y then - min_y = heightmap[i] - end - if heightmap[i] > max_y then - max_y = heightmap[i] - end - end - -- set next line - square_start = square_start + 80 - square_end = square_end + 80 - end - -- return the difference between highest and lowest pos in chunk - local height_diff = max_y - min_y - -- filter buggy heightmaps - if height_diff <= 1 then - return max_height_difference + 1 - end - -- debug info - settlements.debug("heightdiff ".. height_diff) - return height_diff -end -------------------------------------------------------------------------------- -- Set array to list -- https://stackoverflow.com/questions/656199/search-for-an-item-in-a-lua-list ------------------------------------------------------------------------------- From fd56bb746cd2cf0d146eee813ff41451bcfce2d0 Mon Sep 17 00:00:00 2001 From: kay27 Date: Sun, 2 May 2021 04:25:23 +0400 Subject: [PATCH 11/21] [mapgen] Spawn strongholds without emerge areas --- mods/MAPGEN/mcl_dungeons/init.lua | 5 ----- mods/MAPGEN/mcl_structures/init.lua | 4 +++- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/mods/MAPGEN/mcl_dungeons/init.lua b/mods/MAPGEN/mcl_dungeons/init.lua index a24e4dc9d..03a5c4e07 100644 --- a/mods/MAPGEN/mcl_dungeons/init.lua +++ b/mods/MAPGEN/mcl_dungeons/init.lua @@ -14,7 +14,6 @@ local swap_node = minetest.swap_node local set_node = minetest.set_node local dir_to_facedir = minetest.dir_to_facedir local get_meta = minetest.get_meta --- local emerge_area = minetest.emerge_area --vector local vector_add = vector.add @@ -403,8 +402,6 @@ local function dungeons_nodes(minp, maxp, blockseed) local z = pr:next(minp.z, maxp.z-dim.z-1) local p1 = {x=x,y=y,z=z} local p2 = {x = x+dim.x+1, y = y+dim.y+1, z = z+dim.z+1} - -- minetest.log("verbose","[mcl_dungeons] size=" ..minetest.pos_to_string(dim) .. ", emerge from "..minetest.pos_to_string(p1) .. " to " .. minetest.pos_to_string(p2)) - -- emerge_area(p1, p2, ecb_spawn_dungeon, {p1=p1, p2=p2, dim=dim, pr=pr}) spawn_dungeon(p1, p2, dim, pr) end end @@ -413,8 +410,6 @@ function mcl_dungeons.spawn_dungeon(p1, _, pr) if not p1 or not pr or not p1.x or not p1.y or not p1.z then return end local dim = dungeonsizes[pr:next(1, #dungeonsizes)] local p2 = {x = p1.x+dim.x+1, y = p1.y+dim.y+1, z = p1.z+dim.z+1} --- minetest.log("verbose","[mcl_dungeons] size=" ..minetest.pos_to_string(dim) .. ", emerge from "..minetest.pos_to_string(p1) .. " to " .. minetest.pos_to_string(p2)) --- emerge_area(p1, p2, ecb_spawn_dungeon, {p1=p1, p2=p2, dim=dim, pr=pr, dontcheck=true}) spawn_dungeon(p1, p2, dim, pr, true) end diff --git a/mods/MAPGEN/mcl_structures/init.lua b/mods/MAPGEN/mcl_structures/init.lua index 8304061af..617c19d46 100644 --- a/mods/MAPGEN/mcl_structures/init.lua +++ b/mods/MAPGEN/mcl_structures/init.lua @@ -33,7 +33,9 @@ mcl_structures.place_schematic = function(pos, schematic, rotation, replacements local p2 = {x=pos.x+x-1, y=pos.y+s.size.y-1, z=pos.z+z-1} minetest.log("verbose","[mcl_structures] size=" ..minetest.pos_to_string(s.size) .. ", rotation=" .. tostring(rotation) .. ", emerge from "..minetest.pos_to_string(p1) .. " to " .. minetest.pos_to_string(p2)) local param = {pos=vector.new(pos), schematic=s, rotation=rotation, replacements=replacements, force_placement=force_placement, flags=flags, p1=p1, p2=p2, after_placement_callback = after_placement_callback, size=vector.new(s.size), pr=pr, callback_param=callback_param} - minetest.emerge_area(p1, p2, ecb_place, param) + -- minetest.emerge_area(p1, p2, ecb_place, param) + -- TODO: Make it better + ecb_place(0, 0, 0, param) end end From 238eb6cb6823ffe1bb35ca1f4cf54a3fb0d7903f Mon Sep 17 00:00:00 2001 From: kay27 Date: Sun, 2 May 2021 13:29:29 +0400 Subject: [PATCH 12/21] [mapgen] Comment complex part of the code --- mods/CORE/mcl_mapgen/init.lua | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/mods/CORE/mcl_mapgen/init.lua b/mods/CORE/mcl_mapgen/init.lua index 5be3ac488..f89eeabf9 100644 --- a/mods/CORE/mcl_mapgen/init.lua +++ b/mods/CORE/mcl_mapgen/init.lua @@ -46,7 +46,7 @@ local CS_NODES = mcl_mapgen.CS_NODES -- 80 local CS_3D = CS * CS * CS -local DEFAULT_PRIORITY = 5000 +local DEFAULT_PRIORITY = 5000 function mcl_mapgen.register_chunk_generator(callback_function, priority) nodes_chunk = nodes_chunk + 1 @@ -125,6 +125,12 @@ minetest.register_on_generated(function(minp, maxp, blockseed) local cx = math_floor(block_pos_offset_removed / CS) box = block_pos_offset_removed % CS if not blocks[bx] then blocks[bx]={} end + + -- We don't know how many calls, including this one, will overwrite this block's content! + -- Start calculating it with `total_mapgen_block_writes_through_x` variable. + -- It can be `8 or less`, if we (speaking of `x` axis) are on chunk edge now, + -- or it can be `4 or less` - if we are in the middle of the chunk by `x` axis: + local total_mapgen_block_writes_through_x = (box > 0 and box < LAST_BLOCK) and 4 or 8 while y < y2 do by = math_floor(y/BS) @@ -132,14 +138,34 @@ minetest.register_on_generated(function(minp, maxp, blockseed) local cy = math_floor(block_pos_offset_removed / CS) boy = block_pos_offset_removed % CS if not blocks[bx][by] then blocks[bx][by]={} end + + -- Here we just divide `total_mapgen_block_writes_through_x` by 2, + -- if we are (speaking of `y` axis now) in the middle of the chunk now. + -- Or we don't divide it, if not. + -- So, basing on `total_mapgen_block_writes_through_x`, + --- we calculate `total_mapgen_block_writes_through_y` this way: + local total_mapgen_block_writes_through_y = (boy > 0 and boy < LAST_BLOCK) and math_floor(total_mapgen_block_writes_through_x / 2) or total_mapgen_block_writes_through_x while z < z2 do bz = math_floor(z/BS) block_pos_offset_removed = bz - offset local cz = math_floor(block_pos_offset_removed / CS) boz = block_pos_offset_removed % CS + + -- Now we do absolutely the same for `z` axis, basing on our previous result + -- from `total_mapgen_block_writes_through_y` variable. + -- And our final result is in `total_mapgen_block_writes`. + -- It can be still 8, derived from `x` calculation, but it can be less! + -- It can be even 1, if we are in safe 3x3x3 area of mapchunk: + local total_mapgen_block_writes = (boz > 0 and boz < LAST_BLOCK) and math_floor(total_mapgen_block_writes_through_y / 2) or total_mapgen_block_writes_through_y + + -- Get current number of writes from the table, or just set it to 1, if accessed first time: + local current_mapgen_block_writes = blocks[bx][by][bz] and (blocks[bx][by][bz] + 1) or 1 + + -- And compare: + if current_mapgen_block_writes == total_mapgen_block_writes then -- this block shouldn't be overwritten anymore, no need to keep it in memory blocks[bx][by][bz] = nil From 16700632afc074410db87e5f47f99dc663f906f9 Mon Sep 17 00:00:00 2001 From: kay27 Date: Sun, 2 May 2021 23:18:03 +0400 Subject: [PATCH 13/21] [mapgen] [debug] Add blockseed calculation functions --- mods/CORE/mcl_mapgen/init.lua | 54 ++++++++++++++++++++++++++--------- 1 file changed, 40 insertions(+), 14 deletions(-) diff --git a/mods/CORE/mcl_mapgen/init.lua b/mods/CORE/mcl_mapgen/init.lua index f89eeabf9..9c6fb8a11 100644 --- a/mods/CORE/mcl_mapgen/init.lua +++ b/mods/CORE/mcl_mapgen/init.lua @@ -35,6 +35,18 @@ mcl_mapgen.EDGE_MAX = central_chunk_max_pos + numcmax * mcl_mapgen.CS_NODES minetest_log("action", "[mcl_mapgen] World edges are: mcl_mapgen.EDGE_MIN = " .. tostring(mcl_mapgen.EDGE_MIN) .. ", mcl_mapgen.EDGE_MAX = " .. tostring(mcl_mapgen.EDGE_MAX)) ------------------------------------------ +-- Mapgen variables +local overworld, end_, nether = {}, {}, {} +mcl_mapgen.seed = minetest.get_mapgen_setting("seed") +mcl_mapgen.name = minetest.get_mapgen_setting("mg_name") +mcl_mapgen.v6 = mcl_mapgen.name == "v6" +mcl_mapgen.superflat = mcl_mapgen.name == "flat" and minetest.get_mapgen_setting("mcl_superflat_classic") == "true" +mcl_mapgen.singlenode = mcl_mapgen.name == "singlenode" +mcl_mapgen.normal = not mcl_mapgen.superflat and not mcl_mapgen.singlenode +local superflat, singlenode, normal = mcl_mapgen.superflat, mcl_mapgen.singlenode, mcl_mapgen.normal + +minetest_log("action", "[mcl_mapgen] Mapgen mode: " .. (normal and "normal" or (superflat and "superflat" or "singlenode"))) +------------------------------------------ local lvm_block_queue, lvm_chunk_queue, node_block_queue, node_chunk_queue = {}, {}, {}, {} -- Generators' queues local lvm, block, lvm_block, lvm_chunk, param2, nodes_block, nodes_chunk, safe_functions = 0, 0, 0, 0, 0, 0, 0, 0 -- Requirements: 0 means none; greater than 0 means 'required' @@ -74,6 +86,33 @@ function mcl_mapgen.register_block_generator_lvm(callback_function, priority) table.sort(lvm_block_queue, function(a, b) return (a.i <= b.i) end) end +function mcl_mapgen.get_block_seed(pos, seed) + local p = pos + local x, y, z = p.x, p.y, p.z + if x<0 then x = 4294967296+x end + if y<0 then y = 4294967296+y end + if z<0 then z = 4294967296+z end + local seed = (seed or mcl_mapgen.seed or 0) % 4294967296 + return (seed + (z*38134234)%4294967296 + (y*42123)%4294967296 + (x*23)%4294967296) % 4294967296 +end + +function mcl_mapgen.get_block_seed_2(pos, seed) + local p = pos + local seed = seed or mcl_mapgen.seed or 0 + local x, y, z = p.x, p.y, p.z + if x<0 then x = 4294967296+x end + if y<0 then y = 4294967296+y end + if z<0 then z = 4294967296+z end + local n = ((1619*x)%4294967296 + (31337*y)%4294967296 + (52591*z)%4294967296 + (1013*seed)%4294967296) % 4294967296 +-- n = (math_floor(n / 8192) ^ n) % 4294967296 + + local m = (n*n) % 4294967296 + m = (m*60493) % 4294967296 + m = (m+19990303) % 4294967296 + + return (n * m + 1376312589) % 4294967296 +end + local storage = minetest.get_mod_storage() local blocks = minetest.deserialize(storage:get_string("mapgen_blocks") or "return {}") or {} local chunks = minetest.deserialize(storage:get_string("mapgen_chunks") or "return {}") or {} @@ -90,7 +129,7 @@ local current_chunks = {} minetest.register_on_generated(function(minp, maxp, blockseed) local minp, maxp, blockseed = minp, maxp, blockseed local vm, emin, emax = minetest.get_mapgen_object("voxelmanip") - minetest_log("warning", "[mcl_mapgen] New_chunk=" .. minetest_pos_to_string(minp) .. "..." .. minetest_pos_to_string(maxp) .. ", shell=" .. minetest_pos_to_string(emin) .. "..." .. minetest_pos_to_string(emax) .. ", blockseed=" .. tostring(blockseed)) + minetest_log("warning", "[mcl_mapgen] New_chunk=" .. minetest_pos_to_string(minp) .. "..." .. minetest_pos_to_string(maxp) .. ", shell=" .. minetest_pos_to_string(emin) .. "..." .. minetest_pos_to_string(emax) .. ", blockseed=" .. tostring(blockseed) .. ", seed1=" .. mcl_mapgen.get_block_seed(minp) .. ", seed2=" .. mcl_mapgen.get_block_seed_2(minp)) if lvm > 0 then vm_context = {lvm_param2_buffer = lvm_param2_buffer, vm = vm, emin = emin, emax = emax, minp = minp, maxp = maxp, blockseed = blockseed} @@ -289,19 +328,6 @@ function mcl_mapgen.get_chunk_number(pos) -- unsigned int c.x + k_positive end - --- Mapgen variables -local overworld, end_, nether = {}, {}, {} -mcl_mapgen.seed = minetest.get_mapgen_setting("seed") -mcl_mapgen.name = minetest.get_mapgen_setting("mg_name") -mcl_mapgen.v6 = mcl_mapgen.name == "v6" -mcl_mapgen.superflat = mcl_mapgen.name == "flat" and minetest.get_mapgen_setting("mcl_superflat_classic") == "true" -mcl_mapgen.singlenode = mcl_mapgen.name == "singlenode" -mcl_mapgen.normal = not mcl_mapgen.superflat and not mcl_mapgen.singlenode -local superflat, singlenode, normal = mcl_mapgen.superflat, mcl_mapgen.singlenode, mcl_mapgen.normal - -minetest_log("action", "[mcl_mapgen] Mapgen mode: " .. (normal and "normal" or (superflat and "superflat" or "singlenode"))) - mcl_mapgen.minecraft_height_limit = 256 mcl_mapgen.bedrock_is_rough = normal From 66d117285254ee387822a73c4343177aea179e22 Mon Sep 17 00:00:00 2001 From: kay27 Date: Mon, 3 May 2021 05:24:53 +0400 Subject: [PATCH 14/21] [mapgen] Add ocean monument --- mods/CORE/mcl_mapgen/init.lua | 6 +++ mods/MAPGEN/mcl_ocean_monument/init.lua | 36 ++++++++++++++++++ mods/MAPGEN/mcl_ocean_monument/mod.conf | 4 ++ .../schematics/ocean_monument.mts | Bin 0 -> 8342 bytes mods/MAPGEN/mcl_villages/init.lua | 1 + 5 files changed, 47 insertions(+) create mode 100644 mods/MAPGEN/mcl_ocean_monument/init.lua create mode 100644 mods/MAPGEN/mcl_ocean_monument/mod.conf create mode 100644 mods/MAPGEN/mcl_ocean_monument/schematics/ocean_monument.mts diff --git a/mods/CORE/mcl_mapgen/init.lua b/mods/CORE/mcl_mapgen/init.lua index 9c6fb8a11..a5982ae4e 100644 --- a/mods/CORE/mcl_mapgen/init.lua +++ b/mods/CORE/mcl_mapgen/init.lua @@ -1,5 +1,9 @@ mcl_mapgen = {} +local priority = { + OCEAN_MONUMENT = 1000000 +} + local math_floor = math.floor local math_max = math.max local minetest_get_node = minetest.get_node @@ -398,3 +402,5 @@ mcl_mapgen.dungeons = normal mcl_mapgen.overworld = overworld mcl_mapgen.end_ = end_ mcl_mapgen.nether = nether + +mcl_mapgen.priorities = priority diff --git a/mods/MAPGEN/mcl_ocean_monument/init.lua b/mods/MAPGEN/mcl_ocean_monument/init.lua new file mode 100644 index 000000000..135e315bd --- /dev/null +++ b/mods/MAPGEN/mcl_ocean_monument/init.lua @@ -0,0 +1,36 @@ +local mcl_mapgen_get_far_node = mcl_mapgen.get_far_node +local minetest_log = minetest.log +local minetest_place_schematic = minetest.place_schematic +local minetest_pos_to_string = minetest.pos_to_string + +local path = minetest.get_modpath("mcl_ocean_monument") .. "/schematics/ocean_monument.mts" +local water, air = "mcl_core:water_source", "air" + +mcl_mapgen.register_chunk_generator(function(minp, maxp, seed) + local minp = minp + local y = minp.y + if y ~= -32 then return end + + local x, z = minp.x, minp.z + local pr = PseudoRandom(seed) + for i = 1, pr:next(10,100) do + if mcl_mapgen_get_far_node({x=pr:next(0,79)+x, y=1, z=pr:next(0,79)+z}).name ~= water then return end + end + for i = 1, pr:next(10,100) do + if mcl_mapgen_get_far_node({x=pr:next(0,79)+x, y=2, z=pr:next(0,79)+z}).name ~= air then return end + end + for i = 1, pr:next(10,100) do + if mcl_mapgen_get_far_node({x=pr:next(15,64)+x, y=pr:next(0,25)-25, z=pr:next(15,64)+z}).name ~= water then +-- minetest_log("warning", "[mcl_ocean_monument] Not water at " .. minetest_pos_to_string(minp)) + return + end + end + +-- minetest_place_schematic(minp, path, tostring(pr:next(0,3)*90), nil, true) + minetest_place_schematic(minp, path, 0, nil, true) + + minetest_log("action", "[mcl_ocean_monument] Placed at " .. minetest_pos_to_string(minp)) + + ---- TODO: SET UP SPECIAL NODES... + +end, mcl_mapgen.priorities.OCEAN_MONUMENT) diff --git a/mods/MAPGEN/mcl_ocean_monument/mod.conf b/mods/MAPGEN/mcl_ocean_monument/mod.conf new file mode 100644 index 000000000..62648e987 --- /dev/null +++ b/mods/MAPGEN/mcl_ocean_monument/mod.conf @@ -0,0 +1,4 @@ +name = mcl_ocean_monument +author = Sister of epCode +description = Adds Ocean Monument, https://git.minetest.land/MineClone2/MineClone2/issues/958#issuecomment-14102 +depends = mcl_mapgen, mcl_structures diff --git a/mods/MAPGEN/mcl_ocean_monument/schematics/ocean_monument.mts b/mods/MAPGEN/mcl_ocean_monument/schematics/ocean_monument.mts new file mode 100644 index 0000000000000000000000000000000000000000..f94b808b521a431c82d0ed5a708156daf748171b GIT binary patch literal 8342 zcmaKRcU)7+yLa3*t8TEMNU#73i--h+K$I3(lqwyhgg`)gZ&4vsH)}y!%!(ip0wTR? z=#YT10Ma28DFV_WHMAsz2)qaP_rCY@dGGz)`6HQgX6BjaJpDUke9O`pv>&7j5(lY9 z|L+ZS5cKP9uVBz=KNnxe02jC0{;Gk&URb}|!CwAuj?TeeEVJCc=z2TY z2PC~WguMgM#j0X`Z#z5w|0Eq<1MWKex`9sq7Y(f2ZAahR{&(Dh{Xxfnt`7|G_izIU z{QUp-ol8Klo2o~EudB0ffQwIP+ERKPeiBx$sAIH6AJHWlmP;D6S_Ef&#WizC9|~{c{0}U{c&b` z4+9$(wTPb;&CXqxBeQ4=;RDe(q&RpVQO=;{U>|kj!^^d{W6N&|P=T^5N%N^U$fmf5 zy55hNd3Q7nLwI#AFS+;zZkzas1yX!W!xA0O)BXkYjvMp{s(r#(sjLK-4Bcq6yc9&v z$Y-&f+3bR)k_86o74%NqRM=ypA3L5lAxSdviWh;#w?Vy=BT|d={Orv}-e;8i3?x8? znGDk4I{wu{dYyWT5;h|-=!@YOo0FPH05vm%9~@00KqaY8UiN_xpcRRbx*0w#^RE5M zGDiL^G=7c+E}6nBIF~_P?T_u5MdzduyoNhwfDX9I1g~?2yty&My4OZE2n8OCVAfrN z=a}LgMn*&PE;pts+R-dA`FUbVC0UZ@6ndocA3Ob}ysoi5)0xmuFzh~R=IqiP)hT*3J=Hddx71tl zGC|CnTSZYM#1WxA=E)n_P|jn{;VS5`Cnf+cGU)h{H3udXdd!LSkV(TD>y7Tu2JSF$ zDLLbkc6M1AU4eDK`5+s+Aj@SQD1_LcxTUEhJ3nk7{})h2kgII4Zrj5PB+n`@v8jDI zq<+cI$J@pwL;-spCFH5}Lh5R(!kREEg2pLIg9!gcc(jI;H6dwW@mrfO6Wf0lm}eiV z(Tt;SNY`$>RFU~A6KeCFtnE|V+ITprH$s~sGk%iXh{UX%C#Totki)4?qZ(g25tw5j zJC(e$+IG>`wU=H45$I}%8jfC*;#uZb1Wh98;poX>%WQm9G*<-veUP!Mwz`Vt*JQqI z+pUU!sKG9N-6Wn}wRB^yu3sa-(Yl{A7p0c(h>W!ANH6W$ZUzHUq}FuI9CZkkII&JU zNAk=<<>8?4nzAZCOkl?3T3r`pm~ed&+{TT$*%7!Ti0RJIbOuatR+Q>AB9dp8Ty6|3Md2ke~A#P0Kvjj!CYFUhIE^I3ivg6;#mVDC1s$oG|rFN`6Lg@{p zIRDzOfO7Afx)k#b*|sSSMhyYx%a$WSAtD0_vOkOf3SS*fi{eaJj9eLhz2*q%N73t@ zfDRT{KSv{o7g2@Nsy^U1uMU3^wQ&ZTgm{AdhZ;g*)=a!_gFI>!Ra_J6nL+Wh(<2F< zjV=p5jbdFN*Du0j`1?U1WkNZ1B949YPRk94^13Xyy5-9SNQ^v{+d13D!D;19CR!hs z!*pv_HHT_BFihg00$m<7cN%mwT7w%szh$|I{c z>7Y2l21^&(z$lNl%^>>~&rfc$$`rQW@ zGfuemdkyRF;06ATZ?>^lPY#ynLHqJLSM_-cWu&h6MSV$3MKUE+N3-ebPC>YMG%D5{ zBQLHw%g6KNnnxu`E=kb#00f}KBpK=s552jL4_BJn`Lxbb#R?qMG|jm!!wQrr>i3EiEdIpyDnJ_sXE@-A9Lr?#Dr)OBPa_k7%jq5c8V zQ031nAtC{pyq*S+-0~CqOc*Mf_t{~MOLFi>uZVKZybT4z=(Y^exb7RsTrrHiMwR9y z>F?aR&XAYTJ`r=%mrx^I3OVW%2jif`2SQx$;sSAcHGX@d?vo%UkcR$RB90?`zv0JC zJPoZVIh7L&eGtAPNnW5svH&I;E?~ONw}BpLy#?>u(U2L zHPia|HAE9+_Ld_?{)a}krl!BWnF)6-qi&waRP5{IQB2qIwfD{dSrDz<47t3>K5}mh zM?d{(rgE{Zb?jABq&GhX(T3?3m!6ve&s=1fW4a^Dca`B^s>#;TD=#L^bKJb!xnKlg zdRA{#a(LV$oIQ)sH(aI7}{%y=oN)Etaj8l5p(03bze=Fv6VmBQ*~)IJ}7c zBU|foA6Xx78CUYiQ}|_m{m$B3%*yw$%i$H3xwM{6|K-TTppcms(~9w^2+C|>`~^}- zUmuMgqqoU3;$DMA&JPba>@c^igjr^JHPnHy!q5hjp4>wIL1+M1Og5Ar#2#gV`3aD% z43Fv`f*stmP$QaYbC?zy*|mb-Q~-H`;mX&sR=OuT)V#?|uuoe)E_)OsHr6)@HUtXq zj&0FbchfiUQZURL`!2nTKlB;`hGxNr#UAtotp}tihxg1H>#Fr3zF5!kIL%LGu5Jk3~plN%ThV`ux#~b{)HvvyQIdEos@zvkO5AWjj^8(8o7#JD%9IjD3bk< z0{F>0huRG29rPmtJLNZixK>C-Z)D>bMt<~}i6h*T5m5*PiSKZqB9HXk=#0sLI~qPG z{V?6*rpg)jl;$XDQ{YO|9w7ER{s!>Yol#D6;*A;9Lyfq<1HxdyA|2oKLy{K?Sklzp zE7l2l5$sW97QsM#%10bJYS~52tMt3315u?MBgO!^|&1KzS$#0yR9AEE`A4p^QwpR$Gk|&%89x6lectBhW(|3$|N8i9tuv zT_Vx;@-tb%1i>l%>vUfB6 z&)Fi}VYo=Lyv^k1?QKzWgU_9HSKf0_aC28Ip+jw#+f?`h~)2s^Y_ zNJknEeGsSpu>^J`Y_N=4Ppc{s9PJGHoK<$0V2lKNrS52vG`5QcR@mFAY z!tNt2Y1Ob>`$WfrkJtj35WTl30=fPps(@UhJAJ397o$c=KoUV955}0cF3$r!X{}?J z{KWOopviSf4vQYWK=*~4-02anm!ZdScU)a`?Ifh52_uUY-m;rS zdY%2WdS$Y;+yPJoBBb71Z@Q-C>ZJXJ(;s^AQ7-AWkRPk=7Qwj zvB}d+Lt*u`kW)4rGdB)ZeU)wQ8SbL_o> z8v9X;p?yxr8}NsPM*-pe*uDS0{hjH);N$ z70&_gJ%)AvPb$U;L3>Oe?0V47*l|`DL~xkpT!x4(kbrMu$tVlf~}%+^tt@&Ute8G zQa=Jx^U}Xxo?({NlmvTGYI=F?2kand<*w2n?}ns=xRcDPN@E)mN)uwO?XOa3&2ZCd zTv^?Bto)>n_TR1+K{|Z|0m_7PTUPHS;&!>y%q$3WEvN8v-^iyW1V?VTt=?_?Y&sGU zMD(*{eFUTl0Gq}&O-5eTE|-o57-uhoPY^#Zx~h1{R5^dz_ps%k2C3tqiNIE4_qRIF z%M4}H1GZ)hu2`s6X71;;C_~&O_H-vKBS40G#0l7tB%Yl_kb7^r220=Uh<{~84C^rl z%+@dIrI8_a-j|GkRB2yEy*UqTU!`AtF|S~@sAknv*ZZWLj{A}2?B~*VhZQRHOq?05 zElAWGx%{r zouvl1+|K+oEw5HQ)>7Esan@ib?iU5(p?lhe(uE3Y7d@0ya8qU|L7(h{>CCzo2UK9< z4jpQ?F1-5s^axs_>~w9MpDEo3bM+Y*^4AQ^b_I`ld!w=UDR_G@DR{ialH&BLBFM9* z{rD+YI!T{;uCJFP>=lg_#LcuMzHmjOi&5}(>r_8UIWvfZB;&DU<%M`7VcegthQfWE z?50w<^GHn}ZhpStBn^WtgZd`yzdvH>uYfJ_%4*h3DUH$n+$y9}MjvW%#lBdR#?+tL zf$PLVD_hhgKQYdux|dwPGWa<1qK)>pg|+t9;CDj3#A&?|$-LP=K{fklE+`JZXw~&5 zPf@cBXUiwjF87^Ii*3KAeS?z8M4v_|61|0C1LYBuu@6vYCB~{1atbYY1hKx{DXdh8 zly)V*D(NJs&SH<9f|O^|thDLiR5JKOi$RzEO<{q`m%M*k|8ejfD3++V>` zyaH7(;q8M+K$#t_bfs(mHKmU(!eMsQRUvih#o-ipEzJr!%6Uj#cU72wkMmJ+GT4JP zGfxD4khzvxaCDgJrZxEdXsL6KWomsZQ~jgeSwrEZq4UN1b%nRHEBlQc(l-V?C{F0? z_VYn=-jqy)g?|#PM5aP6*dpS~ZIqcduqkR`H1)biPJqo3zb^c>50RmDtXkf8K^~5% zv(aL&Yj@2c#-xOZ4u5;H=qjXD->2x5-j>wZDX-29>y8@C`tZ=jiq(;CWqkr%^Vf5a zw>o!Tz?92Sfg>r1;NQFKbTU(}e#RRVszEO+M2Ft1AT8-gti=+SQ1T7ILbD3tK_$dF zn5_oLPFUc`eHDufYd=^uA`*(I?vZCGMb&79`dgv&&uWDT;HXijp{+Lkd2CDOK&A2M zV)T>BtB`p`#4A_&J|U70C4w1lChdI>{sAA5zYICf3nHqOXNLYB zj8Z5H)k5rT=r3FW^UTjXJ(m*d;d%kGrPoq;YH*=MlPRh5ThV_$#h-}&Y)qU#GbGIG ztdz)9g>(kzUb;2s_vLz#EDrs9Eey&#{P+Ne0jQ_i>#p#qol0sOg@sv8T;&v}Ty=!k zLw#dMDNd2oB=8xD5I4G42Yy7bTJQG-^jG^h!cmm`L;eaV{oEi#n;^F_c|W6pgPeKZPKMJ zQSk5g-gMYqA5jVqrT5v_wm&)bx3?i`U#9Gyza=LRhdT8B17`o3gG9`j2E^6Ok5G}2 zFo*kvFkA6jcP(u8xAx~TluSdfWV7(jBR58rxE}O@mI9SyCb>%yl^I?VWoL)LyxdC; zyWa6aHYGnoPZcaVb>QbHc>{R^`$;EH&Bg17V}_1o37ssPYcU(Q8`k#BnQefzI9hMr z95&h5Qc+b3=Is|$xkO1{i8UGJK#M9E&QM?dr6KGm3Sn9 z>WHbeaaD_*RpFm+m{Kb1rB1(vu0Ue5wfp}92V79Rp?pla9Sm6zX zPw>#D{)beMVrgB|1>@iS{-hclx^U<<;rMPmaqN!fZN&bS;z; zh@ainE{da$ft>b&CL?*4l3BIR?Y%B+FX?uE{I7?w8vj2Qn8`DgOyRi_b49dCxs*Z% z`0p0i+&5{pLd!z^y2%@IKrVa?#BN2uIZ|>iyYeY`&^M`3qE5HqNT_j)uHf0@X=ttHj31LVM9a=JYnEo|wBr3o z9zBvv6qx^h6>;mLs%q1(Ii6M8v*npIprCfjE`590ZcJIyPtq^ihh1gYg@4qdEiAxY z9_*4+1g0xA{Vn9}UK(S)cmM>_wHz|y8{d1|Z+!;GUKTOTCIg?>1j`?ID@D1b0@S(( z{XCmxN@j+1c!xDo6^0~Ej34%MY|9`dntf|$oEtUGctDOHdy_FE14ep}F ze;#e$z591X-%2?$67j+Sbia$qHMHY9N|o(WSvz}|OaP?2+R(fQsP5~{#$Lpo08Pm9 z&iv`}4gic3gmHMS%LdbM9=MuB{D}J8PiM8@BTnoc5&)xdJhx5g&+gujMtUPUeff^e zhTe}oWCYMFn=%m={@FE|MI7Utwg@v4klP1(XS>XntAGfx?}Zel9efOs{8%p`t4sp`LoYw#U=q{^0STpR;&&JEl#mypB?4?4&0NjhIjmD2sp@DEl4>WEph?a z7W~hLyw!u4eV_?fO5>$%+5ddvJMLei`$6|5Ra`e>8p{C_Ij|mA{;y~@Rafx;QVKi} xSO(}<{iy%9y}OLZ2XG=k2PQ(TrJHKb0A#)tExW&J82nTGe*g|}P=Npd literal 0 HcmV?d00001 diff --git a/mods/MAPGEN/mcl_villages/init.lua b/mods/MAPGEN/mcl_villages/init.lua index 2b7109451..6e30f7b1c 100644 --- a/mods/MAPGEN/mcl_villages/init.lua +++ b/mods/MAPGEN/mcl_villages/init.lua @@ -93,6 +93,7 @@ if mg_name ~= "singlenode" then local x = pr1:next(0, 40) + minp.x + 19 local z = pr1:next(0, 40) + minp.z + 19 local y = minetest_get_spawn_level(x, z) + if not y then return end if y < (min or y+1) then min = y end if y > (max or y-1) then max = y end end From 9e3c2fe21e1cef5f4d5d35420a5ac91e8c39c112 Mon Sep 17 00:00:00 2001 From: kay27 Date: Tue, 4 May 2021 03:27:35 +0400 Subject: [PATCH 15/21] [mapgen] [mcl_ocean_monument] Support ice --- mods/MAPGEN/mcl_ocean_monument/init.lua | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/mods/MAPGEN/mcl_ocean_monument/init.lua b/mods/MAPGEN/mcl_ocean_monument/init.lua index 135e315bd..385e342df 100644 --- a/mods/MAPGEN/mcl_ocean_monument/init.lua +++ b/mods/MAPGEN/mcl_ocean_monument/init.lua @@ -4,7 +4,7 @@ local minetest_place_schematic = minetest.place_schematic local minetest_pos_to_string = minetest.pos_to_string local path = minetest.get_modpath("mcl_ocean_monument") .. "/schematics/ocean_monument.mts" -local water, air = "mcl_core:water_source", "air" +local water, air, ice = "mcl_core:water_source", "air", "mcl_core:ice" mcl_mapgen.register_chunk_generator(function(minp, maxp, seed) local minp = minp @@ -14,16 +14,19 @@ mcl_mapgen.register_chunk_generator(function(minp, maxp, seed) local x, z = minp.x, minp.z local pr = PseudoRandom(seed) for i = 1, pr:next(10,100) do - if mcl_mapgen_get_far_node({x=pr:next(0,79)+x, y=1, z=pr:next(0,79)+z}).name ~= water then return end + local pos = {x=pr:next(0,79)+x, y=1, z=pr:next(0,79)+z} + local node_name = mcl_mapgen_get_far_node(pos).name + if node_name ~= water and node_name ~= ice then return end end for i = 1, pr:next(10,100) do - if mcl_mapgen_get_far_node({x=pr:next(0,79)+x, y=2, z=pr:next(0,79)+z}).name ~= air then return end + local pos = {x=pr:next(0,79)+x, y=2, z=pr:next(0,79)+z} + local node_name = mcl_mapgen_get_far_node(pos).name + if node_name ~= air then return end end for i = 1, pr:next(10,100) do - if mcl_mapgen_get_far_node({x=pr:next(15,64)+x, y=pr:next(0,25)-25, z=pr:next(15,64)+z}).name ~= water then --- minetest_log("warning", "[mcl_ocean_monument] Not water at " .. minetest_pos_to_string(minp)) - return - end + local pos = {x=pr:next(15,64)+x, y=pr:next(0,25)-25, z=pr:next(15,64)+z} + local node_name = mcl_mapgen_get_far_node(pos).name + if node_name ~= water then return end end -- minetest_place_schematic(minp, path, tostring(pr:next(0,3)*90), nil, true) From 2fda0f2644ee342fea234a17a54664dc329c5a50 Mon Sep 17 00:00:00 2001 From: kay27 Date: Wed, 5 May 2021 14:22:50 +0000 Subject: [PATCH 16/21] [mapgen] Add true builder name of Ocean Monument into mod.conf --- mods/MAPGEN/mcl_ocean_monument/mod.conf | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mods/MAPGEN/mcl_ocean_monument/mod.conf b/mods/MAPGEN/mcl_ocean_monument/mod.conf index 62648e987..945a81166 100644 --- a/mods/MAPGEN/mcl_ocean_monument/mod.conf +++ b/mods/MAPGEN/mcl_ocean_monument/mod.conf @@ -1,4 +1,4 @@ name = mcl_ocean_monument -author = Sister of epCode +author = TrashPanda description = Adds Ocean Monument, https://git.minetest.land/MineClone2/MineClone2/issues/958#issuecomment-14102 depends = mcl_mapgen, mcl_structures From 2272753652998a45f12dead96f1d4f92b35c0acf Mon Sep 17 00:00:00 2001 From: kay27 Date: Thu, 6 May 2021 00:41:20 +0400 Subject: [PATCH 17/21] [mapgen] [mcl_ocean_monument] Reorder check loops to make it work faster, add random rotation --- mods/MAPGEN/mcl_ocean_monument/init.lua | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/mods/MAPGEN/mcl_ocean_monument/init.lua b/mods/MAPGEN/mcl_ocean_monument/init.lua index 385e342df..8b34f2c6c 100644 --- a/mods/MAPGEN/mcl_ocean_monument/init.lua +++ b/mods/MAPGEN/mcl_ocean_monument/init.lua @@ -1,3 +1,6 @@ + +-- Check it: `/tp 14958,8,11370` @ world seed `1` + local mcl_mapgen_get_far_node = mcl_mapgen.get_far_node local minetest_log = minetest.log local minetest_place_schematic = minetest.place_schematic @@ -14,9 +17,9 @@ mcl_mapgen.register_chunk_generator(function(minp, maxp, seed) local x, z = minp.x, minp.z local pr = PseudoRandom(seed) for i = 1, pr:next(10,100) do - local pos = {x=pr:next(0,79)+x, y=1, z=pr:next(0,79)+z} + local pos = {x=pr:next(15,64)+x, y=pr:next(0,25)-25, z=pr:next(15,64)+z} local node_name = mcl_mapgen_get_far_node(pos).name - if node_name ~= water and node_name ~= ice then return end + if node_name ~= water then return end end for i = 1, pr:next(10,100) do local pos = {x=pr:next(0,79)+x, y=2, z=pr:next(0,79)+z} @@ -24,16 +27,15 @@ mcl_mapgen.register_chunk_generator(function(minp, maxp, seed) if node_name ~= air then return end end for i = 1, pr:next(10,100) do - local pos = {x=pr:next(15,64)+x, y=pr:next(0,25)-25, z=pr:next(15,64)+z} + local pos = {x=pr:next(0,79)+x, y=1, z=pr:next(0,79)+z} local node_name = mcl_mapgen_get_far_node(pos).name - if node_name ~= water then return end + if node_name ~= water and node_name ~= ice then return end end --- minetest_place_schematic(minp, path, tostring(pr:next(0,3)*90), nil, true) - minetest_place_schematic(minp, path, 0, nil, true) + minetest_place_schematic(minp, path, tostring(pr:next(0,3)*90), nil, true) minetest_log("action", "[mcl_ocean_monument] Placed at " .. minetest_pos_to_string(minp)) - ---- TODO: SET UP SPECIAL NODES... + ---- TODO: SET UP SOME NODES? end, mcl_mapgen.priorities.OCEAN_MONUMENT) From 135c8ece4109ccff8a5340809d22e567ea4b514e Mon Sep 17 00:00:00 2001 From: NO11 Date: Wed, 5 May 2021 21:42:11 +0000 Subject: [PATCH 18/21] Remove some helper recipes, because the ocean monument generates now --- mods/MISC/mcl_temp_helper_recipes/init.lua | 27 ---------------------- 1 file changed, 27 deletions(-) diff --git a/mods/MISC/mcl_temp_helper_recipes/init.lua b/mods/MISC/mcl_temp_helper_recipes/init.lua index ff9f541f3..3c448a465 100644 --- a/mods/MISC/mcl_temp_helper_recipes/init.lua +++ b/mods/MISC/mcl_temp_helper_recipes/init.lua @@ -8,33 +8,6 @@ minetest.register_craft({ recipe = {"mcl_core:iron_ingot", "mcl_core:stick", "group:wood", "mcl_chests:chest"}, }) -minetest.register_craft({ - output = "mcl_sponges:sponge", - recipe = { - { "mcl_farming:hay_block", "mcl_farming:hay_block", "mcl_farming:hay_block" }, - { "mcl_farming:hay_block", "mcl_core:goldblock", "mcl_farming:hay_block" }, - { "mcl_farming:hay_block", "mcl_farming:hay_block", "mcl_farming:hay_block" }, - } -}) - -minetest.register_craft({ - output = "mcl_ocean:prismarine_shard", - recipe = { - { "mcl_core:glass_cyan", }, - } -}) - -minetest.register_craft({ - type = "shapeless", - output = "mcl_ocean:prismarine_crystals", - recipe = { - "mcl_ocean:prismarine_shard", - "mcl_ocean:prismarine_shard", - "mcl_ocean:prismarine_shard", - "mcl_core:gold_ingot", - }, -}) - minetest.register_craft({ output = "mcl_armor:helmet_chain", recipe = { From ce6f5b0ee191d51a13ea7e6f8442a73e5ad527de Mon Sep 17 00:00:00 2001 From: kay27 Date: Thu, 6 May 2021 02:42:06 +0400 Subject: [PATCH 19/21] [mapgen] [mcl_ocean_monument] Generate prismarine legs up to the bottom --- mods/MAPGEN/mcl_ocean_monument/init.lua | 78 +++++++++++++++++++++---- 1 file changed, 67 insertions(+), 11 deletions(-) diff --git a/mods/MAPGEN/mcl_ocean_monument/init.lua b/mods/MAPGEN/mcl_ocean_monument/init.lua index 8b34f2c6c..97ca1fa6e 100644 --- a/mods/MAPGEN/mcl_ocean_monument/init.lua +++ b/mods/MAPGEN/mcl_ocean_monument/init.lua @@ -1,41 +1,97 @@ --- Check it: `/tp 14958,8,11370` @ world seed `1` +-- Check it: +-- seed 1, v7 mapgen +-- /teleport 14958,8,11370 local mcl_mapgen_get_far_node = mcl_mapgen.get_far_node local minetest_log = minetest.log local minetest_place_schematic = minetest.place_schematic local minetest_pos_to_string = minetest.pos_to_string +local minetest_swap_node = minetest.swap_node local path = minetest.get_modpath("mcl_ocean_monument") .. "/schematics/ocean_monument.mts" -local water, air, ice = "mcl_core:water_source", "air", "mcl_core:ice" + +local water = "mcl_core:water_source" +local air = "air" +local ice = "mcl_core:ice" + +local leg_materials = { + "mcl_ocean:prismarine_brick", + "mcl_ocean:prismarine", +} +local what_we_can_replace_by_legs = { + water, + air, + "mcl_core:water_flow", + "mcl_core:stone", +} + +local leg_search_quick_index = {} +for _, v in pairs(leg_materials) do + leg_search_quick_index[v] = true +end + +local leg_replace_quick_index = {} +for _, v in pairs(what_we_can_replace_by_legs) do + leg_replace_quick_index[v] = true +end + +local y_wanted = mcl_mapgen.OFFSET_NODES -- supposed to be -32 +local y_bottom = mcl_mapgen.overworld.min -- -62 mcl_mapgen.register_chunk_generator(function(minp, maxp, seed) local minp = minp local y = minp.y - if y ~= -32 then return end + if y ~= y_wanted then return end local x, z = minp.x, minp.z local pr = PseudoRandom(seed) - for i = 1, pr:next(10,100) do - local pos = {x=pr:next(15,64)+x, y=pr:next(0,25)-25, z=pr:next(15,64)+z} + + -- scan the ocean - it should be the ocean: + for i = 1, pr:next(10, 100) do + local pos = {x = pr:next(15, 64) + x, y = pr:next(0, 25) - 25, z = pr:next(15, 64) + z} local node_name = mcl_mapgen_get_far_node(pos).name if node_name ~= water then return end end - for i = 1, pr:next(10,100) do - local pos = {x=pr:next(0,79)+x, y=2, z=pr:next(0,79)+z} + + -- scan nodes above water level - there should be the air: + for i = 1, pr:next(10, 100) do + local pos = {x = pr:next(0, 79) + x, y = 2, z = pr:next(0,79) + z} local node_name = mcl_mapgen_get_far_node(pos).name if node_name ~= air then return end end + + -- scan ocean surface - allow only water and ice: for i = 1, pr:next(10,100) do - local pos = {x=pr:next(0,79)+x, y=1, z=pr:next(0,79)+z} + local pos = {x=pr:next(0, 79)+x, y=1, z=pr:next(0,79)+z} local node_name = mcl_mapgen_get_far_node(pos).name if node_name ~= water and node_name ~= ice then return end end - minetest_place_schematic(minp, path, tostring(pr:next(0,3)*90), nil, true) + -- random rotation: + local rotation = pr:next(0, 3) + local rotation_str = tostring(rotation * 90) + minetest_place_schematic(minp, path, rotation_str, nil, true) - minetest_log("action", "[mcl_ocean_monument] Placed at " .. minetest_pos_to_string(minp)) + -- search prismarine legs at base level and continue them up to the bottom: + for x = x, maxp.x do + for z = z, maxp.z do + local pos = {x = x, y = y, z = z} + local node_name = mcl_mapgen_get_far_node(pos).name + if leg_search_quick_index[node_name] then + local node_leg = {name = node_name} + for y = y - 1, y_bottom, -1 do + pos.y = y + local next_name = mcl_mapgen_get_far_node(pos).name + if not leg_replace_quick_index[next_name] then + break + end + minetest_swap_node(pos, node_leg) + end + end + end + end - ---- TODO: SET UP SOME NODES? + minetest_log("action", "[mcl_ocean_monument] Placed at " .. minetest_pos_to_string(minp) .. ", " .. rotation_str .. " deg.") end, mcl_mapgen.priorities.OCEAN_MONUMENT) From 3bd1a6f89ea750909086e6fb972190e466febdf4 Mon Sep 17 00:00:00 2001 From: kay27 Date: Thu, 6 May 2021 02:58:49 +0400 Subject: [PATCH 20/21] [mapgen] [mcl_ocean_monument] Fix a typo in water_flowing node name --- mods/MAPGEN/mcl_ocean_monument/init.lua | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mods/MAPGEN/mcl_ocean_monument/init.lua b/mods/MAPGEN/mcl_ocean_monument/init.lua index 97ca1fa6e..04117d143 100644 --- a/mods/MAPGEN/mcl_ocean_monument/init.lua +++ b/mods/MAPGEN/mcl_ocean_monument/init.lua @@ -22,7 +22,7 @@ local leg_materials = { local what_we_can_replace_by_legs = { water, air, - "mcl_core:water_flow", + "mcl_core:water_flowing", "mcl_core:stone", } From 279b1b09cdbbb2f51147ed1d10f862ca0c090dfd Mon Sep 17 00:00:00 2001 From: kay27 Date: Sat, 8 May 2021 02:51:17 +0400 Subject: [PATCH 21/21] [mapgen] Add `mcl_mapgen.priorities` table --- mods/CORE/mcl_mapgen/API.md | 84 +++++++++++++++++----------- mods/CORE/mcl_mapgen/init.lua | 17 ++++-- mods/MAPGEN/mcl_biomes/init.lua | 2 +- mods/MAPGEN/mcl_dungeons/init.lua | 2 +- mods/MAPGEN/mcl_strongholds/init.lua | 2 +- mods/MAPGEN/mcl_villages/init.lua | 2 +- 6 files changed, 68 insertions(+), 41 deletions(-) diff --git a/mods/CORE/mcl_mapgen/API.md b/mods/CORE/mcl_mapgen/API.md index 364bc3205..b5afbeb4d 100644 --- a/mods/CORE/mcl_mapgen/API.md +++ b/mods/CORE/mcl_mapgen/API.md @@ -1,54 +1,74 @@ # mcl_mapgen ============ -This mod helps to avoid problems caused by Minetest's 'chunk-in-shell' feature of mapgen.cpp. -It also queues your generators to run them in proper order. +Helps to avoid problems caused by 'chunk-in-shell' feature of mapgen.cpp. +It also queues your generators to run them in proper order: - -========================================================================= ## mcl_mapgen.register_chunk_generator(chunk_callback_function, priority) ========================================================================= -UNSAFE! See below. Registers callback function to be called when current chunk generation is finished. - `callback_function`: chunk callback function definition, see below; - `priority`: order number - the less, the earlier. -### Chunk callback function definition: - `function(minp, maxp, seed)`: - `minp` & `maxp`: minimum and maximum chunk position; - `seed`: seed of this mapchunk. - - -======================================================================= -## mcl_mapgen.register_chunk_generator_lvm(callback_function, priority) -======================================================================= -UNSAFE! See below. Registers callback function to be called when current chunk generation is finished. -`vm_context` passes into callback function and should be returned back. - `callback_function`: chunk callback LVM function definition, see below; - `priority`: order number - the less, the earlier. -### Chunk callback LVM function definition: - Function MUST RETURN `vm_context`. It passes into next callback function from the queue. - `function(vm_context)`: - `vm_context` is a table which already contains some LVM data and some of them can be added in callback function: +Registers callback function to be called when current chunk generation is finished. + `callback_function`: chunk callback function definition: + `function(minp, maxp, seed)`: `minp` & `maxp`: minimum and maximum chunk position; - `seed`: seed of this mapchunk. + `seed`: seed of this mapchunk; + `priority` (optional): order number - the less, the earlier, + e.g. `mcl_mapgen.priorities.BUILDINGS` or `mcl_mapgen.priorities.LARGE_BUILDINGS` - -=================================================================== ## mcl_mapgen.register_block_generator(callback_function, priority) =================================================================== Registers callback function to be called when block (usually 16x16x16 nodes) generation is finished. `callback_function`: block callback function definition, see below; - `priority`: order number - the less, the earlier. + `priority` (optional): order number - the less, the earlier, + e.g. `mcl_mapgen.priorities.BUILDINGS` or `mcl_mapgen.priorities.LARGE_BUILDINGS` - -======================================================================= ## mcl_mapgen.register_block_generator_lvm(callback_function, priority) ======================================================================= Registers callback function to be called when block (usually 16x16x16 nodes) generation is finished. `vm_context` passes into callback function and should be returned back. `callback_function`: block callback LVM function definition, see below; - `priority`: order number - the less, the earlier. + `priority` (optional): order number - the less, the earlier, + e.g. `mcl_mapgen.priorities.BUILDINGS` or `mcl_mapgen.priorities.LARGE_BUILDINGS` +## mcl_mapgen.register_chunk_generator_lvm(callback_function, priority) +======================================================================= +UNSAFE! See https://git.minetest.land/MineClone2/MineClone2/issues/1395 +Registers callback function to be called when current chunk generation is finished. +IT IS UNSAFE! GROUND CONTENT YOU PLACE (INCLUDING WATER AND AIR) CAN BE OVERWRITTEN BY cavegen. +ALL OTHER API FUNCTIONS ARE SAFE! USE THEM PLEASE! BUT WE NEED THIS FUNCTION STILL SOMETIMES, +WHEN WE NEED TO ACCESS MAPGEN OBJECTS like `heightmap`, `biomemap`, ETC. + `callback_function`: chunk callback LVM function definition, see below; + `function(vm_context)`: + Function MUST RETURN `vm_context` back anyway! It will passed into next callback function from the queue. + `vm_context`: a table which already contains some LVM data if the fields, and some of them can be added right in callback function: + `vm`: curent voxel manipulator object itself; + `blockseed`: seed of this mapchunk; + `minp` & `maxp`: minimum and maximum chunk position; + `emin` & `emax`: minimum and maximum chunk position WITH SHELL AROUND IT; + `area`: voxel area, can be helpful to access data; + `data`: LVM buffer data array, data loads into it before the callbacks; + `write`: set it to true in yout callback functionm, if you changed `data` and want to write it; + `data2`: LVM buffer data array of `param2`, !NO ANY DATA LOADS INTO IT BEFORE THE CALLBACKS! - you load it yourfels: + `vm_context.data2 = vm_context.data2 or vm_context.vm.get_param2_data(vm_context.lvm_param2_buffer)` + `write_param2`: set it to true in yout callback functionm, if you used `data2` and want to write it; + `lvm_param2_buffer`: static `param2` buffer pointer, used to load `data2` array; + `shadow`: set it to false to disable shadow propagation; + `heightmap`: mapgen object contanting y coordinates of ground level, + !NO ANY DATA LOADS INTO IT BEFORE THE CALLBACKS! - you load it yourfels: + `vm_context.heightmap = vm_context.heightmap or minetest.get_mapgen_object('heightmap')` + `biomemap`: mapgen object contanting biome IDs of nodes, + !NO ANY DATA LOADS INTO IT BEFORE THE CALLBACKS! - you load it yourfels: + `vm_context.biomemap = vm_context.biomemap or minetest.get_mapgen_object('biomemap')` + `heatmap`: mapgen object contanting temperature values of nodes, + !NO ANY DATA LOADS INTO IT BEFORE THE CALLBACKS! - you load it yourfels: + `vm_context.heatmap = vm_context.heatmap or minetest.get_mapgen_object('heatmap')` + `humiditymap`: mapgen object contanting humidity values of nodes, + !NO ANY DATA LOADS INTO IT BEFORE THE CALLBACKS! - you load it yourfels: + `vm_context.humiditymap = vm_context.humiditymap or minetest.get_mapgen_object('humiditymap')` + `gennotify`: mapgen object contanting mapping table of structures, see Minetest Lua API for explanation, + !NO ANY DATA LOADS INTO IT BEFORE THE CALLBACKS! - you load it yourfels: + `vm_context.gennotify = vm_context.gennotify or minetest.get_mapgen_object('gennotify')` + `priority` (optional): order number - the less, the earlier, + e.g. `mcl_mapgen.priorities.BUILDINGS` or `mcl_mapgen.priorities.LARGE_BUILDINGS` -=============================== ## mcl_mapgen.get_far_node(pos) =============================== Returns node if it is generated. Otherwise returns `{name = "ignore"}`. diff --git a/mods/CORE/mcl_mapgen/init.lua b/mods/CORE/mcl_mapgen/init.lua index a5982ae4e..992c93b0d 100644 --- a/mods/CORE/mcl_mapgen/init.lua +++ b/mods/CORE/mcl_mapgen/init.lua @@ -1,7 +1,14 @@ mcl_mapgen = {} -local priority = { - OCEAN_MONUMENT = 1000000 +local priorities = { -- mcl_mapgen.priorities... + DEFAULT = 5000, + CHORUS = 100000, + BUILDINGS = 200000, + VILLAGES = 900000, + DUNGEONS = 950000, + STRONGHOLDS = 999999, + OCEAN_MONUMENT = 1000000, + LARGE_BUILDINGS = 2000000, } local math_floor = math.floor @@ -62,7 +69,7 @@ local CS_NODES = mcl_mapgen.CS_NODES -- 80 local CS_3D = CS * CS * CS -local DEFAULT_PRIORITY = 5000 +local DEFAULT_PRIORITY = priorities.DEFAULT function mcl_mapgen.register_chunk_generator(callback_function, priority) nodes_chunk = nodes_chunk + 1 @@ -261,7 +268,7 @@ minetest.register_on_generated(function(minp, maxp, blockseed) if vm_context.write_param2 then vm:set_param2_data(data2) end - vm:calc_lighting(minp, maxp, vm_context.shadow) -- TODO: check boundaries + vm:calc_lighting(minp, maxp, vm_context.shadow or true) -- TODO: check boundaries vm:write_to_map() vm:update_liquids() end @@ -403,4 +410,4 @@ mcl_mapgen.overworld = overworld mcl_mapgen.end_ = end_ mcl_mapgen.nether = nether -mcl_mapgen.priorities = priority +mcl_mapgen.priorities = priorities diff --git a/mods/MAPGEN/mcl_biomes/init.lua b/mods/MAPGEN/mcl_biomes/init.lua index a35183c15..80975d6e4 100644 --- a/mods/MAPGEN/mcl_biomes/init.lua +++ b/mods/MAPGEN/mcl_biomes/init.lua @@ -3979,7 +3979,7 @@ if not mcl_mapgen.singlenode then minetest.after(1, mcl_end.grow_chorus_plant, realpos) end return c - end) + end, mcl_mapgen.priorities.CHORUS) end end diff --git a/mods/MAPGEN/mcl_dungeons/init.lua b/mods/MAPGEN/mcl_dungeons/init.lua index 03a5c4e07..b333f4d8a 100644 --- a/mods/MAPGEN/mcl_dungeons/init.lua +++ b/mods/MAPGEN/mcl_dungeons/init.lua @@ -413,4 +413,4 @@ function mcl_dungeons.spawn_dungeon(p1, _, pr) spawn_dungeon(p1, p2, dim, pr, true) end -mcl_mapgen.register_chunk_generator(dungeons_nodes, 999999) +mcl_mapgen.register_chunk_generator(dungeons_nodes, mcl_mapgen.priorities.DUNGEONS) diff --git a/mods/MAPGEN/mcl_strongholds/init.lua b/mods/MAPGEN/mcl_strongholds/init.lua index e4bbdb974..d4dd8a99c 100644 --- a/mods/MAPGEN/mcl_strongholds/init.lua +++ b/mods/MAPGEN/mcl_strongholds/init.lua @@ -100,4 +100,4 @@ mcl_mapgen.register_chunk_generator(function(minp, maxp, blockseed) end end end -end, 999999) +end, mcl_mapgen.priorities.STRONGHOLDS) diff --git a/mods/MAPGEN/mcl_villages/init.lua b/mods/MAPGEN/mcl_villages/init.lua index 6e30f7b1c..3c3cf3291 100644 --- a/mods/MAPGEN/mcl_villages/init.lua +++ b/mods/MAPGEN/mcl_villages/init.lua @@ -103,7 +103,7 @@ if mg_name ~= "singlenode" then if height_difference > max_height_difference then return end build_a_settlement(minp, maxp, blockseed) - end) + end, mcl_mapgen.priorities.VILLAGES) end -- manually place villages if minetest.is_creative_enabled("") then