146 lines
3.9 KiB
Lua
146 lines
3.9 KiB
Lua
-- Initialise
|
|
ctf.register_on_init(function()
|
|
ctf.log("flag", "Initialising...")
|
|
ctf._set("flag.allow_multiple", true)
|
|
ctf._set("flag.capture_take", false)
|
|
ctf._set("flag.names", true)
|
|
ctf._set("flag.waypoints", true)
|
|
ctf._set("flag.protect_distance", 25)
|
|
ctf._set("flag.nobuild_radius", 3)
|
|
ctf._set("flag.drop_time", 7*60)
|
|
ctf._set("flag.drop_warn_time", 60)
|
|
ctf._set("flag.crafting", false)
|
|
ctf._set("flag.alerts", true)
|
|
ctf._set("flag.alerts.neutral_alert", true)
|
|
end)
|
|
|
|
minetest.register_privilege("ctf_place_flag", {
|
|
description = "can place flag"
|
|
})
|
|
|
|
dofile(minetest.get_modpath("ctf_flag") .. "/hud.lua")
|
|
dofile(minetest.get_modpath("ctf_flag") .. "/flag_func.lua")
|
|
dofile(minetest.get_modpath("ctf_flag") .. "/api.lua")
|
|
dofile(minetest.get_modpath("ctf_flag") .. "/flags.lua")
|
|
|
|
ctf.register_on_new_team(function(team)
|
|
team.flags = {}
|
|
end)
|
|
|
|
function ctf_flag.get_nearest(pos)
|
|
local closest = nil
|
|
local closest_distSQ = 1000000
|
|
local pd = ctf.setting("flag.protect_distance")
|
|
local pdSQ = pd * pd
|
|
|
|
for tname, team in pairs(ctf.teams) do
|
|
for i = 1, #team.flags do
|
|
local distSQ = vector.distanceSQ(pos, team.flags[i])
|
|
if distSQ < pdSQ and distSQ < closest_distSQ then
|
|
closest = team.flags[i]
|
|
closest_distSQ = distSQ
|
|
end
|
|
end
|
|
end
|
|
|
|
return closest, closest_distSQ
|
|
end
|
|
|
|
function ctf_flag.get_nearest_team_dist(pos)
|
|
local flag, distSQ = ctf_flag.get_nearest(pos)
|
|
if flag then
|
|
return flag.team, distSQ
|
|
end
|
|
end
|
|
|
|
ctf.register_on_territory_query(ctf_flag.get_nearest_team_dist)
|
|
|
|
function ctf.get_spawn(team)
|
|
if not ctf.team(team) then
|
|
return nil
|
|
end
|
|
|
|
if ctf.team(team).spawn then
|
|
return ctf.team(team).spawn
|
|
end
|
|
|
|
-- Get spawn from first flag
|
|
ctf_flag.assert_flags(team)
|
|
if #ctf.team(team).flags > 0 then
|
|
return ctf.team(team).flags[1]
|
|
else
|
|
return nil
|
|
end
|
|
end
|
|
|
|
-- Add minimum build range
|
|
local old_is_protected = minetest.is_protected
|
|
local r = ctf.setting("flag.nobuild_radius")
|
|
local rs = r * r
|
|
function minetest.is_protected(pos, name)
|
|
if r <= 0 or rs == 0 then
|
|
return old_is_protected(pos, name)
|
|
end
|
|
|
|
local flag, distSQ = ctf_flag.get_nearest(pos)
|
|
if flag and pos.y >= flag.y - 1 and distSQ < rs then
|
|
minetest.chat_send_player(name,
|
|
"Too close to the flag to build! Leave at least " .. r .. " blocks around the flag.")
|
|
return true
|
|
else
|
|
return old_is_protected(pos, name)
|
|
end
|
|
end
|
|
|
|
-- Play sound
|
|
ctf_flag.register_on_pick_up(function(attname, flag)
|
|
local vteam = ctf.team(flag.team)
|
|
for name, player in pairs(vteam.players) do
|
|
minetest.sound_play({name="trumpet_lose"}, {
|
|
to_player = name,
|
|
gain = 1.0, -- default
|
|
})
|
|
end
|
|
|
|
local ateam = ctf.team(ctf.player(attname).team)
|
|
for name, player in pairs(ateam.players) do
|
|
minetest.sound_play({name="trumpet_win"}, {
|
|
to_player = name,
|
|
gain = 1.0, -- default
|
|
})
|
|
end
|
|
end)
|
|
|
|
-- Drop after time
|
|
local pickup_times = {}
|
|
ctf_flag.register_on_pick_up(function(attname, flag)
|
|
pickup_times[attname] = minetest.get_gametime()
|
|
end)
|
|
ctf_flag.register_on_drop(function(attname, flag)
|
|
pickup_times[attname] = nil
|
|
end)
|
|
ctf_flag.register_on_capture(function(attname, flag)
|
|
pickup_times[attname] = nil
|
|
end)
|
|
ctf.register_on_new_game(function()
|
|
pickup_times = {}
|
|
end)
|
|
local function update_flag_drops()
|
|
local time = minetest.get_gametime()
|
|
local drop_time = ctf.setting("flag.drop_time")
|
|
for name, start in pairs(pickup_times) do
|
|
local remaining = drop_time - time + start
|
|
if remaining < 0 then
|
|
ctf_flag.player_drop_flag(name)
|
|
minetest.chat_send_player(name, "You took too long to capture the flag, so it returned!")
|
|
elseif remaining < ctf.setting("flag.drop_warn_time") then
|
|
minetest.chat_send_player(name, "You have " .. remaining ..
|
|
" seconds to capture the flag before it returns.")
|
|
end
|
|
end
|
|
|
|
ctf_flag.assert_flags()
|
|
|
|
minetest.after(5, update_flag_drops)
|
|
end
|
|
minetest.after(5, update_flag_drops)
|