forked from VoxeLibre/VoxeLibre
532 lines
17 KiB
Lua
532 lines
17 KiB
Lua
mcl_spawn = {}
|
|
|
|
local S = minetest.get_translator("mcl_spawn")
|
|
local mg_name = minetest.get_mapgen_setting("mg_name")
|
|
local storage = minetest.get_mod_storage()
|
|
|
|
-- Parameters
|
|
-------------
|
|
|
|
local respawn_search_interval = 30 -- seconds
|
|
local respawn_search_initial_delay = 30 -- seconds
|
|
local trees_distance_max = 30 -- nodes
|
|
local attempts_to_find_pos = 50
|
|
local attempts_to_find_trees = 50
|
|
local node_groups_white_list = {"group:soil"}
|
|
local biomes_white_list = {
|
|
"ColdTaiga",
|
|
"Taiga",
|
|
"MegaTaiga",
|
|
"MegaSpruceTaiga",
|
|
"Plains",
|
|
"SunflowerPlains",
|
|
"Forest",
|
|
"FlowerForest",
|
|
"BirchForest",
|
|
"BirchForestM",
|
|
"Jungle",
|
|
"JungleM",
|
|
"JungleEdge",
|
|
"JungleEdgeM",
|
|
"Savanna",
|
|
"SavannaM",
|
|
}
|
|
|
|
-- Resolution of search grid in nodes.
|
|
local res = 64
|
|
local half_res = 32 -- for emerge areas around the position
|
|
local alt_min = -10
|
|
local alt_max = 200
|
|
-- Number of points checked in the square search grid (edge * edge).
|
|
local checks = 128 * 128
|
|
-- Starting point for biome checks. This also sets the y co-ordinate for all
|
|
-- points checked, so the suitable biomes must be active at this y.
|
|
local start_pos = minetest.setting_get_pos("static_spawnpoint") or {x = 0, y = 8, z = 0}
|
|
-- Table of suitable biomes
|
|
local biome_ids = {}
|
|
|
|
local no_trees_area_counter = 0
|
|
|
|
-- Bed spawning offsets
|
|
local node_search_list =
|
|
{
|
|
--[[1]] {x = 0, y = 0, z = -1}, --
|
|
--[[2]] {x = -1, y = 0, z = 0}, --
|
|
--[[3]] {x = -1, y = 0, z = 1}, --
|
|
--[[4]] {x = 0, y = 0, z = 2}, -- z^ 8 4 9
|
|
--[[5]] {x = 1, y = 0, z = 1}, -- | 3 5
|
|
--[[6]] {x = 1, y = 0, z = 0}, -- | 2 * 6
|
|
--[[7]] {x = -1, y = 0, z = -1}, -- | 7 1 A
|
|
--[[8]] {x = -1, y = 0, z = 2}, -- +----->
|
|
--[[9]] {x = 1, y = 0, z = 2}, -- x
|
|
--[[A]] {x = 1, y = 0, z = -1}, --
|
|
--[[B]] {x = 0, y = 1, z = 0}, --
|
|
--[[C]] {x = 0, y = 1, z = 1}, --
|
|
}
|
|
|
|
-- End of parameters
|
|
--------------------
|
|
|
|
|
|
-- Initial variables
|
|
|
|
local success = storage:get_int("mcl_spawn_success")==1
|
|
local searched = (storage:get_int("mcl_spawn_searched")==1) or mg_name == "v6" or mg_name == "singlenode" or minetest.settings:get("static_spawnpoint")
|
|
local wsp = minetest.string_to_pos(storage:get_string("mcl_spawn_world_spawn_point")) or {} -- world spawn position
|
|
local check = storage:get_int("mcl_spawn_check") or 0
|
|
local cp = minetest.string_to_pos(storage:get_string("mcl_spawn_cp")) or {x=start_pos.x, y=start_pos.y, z=start_pos.z}
|
|
local edge_len = storage:get_int("mcl_spawn_edge_len") or 1
|
|
local edge_dist = storage:get_int("mcl_spawn_edge_dist") or 0
|
|
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
|
|
|
|
-- Get world 'mapgen_limit' and 'chunksize' to calculate 'spawn_limit'.
|
|
-- This accounts for how mapchunks are not generated if they or their shell exceed
|
|
-- 'mapgen_limit'.
|
|
|
|
local mapgen_limit = tonumber(minetest.get_mapgen_setting("mapgen_limit"))
|
|
local chunksize = tonumber(minetest.get_mapgen_setting("chunksize"))
|
|
local spawn_limit = math.max(mapgen_limit - (chunksize + 1) * 16, 0)
|
|
|
|
|
|
--Functions
|
|
-----------
|
|
|
|
local function get_far_node(pos)
|
|
local node = minetest.get_node(pos)
|
|
if node.name ~= "ignore" then
|
|
return node
|
|
end
|
|
minetest.get_voxel_manip():read_from_map(pos, pos)
|
|
return minetest.get_node(pos)
|
|
end
|
|
|
|
local function get_trees(pos, pos2)
|
|
if emerge_pos1 and emerge_pos2 and pos then
|
|
if not pos2 then
|
|
local b1 = {x = math.max(pos.x-trees_distance_max, emerge_pos1.x), y = math.max(pos.y-trees_distance_max, emerge_pos1.y), z = math.max(pos.z-trees_distance_max, emerge_pos1.z)}
|
|
local b2 = {x = math.min(pos.x+trees_distance_max, emerge_pos2.x), y = math.min(pos.y+trees_distance_max, emerge_pos2.y), z = math.min(pos.z+trees_distance_max, emerge_pos2.z)}
|
|
return minetest.find_nodes_in_area(b1, b2, {"group:tree"}, false)
|
|
else
|
|
local b1 = {x = math.max(pos.x , emerge_pos1.x), y = math.max(pos.y , emerge_pos1.y), z = math.max(pos.z, emerge_pos1.z)}
|
|
local b2 = {x = math.min(pos2.x, emerge_pos2.x), y = math.min(pos2.y, emerge_pos2.y), z = math.min(pos2.z, emerge_pos2.z)}
|
|
return minetest.find_nodes_in_area(b1, b2, {"group:tree"}, false)
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local function good_for_respawn(pos, player)
|
|
local pos0 = {x = pos.x, y = pos.y - 1, z = pos.z}
|
|
local pos1 = {x = pos.x, y = pos.y, z = pos.z}
|
|
local pos2 = {x = pos.x, y = pos.y + 1, z = pos.z}
|
|
local node0 = get_far_node(pos0)
|
|
local node1 = get_far_node(pos1)
|
|
local node2 = get_far_node(pos2)
|
|
|
|
local nn0, nn1, nn2 = node0.name, node1.name, node2.name
|
|
if minetest.get_item_group(nn0, "destroys_items") ~=0
|
|
or minetest.get_item_group(nn1, "destroys_items") ~=0
|
|
or minetest.get_item_group(nn2, "destroys_items") ~=0
|
|
or minetest.get_item_group(nn0, "portal") ~=0
|
|
or minetest.get_item_group(nn1, "portal") ~=0
|
|
or minetest.get_item_group(nn2, "portal") ~=0
|
|
or minetest.is_protected(pos0, player or "")
|
|
or minetest.is_protected(pos1, player or "")
|
|
or minetest.is_protected(pos2, player or "")
|
|
or (not player and minetest.get_node_light(pos1, 0.5) < 8)
|
|
or (not player and minetest.get_node_light(pos2, 0.5) < 8)
|
|
or nn0 == "ignore"
|
|
or nn1 == "ignore"
|
|
or nn2 == "ignore"
|
|
then
|
|
return false
|
|
end
|
|
|
|
local def0 = minetest.registered_nodes[nn0]
|
|
local def1 = minetest.registered_nodes[nn1]
|
|
local def2 = minetest.registered_nodes[nn2]
|
|
return def0.walkable and (not def1.walkable) and (not def2.walkable) and
|
|
(def1.damage_per_second == nil or def2.damage_per_second <= 0) and
|
|
(def1.damage_per_second == nil or def2.damage_per_second <= 0)
|
|
end
|
|
|
|
local function can_find_tree(pos1, trees)
|
|
if not emerge_pos1 or not emerge_pos2 then return false end
|
|
local trees = trees or get_trees(pos1)
|
|
if not trees then return false end
|
|
|
|
if (attempts_to_find_trees * 3 < #trees) then
|
|
-- random search
|
|
for i = 1, attempts_to_find_trees do
|
|
local pos2 = trees[math.random(1,#trees)]
|
|
if not minetest.is_protected(pos2, "") then
|
|
if pos2.x < pos1.x then
|
|
pos2.x = pos2.x + 1
|
|
elseif pos2.x > pos1.x then
|
|
pos2.x = pos2.x - 1
|
|
end
|
|
if pos2.z < pos1.z then
|
|
pos2.z = pos2.z + 1
|
|
elseif pos2.z > pos1.z then
|
|
pos2.z = pos2.z - 1
|
|
end
|
|
local way = minetest.find_path(pos1, pos2, res, 1, 3, "A*_noprefetch")
|
|
if way then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
for i, pos2 in ipairs(trees) do
|
|
-- full search
|
|
if not minetest.is_protected(pos2, "") then
|
|
if pos2.x < pos1.x then
|
|
pos2.x = pos2.x + 1
|
|
elseif pos2.x > pos1.x then
|
|
pos2.x = pos2.x - 1
|
|
end
|
|
if pos2.z < pos1.z then
|
|
pos2.z = pos2.z + 1
|
|
elseif pos2.z > pos1.z then
|
|
pos2.z = pos2.z - 1
|
|
end
|
|
local way = minetest.find_path(pos1, pos2, res, 1, 3, "A*_noprefetch")
|
|
if way then
|
|
return true
|
|
end
|
|
end
|
|
if i > attempts_to_find_trees then return false end
|
|
end
|
|
return false
|
|
end
|
|
|
|
local function next_pos()
|
|
if edge_dist >= edge_len then
|
|
edge_dist = 1
|
|
dir_ind = (dir_ind % 4) + 1
|
|
dir_step = dir_step + 1
|
|
edge_len = math.floor(dir_step / 2) + 1
|
|
else
|
|
edge_dist = edge_dist + 1
|
|
end
|
|
if dir_ind==1 then
|
|
cp.z = cp.z + res
|
|
elseif dir_ind==2 then
|
|
cp.x = cp.x - res
|
|
elseif dir_ind==3 then
|
|
cp.z = cp.z - res
|
|
else
|
|
cp.x = cp.x + res
|
|
end
|
|
end
|
|
|
|
-- Spawn position search
|
|
|
|
local function next_biome()
|
|
if #biome_ids < 1 then
|
|
for _, biome_name in pairs(biomes_white_list) do
|
|
local biome_id = minetest.get_biome_id(biome_name)
|
|
if biome_id then
|
|
table.insert(biome_ids, biome_id)
|
|
end
|
|
end
|
|
if #biome_ids < 1 then
|
|
next_pos()
|
|
if math.abs(cp.x) > spawn_limit or math.abs(cp.z) > spawn_limit then
|
|
check = checks + 1
|
|
minetest.log("warning", "[mcl_spawn] No white-listed biomes found - search stopped by overlimit")
|
|
return false
|
|
end
|
|
check = check + 1
|
|
cp.y = minetest.get_spawn_level(cp.x, cp.z) or start_pos.y
|
|
if cp.y then
|
|
wsp = {x = cp.x, y = cp.y, z = cp.z}
|
|
minetest.log("warning", "[mcl_spawn] No white-listed biomes found - using current")
|
|
return true
|
|
else
|
|
minetest.log("warning", "[mcl_spawn] No white-listed biomes found and spawn level is nil - please define start_pos to continue")
|
|
return false
|
|
end
|
|
end
|
|
minetest.log("action", "[mcl_spawn] Suitable biomes found: "..tostring(#biome_ids))
|
|
end
|
|
while check <= checks do
|
|
local biome_data = minetest.get_biome_data(cp)
|
|
-- Sometimes biome_data is nil
|
|
local biome = biome_data and biome_data.biome
|
|
if biome then
|
|
minetest.log("verbose", "[mcl_spawn] Search white-listed biome at "..minetest.pos_to_string(cp)..": "..minetest.get_biome_name(biome))
|
|
for _, biome_id in ipairs(biome_ids) do
|
|
if biome == biome_id then
|
|
cp.y = minetest.get_spawn_level(cp.x, cp.z) or start_pos.y
|
|
if cp.y then
|
|
wsp = {x = cp.x, y = cp.y, z = cp.z}
|
|
return true
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
next_pos()
|
|
|
|
-- Check for position being outside world edge
|
|
if math.abs(cp.x) > spawn_limit or math.abs(cp.z) > spawn_limit then
|
|
check = checks + 1
|
|
return false
|
|
end
|
|
|
|
check = check + 1
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
local function ecb_search_continue(blockpos, action, calls_remaining, param)
|
|
if calls_remaining <= 0 then
|
|
emerge_pos1 = {x = wsp.x-half_res, y = alt_min, z = wsp.z-half_res}
|
|
emerge_pos2 = {x = wsp.x+half_res, y = alt_max, z = wsp.z+half_res}
|
|
local nodes = minetest.find_nodes_in_area_under_air(emerge_pos1, emerge_pos2, node_groups_white_list)
|
|
minetest.log("verbose", "[mcl_spawn] Data emerge callback: "..minetest.pos_to_string(wsp).." - "..tostring(nodes and #nodes) .. " node(s) found under air")
|
|
if nodes then
|
|
if no_trees_area_counter >= 0 then
|
|
local trees = get_trees(emerge_pos1, emerge_pos2)
|
|
if trees and #trees > 0 then
|
|
no_trees_area_counter = 0
|
|
if attempts_to_find_pos * 3 < #nodes then
|
|
-- random
|
|
for i=1, attempts_to_find_pos do
|
|
wsp = nodes[math.random(1,#nodes)]
|
|
if wsp then
|
|
wsp.y = wsp.y + 1
|
|
if good_for_respawn(wsp) and can_find_tree(wsp, trees) then
|
|
minetest.log("action", "[mcl_spawn] Dynamic world spawn randomly determined to be "..minetest.pos_to_string(wsp))
|
|
searched = true
|
|
success = true
|
|
return
|
|
end
|
|
end
|
|
end
|
|
else
|
|
-- in a sequence
|
|
for i=1, math.min(#nodes, attempts_to_find_pos) do
|
|
wsp = nodes[i]
|
|
if wsp then
|
|
wsp.y = wsp.y + 1
|
|
if good_for_respawn(wsp) and can_find_tree(wsp, trees) then
|
|
minetest.log("action", "[mcl_spawn] Dynamic world spawn determined to be "..minetest.pos_to_string(wsp))
|
|
searched = true
|
|
success = true
|
|
return
|
|
end
|
|
end
|
|
end
|
|
end
|
|
else
|
|
no_trees_area_counter = no_trees_area_counter + 1
|
|
if no_trees_area_counter > 10 then
|
|
minetest.log("verbose", "[mcl_spawn] More than 10 times no trees at all! Won't search trees next 200 calls")
|
|
no_trees_area_counter = -200
|
|
end
|
|
end
|
|
else -- seems there are no trees but we'll check it later, after next 200 calls
|
|
no_trees_area_counter = no_trees_area_counter + 1
|
|
if attempts_to_find_pos * 3 < #nodes then
|
|
-- random
|
|
for i=1, attempts_to_find_pos do
|
|
wsp = nodes[math.random(1,#nodes)]
|
|
if wsp then
|
|
wsp.y = wsp.y + 1
|
|
if good_for_respawn(wsp) then
|
|
minetest.log("action", "[mcl_spawn] Dynamic world spawn randomly determined to be "..minetest.pos_to_string(wsp) .. " (no trees)")
|
|
searched = true
|
|
success = true
|
|
return
|
|
end
|
|
end
|
|
end
|
|
else
|
|
-- in a sequence
|
|
for i=1, math.min(#nodes, attempts_to_find_pos) do
|
|
wsp = nodes[i]
|
|
if wsp then
|
|
wsp.y = wsp.y + 1
|
|
if good_for_respawn(wsp) then
|
|
minetest.log("action", "[mcl_spawn] Dynamic world spawn determined to be "..minetest.pos_to_string(wsp) .. " (no trees)")
|
|
searched = true
|
|
success = true
|
|
return
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
next_pos()
|
|
mcl_spawn.search()
|
|
end
|
|
end
|
|
|
|
function mcl_spawn.search()
|
|
if not next_biome() or check > checks then
|
|
return false
|
|
end
|
|
check = check + 1
|
|
if not wsp.y then
|
|
wsp.y = 8
|
|
end
|
|
local pos1 = {x = wsp.x-half_res, y = alt_min, z = wsp.z-half_res}
|
|
local pos2 = {x = wsp.x+half_res, y = alt_max, z = wsp.z+half_res}
|
|
minetest.emerge_area(pos1, pos2, ecb_search_continue)
|
|
end
|
|
|
|
|
|
mcl_spawn.get_world_spawn_pos = function()
|
|
local ssp = minetest.setting_get_pos("static_spawnpoint")
|
|
if ssp then
|
|
return ssp
|
|
end
|
|
if success then
|
|
return wsp
|
|
end
|
|
minetest.log("action", "[mcl_spawn] Failed to determine dynamic world spawn!")
|
|
return start_pos
|
|
end
|
|
|
|
-- Returns a spawn position of player.
|
|
-- If player is nil or not a player, a world spawn point is returned.
|
|
-- The second return value is true if returned spawn point is player-chosen,
|
|
-- false otherwise.
|
|
mcl_spawn.get_bed_spawn_pos = function(player)
|
|
local spawn, custom_spawn = nil, false
|
|
if player ~= nil and player:is_player() then
|
|
local attr = player:get_meta():get_string("mcl_beds:spawn")
|
|
if attr ~= nil and attr ~= "" then
|
|
spawn = minetest.string_to_pos(attr)
|
|
custom_spawn = true
|
|
end
|
|
end
|
|
if not spawn or spawn == "" then
|
|
spawn = mcl_spawn.get_world_spawn_pos()
|
|
custom_spawn = false
|
|
end
|
|
return spawn, custom_spawn
|
|
end
|
|
|
|
-- Sets the player's spawn position to pos.
|
|
-- Set pos to nil to clear the spawn position.
|
|
-- If message is set, informs the player with a chat message when the spawn position
|
|
-- changed.
|
|
mcl_spawn.set_spawn_pos = function(player, pos, message)
|
|
local spawn_changed = false
|
|
local meta = player:get_meta()
|
|
if pos == nil then
|
|
if meta:get_string("mcl_beds:spawn") ~= "" then
|
|
spawn_changed = true
|
|
if message then
|
|
minetest.chat_send_player(player:get_player_name(), S("Respawn position cleared!"))
|
|
end
|
|
end
|
|
meta:set_string("mcl_beds:spawn", "")
|
|
else
|
|
local oldpos = minetest.string_to_pos(meta:get_string("mcl_beds:spawn"))
|
|
meta:set_string("mcl_beds:spawn", minetest.pos_to_string(pos))
|
|
if oldpos then
|
|
-- We don't bother sending a message if the new spawn pos is basically the same
|
|
spawn_changed = vector.distance(pos, oldpos) > 0.1
|
|
else
|
|
-- If it wasn't set and now it will be set, it means it is changed
|
|
spawn_changed = true
|
|
end
|
|
if spawn_changed and message then
|
|
minetest.chat_send_player(player:get_player_name(), S("New respawn position set!"))
|
|
end
|
|
end
|
|
return spawn_changed
|
|
end
|
|
|
|
mcl_spawn.get_player_spawn_pos = function(player)
|
|
local pos, custom_spawn = mcl_spawn.get_bed_spawn_pos(player)
|
|
if pos and custom_spawn then
|
|
-- Check if bed is still there
|
|
local node_bed = get_far_node(pos)
|
|
local bgroup = minetest.get_item_group(node_bed.name, "bed")
|
|
if bgroup ~= 1 and bgroup ~= 2 then
|
|
-- Bed is destroyed:
|
|
if player ~= nil and player:is_player() then
|
|
player:get_meta():set_string("mcl_beds:spawn", "")
|
|
end
|
|
minetest.chat_send_player(player:get_player_name(), S("Your spawn bed was missing or blocked."))
|
|
return mcl_spawn.get_world_spawn_pos(), false
|
|
end
|
|
|
|
-- Find spawning position on/near the bed free of solid or damaging blocks iterating a square spiral 15x15:
|
|
|
|
local dir = minetest.facedir_to_dir(minetest.get_node(pos).param2)
|
|
local offset
|
|
for _, o in ipairs(node_search_list) do
|
|
if dir.z == -1 then
|
|
offset = {x = o.x, y = o.y, z = o.z}
|
|
elseif dir.z == 1 then
|
|
offset = {x = -o.x, y = o.y, z = -o.z}
|
|
elseif dir.x == -1 then
|
|
offset = {x = o.z, y = o.y, z = -o.x}
|
|
else -- dir.x == 1
|
|
offset = {x = -o.z, y = o.y, z = o.x}
|
|
end
|
|
local player_spawn_pos = vector.add(pos, offset)
|
|
if good_for_respawn(player_spawn_pos, player:get_player_name()) then
|
|
return player_spawn_pos, true
|
|
end
|
|
end
|
|
-- We here if we didn't find suitable place for respawn
|
|
end
|
|
return mcl_spawn.get_world_spawn_pos(), false
|
|
end
|
|
|
|
mcl_spawn.spawn = function(player)
|
|
local pos, in_bed = mcl_spawn.get_player_spawn_pos(player)
|
|
player:set_pos(pos)
|
|
return in_bed or success
|
|
end
|
|
|
|
-- Respawn player at specified respawn position
|
|
minetest.register_on_respawnplayer(mcl_spawn.spawn)
|
|
|
|
function mcl_spawn.shadow_worker()
|
|
if not searched then
|
|
searched = true
|
|
mcl_spawn.search()
|
|
minetest.log("action", "[mcl_spawn] Started world spawn point search")
|
|
end
|
|
if success and ((not good_for_respawn(wsp)) or (not can_find_tree(wsp))) then
|
|
success = false
|
|
minetest.log("action", "[mcl_spawn] World spawn position isn't safe anymore: "..minetest.pos_to_string(wsp))
|
|
mcl_spawn.search()
|
|
end
|
|
|
|
minetest.after(respawn_search_interval, mcl_spawn.shadow_worker)
|
|
end
|
|
|
|
minetest.after(respawn_search_initial_delay, function()
|
|
mcl_spawn.shadow_worker()
|
|
|
|
minetest.register_on_shutdown(function()
|
|
storage:set_int("mcl_spawn_success", success and 1 or 0)
|
|
if wsp and wsp.x then
|
|
storage:set_string("mcl_spawn_world_spawn_point", minetest.pos_to_string(wsp))
|
|
end
|
|
storage:set_int("mcl_spawn_searched", searched and 1 or 0)
|
|
storage:set_int("mcl_spawn_check", check)
|
|
storage:set_string("mcl_spawn_cp", minetest.pos_to_string(cp))
|
|
storage:set_int("mcl_spawn_edge_len", edge_len)
|
|
storage:set_int("mcl_spawn_edge_dist", edge_dist)
|
|
storage:set_int("mcl_spawn_dir_step", dir_step)
|
|
storage:set_int("mcl_spawn_dir_ind", dir_ind)
|
|
end)
|
|
end)
|