forked from MineClone5/MineClone5
633 lines
22 KiB
Lua
633 lines
22 KiB
Lua
local modname = minetest.get_current_modname()
|
|
local modpath = minetest.get_modpath(modname)
|
|
|
|
local chance_per_chunk = 400
|
|
local noise_multiplier = 2.5
|
|
local random_offset = 9159
|
|
local scanning_ratio = 0.001
|
|
local struct_threshold = 396
|
|
|
|
local mcl_structures_get_perlin_noise_level = mcl_structures.get_perlin_noise_level
|
|
local minetest_find_nodes_in_area = minetest.find_nodes_in_area
|
|
local minetest_swap_node = minetest.swap_node
|
|
local math_round = math.round
|
|
local math_abs = math.abs
|
|
|
|
|
|
local rotation_to_orientation = {
|
|
["0"] = 1,
|
|
["90"] = 0,
|
|
["180"] = 1,
|
|
["270"] = 0,
|
|
}
|
|
|
|
local rotation_to_param2 = {
|
|
["0"] = 3,
|
|
["90"] = 0,
|
|
["180"] = 1,
|
|
["270"] = 2,
|
|
}
|
|
|
|
local node_top = {
|
|
"mcl_core:goldblock",
|
|
"mcl_core:stone_with_gold",
|
|
"mcl_core:goldblock",
|
|
}
|
|
|
|
local node_garbage = {
|
|
"mcl_nether:netherrack",
|
|
"mcl_core:lava_source",
|
|
"mcl_nether:netherrack",
|
|
"mcl_nether:netherrack",
|
|
"mcl_nether:magma",
|
|
"mcl_nether:netherrack",
|
|
}
|
|
|
|
local stone1 = {name = "mcl_core:stonebrickcracked"}
|
|
local stone2 = {name = "mcl_core:stonebrickmossy"}
|
|
local stone3 = {name = "mcl_nether:magma"}
|
|
local stone4 = {name = "mcl_core:stonebrick"}
|
|
|
|
local slab1 = {name = "mcl_stairs:slab_stonebrickcracked_top"}
|
|
local slab2 = {name = "mcl_stairs:slab_stonebrickmossy_top"}
|
|
local slab3 = {name = "mcl_stairs:slab_stone_top"}
|
|
local slab4 = {name = "mcl_stairs:slab_stonebrick_top"}
|
|
|
|
local stair1 = "mcl_stairs:stair_stonebrickcracked"
|
|
local stair2 = "mcl_stairs:stair_stonebrickmossy"
|
|
local stair3 = "mcl_stairs:stair_stone_rough"
|
|
local stair4 = "mcl_stairs:stair_stonebrick"
|
|
|
|
|
|
local function draw_frame(frame_pos, frame_width, frame_height, orientation, pr, is_chain, rotation)
|
|
local param2 = rotation_to_param2[rotation]
|
|
|
|
local function set_ruined_node(pos, node)
|
|
if pr:next(1, 5) == 4 then return end
|
|
minetest_swap_node(pos, node)
|
|
end
|
|
|
|
local function get_random_stone_material()
|
|
local rnd = pr:next(1, 15)
|
|
if rnd < 4 then return stone1 end
|
|
if rnd == 4 then return stone2 end
|
|
if rnd == 5 then return stone3 end
|
|
return stone4
|
|
end
|
|
|
|
local function get_random_slab()
|
|
local rnd = pr:next(1, 15)
|
|
if rnd < 4 then return slab1 end
|
|
if rnd == 4 then return slab2 end
|
|
if rnd == 5 then return slab3 end
|
|
return slab4
|
|
end
|
|
|
|
local function get_random_stair(param2_offset)
|
|
local param2 = (param2 + (param2_offset or 0)) % 4
|
|
local rnd = pr:next(1, 15)
|
|
if rnd < 4 then return {name = stair1, param2 = param2} end
|
|
if rnd == 4 then return {name = stair2, param2 = param2} end
|
|
if rnd == 5 then return {name = stair3, param2 = param2} end
|
|
return {name = stair4, param2 = param2}
|
|
end
|
|
|
|
local function set_frame_stone_material(pos)
|
|
minetest_swap_node(pos, get_random_stone_material())
|
|
end
|
|
|
|
local function set_ruined_frame_stone_material(pos)
|
|
set_ruined_node(pos, get_random_stone_material())
|
|
end
|
|
|
|
local is_chain = is_chain
|
|
local orientation = orientation
|
|
local x1 = frame_pos.x
|
|
local y1 = frame_pos.y
|
|
local z1 = frame_pos.z
|
|
local slide_x = (1 - orientation)
|
|
local slide_z = orientation
|
|
local last_x = x1 + (frame_width - 1) * slide_x
|
|
local last_z = z1 + (frame_width - 1) * slide_z
|
|
local last_y = y1 + frame_height - 1
|
|
|
|
-- it's about the portal frame itself, what it will consist of
|
|
local frame_nodes = 2 * (frame_height + frame_width) - 4
|
|
local obsidian_nodes = pr:next(math_round(frame_nodes * 0.5), math_round(frame_nodes * 0.73))
|
|
local crying_obsidian_nodes = pr:next(math_round(obsidian_nodes * 0.09), math_round(obsidian_nodes * 0.5))
|
|
local air_nodes = frame_nodes - obsidian_nodes
|
|
|
|
local function set_frame_node(pos)
|
|
-- local node_choice = pr:next(1, air_nodes + obsidian_nodes)
|
|
local node_choice = math_round(mcl_structures_get_perlin_noise_level(pos) * (air_nodes + obsidian_nodes))
|
|
if node_choice > obsidian_nodes and air_nodes > 0 then
|
|
air_nodes = air_nodes - 1
|
|
return
|
|
end
|
|
obsidian_nodes = obsidian_nodes - 1
|
|
if node_choice >= crying_obsidian_nodes then
|
|
minetest_swap_node(pos, {name = "mcl_core:obsidian"})
|
|
return 1
|
|
end
|
|
minetest_swap_node(pos, {name = "mcl_core:crying_obsidian"})
|
|
crying_obsidian_nodes = crying_obsidian_nodes - 1
|
|
return 1
|
|
end
|
|
|
|
local function set_outer_frame_node(def)
|
|
local is_top = def.is_top
|
|
if is_chain then
|
|
local pos2 = def.pos_outer2
|
|
local is_top_hole = is_top and frame_width > 5 and ((pos2.x == x1 + slide_x * 2 and pos2.z == z1 + slide_z * 2) or (pos2.x == last_x - slide_x * 2 and pos2.z == last_z - slide_z * 2))
|
|
if is_top_hole then
|
|
if pr:next(1, 7) > 1 then
|
|
minetest_swap_node(pos2, {name = "xpanes:bar_flat", param2 = orientation})
|
|
end
|
|
else
|
|
set_frame_stone_material(pos2)
|
|
end
|
|
end
|
|
local is_obsidian = def.is_obsidian
|
|
if not is_obsidian and pr:next(1, 2) == 1 then return end
|
|
local pos = def.pos_outer1
|
|
local is_decor_here = not is_top and pos.y % 3 == 2
|
|
if is_decor_here then
|
|
minetest_swap_node(pos, {name = "mcl_core:stonebrickcarved"})
|
|
elseif is_chain then
|
|
if not is_top and not is_obsidian then
|
|
minetest_swap_node(pos, {name = "xpanes:bar"})
|
|
else
|
|
minetest_swap_node(pos, {name = "xpanes:bar_flat", param2 = orientation})
|
|
end
|
|
else
|
|
if pr:next(1, 5) == 3 then
|
|
minetest_swap_node(pos, {name = "mcl_core:stonebrickcracked"})
|
|
else
|
|
minetest_swap_node(pos, {name = "mcl_core:stonebrick"})
|
|
end
|
|
end
|
|
end
|
|
|
|
local function draw_roof(pos, length)
|
|
local x = pos.x
|
|
local y = pos.y
|
|
local z = pos.z
|
|
local number_of_roof_nodes = length
|
|
if number_of_roof_nodes > 1 then
|
|
set_ruined_node({x = x, y = y, z = z}, get_random_stair((param2 == 1 or param2 == 2) and -1 or 1))
|
|
set_ruined_node({x = x + (length - 1) * slide_x, y = y, z = z + (length - 1) * slide_z}, get_random_stair((param2 == 1 or param2 == 2) and 1 or -1))
|
|
number_of_roof_nodes = number_of_roof_nodes - 2
|
|
x = x + slide_x
|
|
z = z + slide_z
|
|
end
|
|
while number_of_roof_nodes > 0 do
|
|
set_ruined_node({x = x, y = y, z = z}, get_random_stair((param2 == 1 or param2 == 2) and 2 or 0))
|
|
x = x + slide_x
|
|
z = z + slide_z
|
|
number_of_roof_nodes = number_of_roof_nodes - 1
|
|
end
|
|
end
|
|
|
|
-- bottom corners
|
|
set_frame_node({x = x1, y = y1, z = z1})
|
|
set_frame_node({x = last_x, y = y1, z = last_z})
|
|
|
|
-- top corners
|
|
local is_obsidian_top_left = set_frame_node({x = x1, y = last_y, z = z1})
|
|
local is_obsidian_top_right = set_frame_node({x = last_x, y = last_y, z = last_z})
|
|
|
|
if is_chain then
|
|
if is_obsidian_top_left and pr:next(1, 4) ~= 2 then
|
|
set_frame_stone_material({x = x1 - slide_x * 2, y = last_y + 2, z = z1 - slide_z * 2})
|
|
end
|
|
if is_obsidian_top_left and pr:next(1, 4) ~= 2 then
|
|
set_frame_stone_material({x = x1 - slide_x * 2, y = last_y + 1, z = z1 - slide_z * 2})
|
|
end
|
|
if is_obsidian_top_left and pr:next(1, 4) ~= 2 then
|
|
set_frame_stone_material({x = last_x + slide_x * 2, y = last_y + 2, z = last_z + slide_z * 2})
|
|
end
|
|
if is_obsidian_top_left and pr:next(1, 4) ~= 2 then
|
|
set_frame_stone_material({x = last_x + slide_x * 2, y = last_y + 1, z = last_z + slide_z * 2})
|
|
end
|
|
end
|
|
|
|
for y = y1, last_y do
|
|
local begin_or_end = y == y1 or y == last_y
|
|
local is_obsidian_left = begin_or_end and is_obsidian_top_left or set_frame_node({x = x1 , y = y, z = z1 })
|
|
local is_obsidian_right = begin_or_end and is_obsidian_top_right or set_frame_node({x = last_x, y = y, z = last_z})
|
|
set_outer_frame_node({
|
|
pos_outer1 = {x = x1 - slide_x , y = y, z = z1 - slide_z },
|
|
pos_outer2 = {x = x1 - slide_x * 2, y = y, z = z1 - slide_z * 2},
|
|
is_obsidian = is_obsidian_left,
|
|
})
|
|
set_outer_frame_node({
|
|
pos_outer1 = {x = last_x + slide_x , y = y, z = last_z + slide_z },
|
|
pos_outer2 = {x = last_x + slide_x * 2, y = y, z = last_z + slide_z * 2},
|
|
is_obsidian = is_obsidian_right,
|
|
})
|
|
end
|
|
|
|
for i = 0, 1 do
|
|
set_outer_frame_node({
|
|
pos_outer1 = {x = x1 - slide_x * i, y = last_y + 1, z = z1 - slide_z * i},
|
|
pos_outer2 = {x = x1 - slide_x * i, y = last_y + 2, z = z1 - slide_z * i},
|
|
is_obsidian = is_obsidian_top_left,
|
|
is_top = true,
|
|
})
|
|
set_outer_frame_node({
|
|
pos_outer1 = {x = last_x + slide_x * i, y = last_y + 1, z = last_z + slide_z * i},
|
|
pos_outer2 = {x = last_x + slide_x * i, y = last_y + 2, z = last_z + slide_z * i},
|
|
is_obsidian = is_obsidian_top_right,
|
|
is_top = true,
|
|
})
|
|
end
|
|
|
|
for x = x1 + slide_x, last_x - slide_x do for z = z1 + slide_z, last_z - slide_z do
|
|
set_frame_node({x = x, y = y1, z = z})
|
|
local is_obsidian_top = set_frame_node({x = x, y = last_y, z = z})
|
|
set_outer_frame_node({
|
|
pos_outer1 = {x = x, y = last_y + 1, z = z},
|
|
pos_outer2 = {x = x, y = last_y + 2, z = z},
|
|
is_obsidian = is_obsidian_top,
|
|
is_top = true
|
|
})
|
|
end end
|
|
|
|
local node_top = {name = node_top[pr:next(1, #node_top)]}
|
|
if is_chain then
|
|
set_ruined_frame_stone_material({x = x1 + slide_x * 2, y = last_y + 3, z = z1 + slide_z * 2})
|
|
set_ruined_frame_stone_material({x = x1 + slide_x , y = last_y + 3, z = z1 + slide_z })
|
|
set_ruined_frame_stone_material({x = last_x - slide_x , y = last_y + 3, z = last_z - slide_z })
|
|
set_ruined_frame_stone_material({x = last_x - slide_x * 2, y = last_y + 3, z = last_z - slide_z * 2})
|
|
for x = x1 + slide_x * 3, last_x - slide_x * 3 do for z = z1 + slide_z * 3, last_z - slide_z * 3 do
|
|
set_ruined_node({x = x, y = last_y + 3, z = z}, node_top)
|
|
set_ruined_node({x = x - slide_z, y = last_y + 3, z = z - slide_x}, get_random_slab())
|
|
set_ruined_node({x = x + slide_z, y = last_y + 3, z = z + slide_x}, get_random_slab())
|
|
end end
|
|
draw_roof({x = x1 + slide_x * 3, y = last_y + 4, z = z1 + slide_z * 3}, frame_width - 6)
|
|
else
|
|
set_ruined_frame_stone_material({x = x1 + slide_x * 3, y = last_y + 2, z = z1 + slide_z * 3})
|
|
set_ruined_frame_stone_material({x = x1 + slide_x * 2, y = last_y + 2, z = z1 + slide_z * 2})
|
|
set_ruined_frame_stone_material({x = last_x - slide_x * 2, y = last_y + 2, z = last_z - slide_z * 2})
|
|
set_ruined_frame_stone_material({x = last_x - slide_x * 3, y = last_y + 2, z = last_z - slide_z * 3})
|
|
for x = x1 + slide_x * 4, last_x - slide_x * 4 do for z = z1 + slide_z * 4, last_z - slide_z * 4 do
|
|
set_ruined_node({x = x, y = last_y + 2, z = z}, node_top)
|
|
set_ruined_node({x = x - slide_z, y = last_y + 2, z = z - slide_x}, get_random_slab())
|
|
set_ruined_node({x = x + slide_z, y = last_y + 2, z = z + slide_x}, get_random_slab())
|
|
end end
|
|
draw_roof({x = x1 + slide_x * 3, y = last_y + 3, z = z1 + slide_z * 3}, frame_width - 6)
|
|
end
|
|
end
|
|
|
|
local possible_rotations = {"0", "90", "180", "270"}
|
|
|
|
local function draw_trash(pos, width, height, lift, orientation, pr)
|
|
local slide_x = (1 - orientation)
|
|
local slide_z = orientation
|
|
local x1 = pos.x - lift - 1
|
|
local x2 = pos.x + (width - 1) * slide_x + lift + 1
|
|
local z1 = pos.z - lift - 1
|
|
local z2 = pos.z + (width - 1) * slide_z + lift + 1
|
|
local y1 = pos.y - pr:next(1, height) - 1
|
|
local y2 = pos.y
|
|
local opacity_layers = math.floor((y2 - y1) / 2)
|
|
local opacity_layer = -opacity_layers
|
|
for y = y1, y2 do
|
|
local inverted_opacity_0_5 = math_round(math_abs(opacity_layer) / opacity_layers * 5)
|
|
for x = x1 + pr:next(0, 2), x2 - pr:next(0, 2) do
|
|
for z = z1 + pr:next(0, 2), z2 - pr:next(0, 2) do
|
|
if inverted_opacity_0_5 == 0 or (x % inverted_opacity_0_5 ~= pr:next(0, 1) and z % inverted_opacity_0_5 ~= pr:next(0, 1)) then
|
|
minetest_swap_node({x = x, y = y, z = z}, {name = node_garbage[pr:next(1, #node_garbage)]})
|
|
end
|
|
end
|
|
end
|
|
opacity_layer = opacity_layer + 1
|
|
end
|
|
end
|
|
|
|
local stair_replacement_list = {
|
|
"air",
|
|
"group:water",
|
|
"group:lava",
|
|
"group:buildable_to",
|
|
"group:deco_block",
|
|
}
|
|
|
|
local stair_names = {
|
|
"mcl_stairs:stair_stonebrickcracked",
|
|
"mcl_stairs:stair_stonebrickmossy",
|
|
"mcl_stairs:stair_stone_rough",
|
|
"mcl_stairs:stair_stone_rough",
|
|
"mcl_stairs:stair_stone_rough",
|
|
"mcl_stairs:stair_stone_rough",
|
|
"mcl_stairs:stair_stone_rough",
|
|
"mcl_stairs:stair_stone_rough",
|
|
"mcl_stairs:stair_stone_rough",
|
|
"mcl_stairs:stair_stonebrick",
|
|
"mcl_stairs:stair_stonebrick",
|
|
"mcl_stairs:stair_stonebrick",
|
|
}
|
|
local stair_outer_names = {
|
|
"mcl_stairs:stair_stonebrickcracked_outer",
|
|
"mcl_stairs:stair_stonebrickmossy_outer",
|
|
"mcl_stairs:stair_stone_rough_outer",
|
|
"mcl_stairs:stair_stonebrick_outer",
|
|
}
|
|
|
|
local stair_content = {
|
|
{name = "mcl_core:lava_source"},
|
|
{name = "mcl_core:stone"},
|
|
{name = "mcl_core:stone"},
|
|
{name = "mcl_core:stone"},
|
|
{name = "mcl_core:stone"},
|
|
{name = "mcl_core:stone"},
|
|
{name = "mcl_core:stonebrick"},
|
|
{name = "mcl_nether:magma"},
|
|
{name = "mcl_nether:netherrack"},
|
|
{name = "mcl_nether:netherrack"},
|
|
}
|
|
|
|
local stair_content_bottom = {
|
|
{name = "mcl_nether:magma"},
|
|
{name = "mcl_nether:magma"},
|
|
{name = "mcl_nether:netherrack"},
|
|
{name = "mcl_nether:netherrack"},
|
|
{name = "mcl_nether:netherrack"},
|
|
{name = "mcl_nether:netherrack"},
|
|
}
|
|
|
|
local slabs = {
|
|
{name = "mcl_stairs:slab_stone"},
|
|
{name = "mcl_stairs:slab_stone"},
|
|
{name = "mcl_stairs:slab_stone"},
|
|
{name = "mcl_stairs:slab_stone"},
|
|
{name = "mcl_stairs:slab_stone"},
|
|
{name = "mcl_stairs:slab_stonebrick"},
|
|
{name = "mcl_stairs:slab_stonebrick"},
|
|
{name = "mcl_stairs:slab_stonebrickcracked"},
|
|
{name = "mcl_stairs:slab_stonebrickmossy"},
|
|
}
|
|
|
|
local stones = {
|
|
{name = "mcl_core:stone"},
|
|
{name = "mcl_core:stone"},
|
|
{name = "mcl_core:stone"},
|
|
{name = "mcl_core:cobble"},
|
|
{name = "mcl_core:mossycobble"},
|
|
}
|
|
|
|
local stair_selector = {
|
|
[-1] = {
|
|
[-1] = {
|
|
names = stair_outer_names,
|
|
param2 = 1,
|
|
},
|
|
[0] = {
|
|
names = stair_names,
|
|
param2 = 1,
|
|
},
|
|
[1] = {
|
|
names = stair_outer_names,
|
|
param2 = 2,
|
|
},
|
|
},
|
|
[0] = {
|
|
[-1] = {
|
|
names = stair_names,
|
|
param2 = 0,
|
|
},
|
|
[0] = {
|
|
names = stair_content,
|
|
},
|
|
[1] = {
|
|
names = stair_names,
|
|
param2 = 2,
|
|
},
|
|
},
|
|
[1] = {
|
|
[-1] = {
|
|
names = stair_outer_names,
|
|
param2 = 0,
|
|
},
|
|
[0] = {
|
|
names = stair_names,
|
|
param2 = 3,
|
|
},
|
|
[1] = {
|
|
names = stair_outer_names,
|
|
param2 = 3,
|
|
},
|
|
},
|
|
}
|
|
|
|
local stair_offset_from_bottom = 2
|
|
|
|
local function draw_stairs(pos, width, height, lift, orientation, pr, is_chain, param2)
|
|
|
|
local current_stair_content = stair_content
|
|
local current_stones = stones
|
|
|
|
local function set_ruined_node(pos, node)
|
|
if pr:next(1, 7) < 3 then return end
|
|
minetest_swap_node(pos, node)
|
|
return true
|
|
end
|
|
|
|
local param2 = param2
|
|
local mirror = param2 == 1 or param2 == 2
|
|
if mirror then
|
|
param2 = (param2 + 2) % 4
|
|
end
|
|
|
|
local chain_offset = is_chain and 1 or 0
|
|
|
|
local lift = lift + stair_offset_from_bottom
|
|
local slide_x = (1 - orientation)
|
|
local slide_z = orientation
|
|
local width = width + 2
|
|
local x1 = pos.x - (chain_offset + 1 ) * slide_x - 1
|
|
local x2 = pos.x + (chain_offset + width) * slide_x + 1
|
|
local z1 = pos.z - (chain_offset + 1 ) * slide_z - 1
|
|
local z2 = pos.z + (chain_offset + width) * slide_z + 1
|
|
local y1 = pos.y - stair_offset_from_bottom
|
|
local y2 = pos.y + lift - stair_offset_from_bottom
|
|
local stair_layer = true
|
|
local y = y2
|
|
local place_slabs = true
|
|
local x_key, z_key
|
|
local need_to_place_chest = true
|
|
local chest_pos
|
|
local bad_nodes_ratio = 0
|
|
while (y >= y1) or (bad_nodes_ratio > 0.07) do
|
|
local good_nodes_counter = 0
|
|
for x = x1, x2 do
|
|
x_key = (x == x1) and -1 or (x == x2) and 1 or 0
|
|
for z = z1, z2 do
|
|
local pos = {x = x, y = y, z = z}
|
|
if #minetest_find_nodes_in_area(pos, pos, stair_replacement_list, false) > 0 then
|
|
z_key = (z == z1) and -1 or (z == z2) and 1 or 0
|
|
local stair_coverage = (x_key ~= 0) or (z_key ~= 0)
|
|
if stair_coverage then
|
|
if stair_layer then
|
|
local stair = stair_selector[x_key][z_key]
|
|
local names = stair.names
|
|
set_ruined_node(pos, {name = names[pr:next(1, #names)], param2 = stair.param2})
|
|
elseif place_slabs then
|
|
set_ruined_node(pos, slabs[pr:next(1, #slabs)])
|
|
else
|
|
local placed = set_ruined_node(pos, current_stones[pr:next(1, #current_stones)])
|
|
if need_to_place_chest and placed then
|
|
chest_pos = {x = pos.x, y = pos.y + 1, z = pos.z}
|
|
minetest_swap_node(chest_pos, {name = "mcl_chests:chest_small"})
|
|
need_to_place_chest = false
|
|
end
|
|
end
|
|
elseif not stair_layer then
|
|
set_ruined_node(pos, current_stair_content[pr:next(1, #current_stair_content)])
|
|
end
|
|
else
|
|
good_nodes_counter = good_nodes_counter + 1
|
|
end
|
|
end
|
|
end
|
|
bad_nodes_ratio = 1 - good_nodes_counter / ((x2 - x1 + 1) * (z2 - z1 + 1))
|
|
if y >= y1 then
|
|
x1 = x1 - 1
|
|
x2 = x2 + 1
|
|
z1 = z1 - 1
|
|
z2 = z2 + 1
|
|
if (stair_layer or place_slabs) then
|
|
y = y - 1
|
|
if y <= y1 then
|
|
current_stair_content = stair_content_bottom
|
|
current_stones = stair_content_bottom
|
|
end
|
|
end
|
|
place_slabs = not place_slabs
|
|
stair_layer = false
|
|
else
|
|
place_slabs = false
|
|
y = y - 1
|
|
local dx1 = pr:next(0, 10)
|
|
if dx1 < 3 then x1 = x1 + dx1 end
|
|
local dx2 = pr:next(0, 10)
|
|
if dx2 < 3 then x2 = x2 - dx1 end
|
|
if x1 >= x2 then return chest_pos end
|
|
local dz1 = pr:next(0, 10)
|
|
if dz1 < 3 then z1 = z1 + dz1 end
|
|
local dz2 = pr:next(0, 10)
|
|
if dz2 < 3 then z2 = z2 - dz1 end
|
|
if z1 >= z2 then return chest_pos end
|
|
end
|
|
end
|
|
return chest_pos
|
|
end
|
|
|
|
local function enchant(stack, pr)
|
|
-- 75%-100% damage
|
|
mcl_enchanting.enchant_randomly(stack, 30, true, false, false, pr)
|
|
end
|
|
|
|
local function enchant_armor(stack, pr)
|
|
-- itemstack, enchantment_level, treasure, no_reduced_bonus_chance, ignore_already_enchanted, pr)
|
|
mcl_enchanting.enchant_randomly(stack, 30, false, false, false, pr)
|
|
end
|
|
|
|
local function place(pos, rotation, pr)
|
|
local width = pr:next(2, 10)
|
|
local height = pr:next(((width < 3) and 3 or 2), 10)
|
|
local lift = pr:next(0, 4)
|
|
local rotation = rotation or possible_rotations[pr:next(1, #possible_rotations)]
|
|
local orientation = rotation_to_orientation[rotation]
|
|
assert(orientation)
|
|
local param2 = rotation_to_param2[rotation]
|
|
assert(param2)
|
|
local is_chain = pr:next(1, 3) > 1
|
|
draw_trash(pos, width, height, lift, orientation, pr)
|
|
local chest_pos = draw_stairs(pos, width, height, lift, orientation, pr, is_chain, param2)
|
|
draw_frame({x = pos.x, y = pos.y + lift, z = pos.z}, width + 2, height + 2, orientation, pr, is_chain, rotation)
|
|
if not chest_pos then return end
|
|
|
|
local lootitems = mcl_loot.get_loot(
|
|
{
|
|
stacks_min = 4,
|
|
stacks_max = 8,
|
|
items = {
|
|
{itemstring = "mcl_core:iron_nugget", weight = 40, amount_min = 9, amount_max = 18},
|
|
{itemstring = "mcl_core:flint", weight = 40, amount_min = 9, amount_max = 18},
|
|
{itemstring = "mcl_core:obsidian", weight = 40, amount_min = 1, amount_max = 2},
|
|
{itemstring = "mcl_fire:fire_charge", weight = 40, amount_min = 1, amount_max = 1},
|
|
{itemstring = "mcl_fire:flint_and_steel", weight = 40, amount_min = 1, amount_max = 1},
|
|
{itemstring = "mcl_core:gold_nugget", weight = 15, amount_min = 4, amount_max = 24},
|
|
{itemstring = "mcl_core:apple_gold", weight = 15},
|
|
{itemstring = "mcl_tools:axe_gold", weight = 15, func = enchant},
|
|
{itemstring = "mcl_farming:hoe_gold", weight = 15, func = enchant},
|
|
{itemstring = "mcl_tools:pick_gold", weight = 15, func = enchant},
|
|
{itemstring = "mcl_tools:shovel_gold", weight = 15, func = enchant},
|
|
{itemstring = "mcl_tools:sword_gold", weight = 15, func = enchant},
|
|
{itemstring = "mcl_armor:helmet_gold", weight = 15, func = enchant_armor},
|
|
{itemstring = "mcl_armor:chestplate_gold", weight = 15, func = enchant_armor},
|
|
{itemstring = "mcl_armor:leggings_gold", weight = 15, func = enchant_armor},
|
|
{itemstring = "mcl_armor:boots_gold", weight = 15, func = enchant_armor},
|
|
{itemstring = "mcl_potions:speckled_melon", weight = 5, amount_min = 4, amount_max = 12},
|
|
{itemstring = "mcl_farming:carrot_item_gold", weight = 5, amount_min = 4, amount_max = 12},
|
|
{itemstring = "mcl_core:gold_ingot", weight = 5, amount_min = 2, amount_max = 8},
|
|
{itemstring = "mcl_clock:clock", weight = 5},
|
|
{itemstring = "mesecons_pressureplates:pressure_plate_gold_off", weight = 5},
|
|
{itemstring = "mobs_mc:gold_horse_armor", weight = 5},
|
|
{itemstring = "mcl_core:goldblock", weight = 1, amount_min = 1, amount_max = 2},
|
|
{itemstring = "mcl_bells:bell", weight = 1},
|
|
{itemstring = "mcl_core:apple_gold_enchanted", weight = 1},
|
|
}
|
|
},
|
|
pr
|
|
)
|
|
mcl_structures.init_node_construct(chest_pos)
|
|
local meta = minetest.get_meta(chest_pos)
|
|
local inv = meta:get_inventory()
|
|
mcl_loot.fill_inventory(inv, "main", lootitems, pr)
|
|
end
|
|
|
|
local function get_place_rank(pos)
|
|
local x, y, z = pos.x, pos.y, pos.z
|
|
local p1 = {x = x , y = y, z = z }
|
|
local p2 = {x = x + 7, y = y, z = z + 7}
|
|
local air_pos_list_surface = #minetest_find_nodes_in_area(p1, p2, "air", false)
|
|
p1.y = p1.y - 1
|
|
p2.y = p2.y - 1
|
|
local opaque_pos_list_surface = #minetest_find_nodes_in_area(p1, p2, "group:opaque", false)
|
|
return air_pos_list_surface + 3 * opaque_pos_list_surface
|
|
end
|
|
|
|
mcl_structures.register_structure({
|
|
name = "ruined_portal",
|
|
decoration = {
|
|
deco_type = "simple",
|
|
flags = "all_floors",
|
|
fill_ratio = scanning_ratio,
|
|
height = 1,
|
|
place_on = {"mcl_core:sand", "mcl_core:dirt_with_grass", "mcl_core:water_source", "mcl_core:dirt_with_grass_snow"},
|
|
},
|
|
on_finished_chunk = function(minp, maxp, seed, vm_context, pos_list)
|
|
if maxp.y < mcl_mapgen.overworld.min then return end
|
|
local pr = PseudoRandom(seed + random_offset)
|
|
local random_number = pr:next(1, chance_per_chunk)
|
|
local noise = mcl_structures_get_perlin_noise_level(minp) * noise_multiplier
|
|
if (random_number + noise) < struct_threshold then return end
|
|
local pos = pos_list[1]
|
|
if #pos_list > 1 then
|
|
local count = get_place_rank(pos)
|
|
for i = 2, #pos_list do
|
|
local pos_i = pos_list[i]
|
|
local count_i = get_place_rank(pos_i)
|
|
if count_i > count then
|
|
count = count_i
|
|
pos = pos_i
|
|
end
|
|
end
|
|
end
|
|
place(pos, nil, pr)
|
|
end,
|
|
place_function = place,
|
|
})
|