454 lines
11 KiB
Lua
454 lines
11 KiB
Lua
|
|
local reverse = true
|
|
|
|
local function destruct_bed(pos, n)
|
|
local node = minetest.get_node(pos)
|
|
local other
|
|
|
|
if n == 2 then
|
|
local dir = minetest.facedir_to_dir(node.param2)
|
|
other = vector.subtract(pos, dir)
|
|
elseif n == 1 then
|
|
local dir = minetest.facedir_to_dir(node.param2)
|
|
other = vector.add(pos, dir)
|
|
end
|
|
|
|
if reverse then
|
|
reverse = not reverse
|
|
minetest.remove_node(other)
|
|
minetest.check_for_falling(other)
|
|
else
|
|
reverse = not reverse
|
|
end
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
local pi = math.pi
|
|
local player_in_bed = 0
|
|
local is_sp = minetest.is_singleplayer()
|
|
local enable_respawn = minetest.settings:get_bool("enable_bed_respawn")
|
|
if enable_respawn == nil then
|
|
enable_respawn = true
|
|
end
|
|
|
|
-- Helper functions
|
|
|
|
local function get_look_yaw(pos)
|
|
local rotation = minetest.get_node(pos).param2
|
|
if rotation > 3 then
|
|
rotation = rotation % 4 -- Mask colorfacedir values
|
|
end
|
|
if rotation == 1 then
|
|
return pi / 2, rotation
|
|
elseif rotation == 3 then
|
|
return -pi / 2, rotation
|
|
elseif rotation == 0 then
|
|
return pi, rotation
|
|
else
|
|
return 0, rotation
|
|
end
|
|
end
|
|
|
|
local function is_night_skip_enabled()
|
|
local enable_night_skip = minetest.settings:get_bool("enable_bed_night_skip")
|
|
if enable_night_skip == nil then
|
|
enable_night_skip = true
|
|
end
|
|
return enable_night_skip
|
|
end
|
|
|
|
local function check_in_beds(players)
|
|
local in_bed = beds.player
|
|
if not players then
|
|
players = minetest.get_connected_players()
|
|
end
|
|
|
|
for n, player in ipairs(players) do
|
|
local name = player:get_player_name()
|
|
if not in_bed[name] then
|
|
return false
|
|
end
|
|
end
|
|
|
|
return #players > 0
|
|
end
|
|
|
|
local function lay_down(player, pos, bed_pos, state, skip)
|
|
local name = player:get_player_name()
|
|
local hud_flags = player:hud_get_flags()
|
|
|
|
if not player or not name then
|
|
return
|
|
end
|
|
|
|
-- stand up
|
|
if state ~= nil and not state then
|
|
local p = beds.pos[name] or nil
|
|
if beds.player[name] ~= nil then
|
|
beds.player[name] = nil
|
|
beds.bed_position[name] = nil
|
|
player_in_bed = player_in_bed - 1
|
|
end
|
|
-- skip here to prevent sending player specific changes (used for leaving players)
|
|
if skip then
|
|
return
|
|
end
|
|
if p then
|
|
player:set_pos(p)
|
|
end
|
|
|
|
-- physics, eye_offset, etc
|
|
player:set_eye_offset({x = 0, y = 0, z = 0}, {x = 0, y = 0, z = 0})
|
|
player:set_look_horizontal(math.random(1, 180) / 100)
|
|
player_api.player_attached[name] = false
|
|
player:set_physics_override(1, 1, 1)
|
|
hud_flags.wielditem = true
|
|
player_api.set_animation(player, "stand" , 30)
|
|
|
|
-- lay down
|
|
else
|
|
beds.player[name] = 1
|
|
beds.pos[name] = pos
|
|
beds.bed_position[name] = bed_pos
|
|
player_in_bed = player_in_bed + 1
|
|
|
|
-- physics, eye_offset, etc
|
|
player:set_eye_offset({x = 0, y = -13, z = 0}, {x = 0, y = 0, z = 0})
|
|
local yaw, param2 = get_look_yaw(bed_pos)
|
|
player:set_look_horizontal(yaw)
|
|
local dir = minetest.facedir_to_dir(param2)
|
|
local p = {x = bed_pos.x + dir.x / 2, y = bed_pos.y, z = bed_pos.z + dir.z / 2}
|
|
player:set_physics_override(0, 0, 0)
|
|
player:set_pos(p)
|
|
player_api.player_attached[name] = true
|
|
hud_flags.wielditem = false
|
|
player_api.set_animation(player, "lay" , 0)
|
|
end
|
|
|
|
player:hud_set_flags(hud_flags)
|
|
end
|
|
|
|
local function update_formspecs(finished)
|
|
local ges = #minetest.get_connected_players()
|
|
local form_n
|
|
local is_majority = (ges / 2) < player_in_bed
|
|
|
|
if finished then
|
|
form_n = beds.formspec .. "label[2.7,9; Good morning.]"
|
|
else
|
|
form_n = beds.formspec .. "label[2.2,9;" .. tostring(player_in_bed) ..
|
|
" of " .. tostring(ges) .. " players are in bed]"
|
|
if is_majority and is_night_skip_enabled() then
|
|
form_n = form_n .. "button_exit[2,6;4,0.75;force;Force night skip]"
|
|
end
|
|
end
|
|
|
|
for name,_ in pairs(beds.player) do
|
|
minetest.show_formspec(name, "beds_form", form_n)
|
|
end
|
|
end
|
|
|
|
|
|
-- Public functions
|
|
|
|
function beds.kick_players()
|
|
for name, _ in pairs(beds.player) do
|
|
local player = minetest.get_player_by_name(name)
|
|
lay_down(player, nil, nil, false)
|
|
end
|
|
end
|
|
|
|
function beds.skip_night()
|
|
minetest.set_timeofday(0.23)
|
|
end
|
|
|
|
function beds.on_rightclick(pos, player)
|
|
local name = player:get_player_name()
|
|
local ppos = player:get_pos()
|
|
local tod = minetest.get_timeofday()
|
|
|
|
if tod > 0.2 and tod < 0.805 then
|
|
if beds.player[name] then
|
|
lay_down(player, nil, nil, false)
|
|
end
|
|
minetest.chat_send_player(name, "You can only sleep at night.")
|
|
return
|
|
end
|
|
|
|
-- move to bed
|
|
if not beds.player[name] then
|
|
lay_down(player, ppos, pos)
|
|
beds.set_spawns() -- save respawn positions when entering bed
|
|
else
|
|
lay_down(player, nil, nil, false)
|
|
end
|
|
|
|
if not is_sp then
|
|
update_formspecs(false)
|
|
end
|
|
|
|
-- skip the night and let all players stand up
|
|
if check_in_beds() then
|
|
minetest.after(2, function()
|
|
if not is_sp then
|
|
update_formspecs(is_night_skip_enabled())
|
|
end
|
|
if is_night_skip_enabled() then
|
|
beds.skip_night()
|
|
beds.kick_players()
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
|
|
function beds.can_dig(bed_pos)
|
|
-- Check all players in bed which one is at the expected position
|
|
for _, player_bed_pos in pairs(beds.bed_position) do
|
|
if vector.equals(bed_pos, player_bed_pos) then
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
|
|
|
|
|
|
--[[
|
|
function beds.register_bed(name, def)
|
|
minetest.register_node(name .. "_bottom", {
|
|
description = def.description,
|
|
inventory_image = def.inventory_image,
|
|
wield_image = def.wield_image,
|
|
drawtype = "nodebox",
|
|
tiles = def.tiles.bottom,
|
|
paramtype = "light",
|
|
paramtype2 = "facedir",
|
|
is_ground_content = false,
|
|
stack_max = 1,
|
|
groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 3, bed = 1},
|
|
sounds = def.sounds or default.node_sound_wood_defaults(),
|
|
node_box = {
|
|
type = "fixed",
|
|
fixed = def.nodebox.bottom,
|
|
},
|
|
selection_box = {
|
|
type = "fixed",
|
|
fixed = def.selectionbox,
|
|
},
|
|
|
|
on_place = function(itemstack, placer, pointed_thing)
|
|
local under = pointed_thing.under
|
|
local node = minetest.get_node(under)
|
|
local udef = minetest.registered_nodes[node.name]
|
|
if udef and udef.on_rightclick and
|
|
not (placer and placer:is_player() and
|
|
placer:get_player_control().sneak) then
|
|
return udef.on_rightclick(under, node, placer, itemstack,
|
|
pointed_thing) or itemstack
|
|
end
|
|
|
|
local pos
|
|
if udef and udef.buildable_to then
|
|
pos = under
|
|
else
|
|
pos = pointed_thing.above
|
|
end
|
|
|
|
local player_name = placer and placer:get_player_name() or ""
|
|
|
|
if minetest.is_protected(pos, player_name) and
|
|
not minetest.check_player_privs(player_name, "protection_bypass") then
|
|
minetest.record_protection_violation(pos, player_name)
|
|
return itemstack
|
|
end
|
|
|
|
local node_def = minetest.registered_nodes[minetest.get_node(pos).name]
|
|
if not node_def or not node_def.buildable_to then
|
|
return itemstack
|
|
end
|
|
|
|
local dir = placer and placer:get_look_dir() and
|
|
minetest.dir_to_facedir(placer:get_look_dir()) or 0
|
|
local botpos = vector.add(pos, minetest.facedir_to_dir(dir))
|
|
|
|
if minetest.is_protected(botpos, player_name) and
|
|
not minetest.check_player_privs(player_name, "protection_bypass") then
|
|
minetest.record_protection_violation(botpos, player_name)
|
|
return itemstack
|
|
end
|
|
|
|
local botdef = minetest.registered_nodes[minetest.get_node(botpos).name]
|
|
if not botdef or not botdef.buildable_to then
|
|
return itemstack
|
|
end
|
|
|
|
minetest.set_node(pos, {name = name .. "_bottom", param2 = dir})
|
|
minetest.set_node(botpos, {name = name .. "_top", param2 = dir})
|
|
|
|
if not (creative and creative.is_enabled_for
|
|
and creative.is_enabled_for(player_name)) then
|
|
itemstack:take_item()
|
|
end
|
|
return itemstack
|
|
end,
|
|
|
|
on_destruct = function(pos)
|
|
destruct_bed(pos, 1)
|
|
end,
|
|
|
|
on_rightclick = function(pos, node, clicker, itemstack, pointed_thing)
|
|
beds.on_rightclick(pos, clicker)
|
|
return itemstack
|
|
end,
|
|
|
|
on_rotate = function(pos, node, user, _, new_param2)
|
|
local dir = minetest.facedir_to_dir(node.param2)
|
|
local p = vector.add(pos, dir)
|
|
local node2 = minetest.get_node_or_nil(p)
|
|
if not node2 or not minetest.get_item_group(node2.name, "bed") == 2 or
|
|
not node.param2 == node2.param2 then
|
|
return false
|
|
end
|
|
if minetest.is_protected(p, user:get_player_name()) then
|
|
minetest.record_protection_violation(p, user:get_player_name())
|
|
return false
|
|
end
|
|
if new_param2 % 32 > 3 then
|
|
return false
|
|
end
|
|
local newp = vector.add(pos, minetest.facedir_to_dir(new_param2))
|
|
local node3 = minetest.get_node_or_nil(newp)
|
|
local node_def = node3 and minetest.registered_nodes[node3.name]
|
|
if not node_def or not node_def.buildable_to then
|
|
return false
|
|
end
|
|
if minetest.is_protected(newp, user:get_player_name()) then
|
|
minetest.record_protection_violation(newp, user:get_player_name())
|
|
return false
|
|
end
|
|
node.param2 = new_param2
|
|
-- do not remove_node here - it will trigger destroy_bed()
|
|
minetest.set_node(p, {name = "air"})
|
|
minetest.set_node(pos, node)
|
|
minetest.set_node(newp, {name = name .. "_top", param2 = new_param2})
|
|
return true
|
|
end,
|
|
can_dig = function(pos, player)
|
|
return beds.can_dig(pos)
|
|
end,
|
|
})
|
|
|
|
minetest.register_node(name .. "_top", {
|
|
drawtype = "nodebox",
|
|
tiles = def.tiles.top,
|
|
paramtype = "light",
|
|
paramtype2 = "facedir",
|
|
is_ground_content = false,
|
|
pointable = false,
|
|
groups = {choppy = 2, oddly_breakable_by_hand = 2, flammable = 3, bed = 2},
|
|
sounds = def.sounds or default.node_sound_wood_defaults(),
|
|
drop = name .. "_bottom",
|
|
node_box = {
|
|
type = "fixed",
|
|
fixed = def.nodebox.top,
|
|
},
|
|
on_destruct = function(pos)
|
|
destruct_bed(pos, 2)
|
|
end,
|
|
can_dig = function(pos, player)
|
|
local node = minetest.get_node(pos)
|
|
local dir = minetest.facedir_to_dir(node.param2)
|
|
local p = vector.add(pos, dir)
|
|
return beds.can_dig(p)
|
|
end,
|
|
})
|
|
|
|
minetest.register_alias(name, name .. "_bottom")
|
|
|
|
minetest.register_craft({
|
|
output = name,
|
|
recipe = def.recipe
|
|
})
|
|
end
|
|
--]]
|
|
|
|
|
|
|
|
|
|
-- Callbacks
|
|
-- Only register respawn callback if respawn enabled
|
|
if enable_respawn then
|
|
-- respawn player at bed if enabled and valid position is found
|
|
minetest.register_on_respawnplayer(function(player)
|
|
local name = player:get_player_name()
|
|
local pos = beds.spawn[name]
|
|
if pos then
|
|
player:set_pos(pos)
|
|
return true
|
|
end
|
|
end)
|
|
end
|
|
|
|
minetest.register_on_leaveplayer(function(player)
|
|
local name = player:get_player_name()
|
|
lay_down(player, nil, nil, false, true)
|
|
beds.player[name] = nil
|
|
if check_in_beds() then
|
|
minetest.after(2, function()
|
|
update_formspecs(is_night_skip_enabled())
|
|
if is_night_skip_enabled() then
|
|
beds.skip_night()
|
|
beds.kick_players()
|
|
end
|
|
end)
|
|
end
|
|
end)
|
|
|
|
minetest.register_on_player_receive_fields(function(player, formname, fields)
|
|
if formname ~= "beds_form" then
|
|
return
|
|
end
|
|
|
|
-- Because "Force night skip" button is a button_exit, it will set fields.quit
|
|
-- and lay_down call will change value of player_in_bed, so it must be taken
|
|
-- earlier.
|
|
local last_player_in_bed = player_in_bed
|
|
|
|
if fields.quit or fields.leave then
|
|
lay_down(player, nil, nil, false)
|
|
update_formspecs(false)
|
|
end
|
|
|
|
if fields.force then
|
|
local is_majority = (#minetest.get_connected_players() / 2) < last_player_in_bed
|
|
if is_majority and is_night_skip_enabled() then
|
|
update_formspecs(true)
|
|
beds.skip_night()
|
|
beds.kick_players()
|
|
else
|
|
update_formspecs(false)
|
|
end
|
|
end
|
|
end)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|