subterrane/player_spawn.lua

local sidelen = mapgen_helper.block_size

local snap_to_minp = function(ydepth)
	return ydepth - (ydepth+32) % sidelen -- put ydepth at the minp.y of mapblocks
end

function subterrane:register_cave_spawn(cave_layer_def, start_depth)
	minetest.register_on_newplayer(function(player)
		local ydepth = snap_to_minp(start_depth or cave_layer_def.y_max)
		local spawned = false
		while spawned ~= true do
			spawned = spawnplayer(cave_layer_def, player, ydepth)
			ydepth = ydepth - sidelen
			if ydepth < cave_layer_def.y_min then
				ydepth = snap_to_minp(cave_layer_def.y_max)
			end
		end
	end)

	minetest.register_on_respawnplayer(function(player)
		local ydepth = snap_to_minp(start_depth or cave_layer_def.y_max)
		local spawned = false
		while spawned ~= true do
			spawned = spawnplayer(cave_layer_def, player, ydepth)
			ydepth = ydepth - sidelen
			if ydepth < cave_layer_def.y_min then
				ydepth = snap_to_minp(cave_layer_def.y_max)
			end
		end
		return true
	end)
end

local outside_region = 0
local inside_ground = 1
local inside_cavern = 2

-- Spawn player underground in a giant cavern
function spawnplayer(cave_layer_def, player, ydepth)
	subterrane.set_defaults(cave_layer_def)

	local YMIN = cave_layer_def.y_min
	local YMAX = cave_layer_def.y_max
	local BLEND = math.min(cave_layer_def.boundary_blend_range, (YMAX-YMIN)/2)

	local TCAVE = cave_layer_def.cave_threshold
	
	local np_cave = cave_layer_def.perlin_cave
	local np_wave = cave_layer_def.perlin_wave
	
	local y_blend_min = YMIN + BLEND * 1.5
	local y_blend_max = YMAX - BLEND * 1.5	
	
	local column_def = cave_layer_def.columns
	local double_frequency = cave_layer_def.double_frequency

	local options = {}

	for chunk = 1, 64 do
		minetest.log("info", "[subterrane] searching for spawn "..chunk)
				
		local minp = {x = sidelen * math.random(-32, 32) - 32, z = sidelen * math.random(-32, 32) - 32, y = ydepth}
		local maxp = {x = minp.x + sidelen - 1, z = minp.z + sidelen - 1, y = ydepth + sidelen - 1}

		local nvals_cave, cave_area = mapgen_helper.perlin3d("subterrane:cave", minp, maxp, np_cave) --cave noise for structure
		local nvals_wave = mapgen_helper.perlin3d("subterrane:wave", minp, maxp, np_wave) --wavy structure of cavern ceilings and floors

		-- pre-average everything
		for vi, value in ipairs(nvals_cave) do
			nvals_cave[vi] = (value + nvals_wave[vi])/2
		end
		local column_points = nil
		local column_weight = nil		
		
		local previous_y = minp.y
		local previous_node_state = outside_region
	
		for vi, x, y, z in cave_area:iterp_yxz(vector.add(minp, 2), vector.subtract(maxp, 2)) do
			
			if y < previous_y then
				previous_node_state = outside_region
			end
			previous_y = y
			
			local cave_local_threshold
			if y < y_blend_min then
				cave_local_threshold = TCAVE + ((y_blend_min - y) / BLEND) ^ 2
			elseif y > y_blend_max then
				cave_local_threshold = TCAVE + ((y - y_blend_max) / BLEND) ^ 2
			else
				cave_local_threshold = TCAVE
			end

			local cave_value = nvals_cave[vi]
			if double_frequency then
				cave_value = math.abs(cave_value)
			end			
		
			-- inside a giant cavern
			if cave_value > cave_local_threshold then
				local column_value = 0
				local inside_column = false
				if column_def then
					if column_points == nil then
						column_points = subterrane.get_column_points(minp, maxp, column_def)
						column_weight = column_def.weight
					end
					column_value = subterrane.get_column_value({x=x, y=y, z=z}, column_points)
				end
				inside_column =  column_value > 0 and cave_value - column_value * column_weight < cave_local_threshold
				if previous_node_state == inside_ground and not inside_column then
					-- we just entered the cavern from below. Do a quick check for head space.
					local val_above = nvals_cave[vi+cave_area.ystride]
					if double_frequency then
						val_above = math.abs(val_above)
					end
					if val_above > cave_local_threshold then
						table.insert(options, {x=x, y=y+1, z=z})
					end
				end
				if not inside_column then
					previous_node_state = inside_cavern
				else
					previous_node_state = inside_ground
				end

			else
				previous_node_state = inside_ground
			end
		end

		if table.getn(options) > 20 then -- minimum 20 to ensure the player is put in a place with a modicum of size
			local choice = math.random(1, table.getn(options))
			local spawnpoint = options[ choice ]
			minetest.log("action", "[subterrane] spawning player " .. minetest.pos_to_string(spawnpoint))
			player:setpos(spawnpoint)
			return true
		end
	end
	return false
end