838 lines
20 KiB
Lua
838 lines
20 KiB
Lua
-- Get or add a team
|
|
function ctf.team(name)
|
|
if name == nil then
|
|
return nil
|
|
end
|
|
if type(name) == "table" then
|
|
if not name.add_team then
|
|
ctf.error("team", "Invalid table given to ctf.team")
|
|
return
|
|
end
|
|
|
|
return ctf.create_team(name.name, name)
|
|
else
|
|
local team = ctf.teams[name]
|
|
if team then
|
|
--Migration to version with applications
|
|
if not team.applications then
|
|
team.applications = {}
|
|
end
|
|
if not team.data or not team.players then
|
|
ctf.warning("team", "Assertion failed, data{} or players{} not " ..
|
|
"found in team{}")
|
|
end
|
|
return team
|
|
else
|
|
if name and name:trim() ~= "" then
|
|
ctf.warning("team", dump(name) .. " does not exist!")
|
|
end
|
|
return nil
|
|
end
|
|
end
|
|
end
|
|
|
|
function ctf.create_team(name, data)
|
|
ctf.log("team", "Creating team " .. name)
|
|
|
|
ctf.teams[name] = {
|
|
data = data,
|
|
spawn = nil,
|
|
players = {},
|
|
applications = {},
|
|
access = {},
|
|
power = {
|
|
max_power = 0,
|
|
power = 0
|
|
}
|
|
}
|
|
|
|
for i = 1, #ctf.registered_on_new_team do
|
|
ctf.registered_on_new_team[i](ctf.teams[name])
|
|
end
|
|
|
|
ctf.needs_save = true
|
|
|
|
return ctf.teams[name]
|
|
end
|
|
|
|
function ctf.remove_team(name)
|
|
local team = ctf.team(name)
|
|
if team then
|
|
for username, player in pairs(team.players) do
|
|
player.team = nil
|
|
end
|
|
for i = 1, #team.flags do
|
|
team.flags[i].team = nil
|
|
end
|
|
ctf.teams[name] = nil
|
|
ctf.access_remove_team_all(name)
|
|
ctf.needs_save = true
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
function ctf.list_teams(name)
|
|
minetest.chat_send_player(name, "Teams:")
|
|
for tname, team in pairs(ctf.teams) do
|
|
if team and team.players then
|
|
local details = ""
|
|
|
|
local numPlayers = ctf.count_players_in_team(tname)
|
|
details = numPlayers .. " members"
|
|
|
|
if team.flags then
|
|
local numFlags = 0
|
|
for flagid, flag in pairs(team.flags) do
|
|
numFlags = numFlags + 1
|
|
end
|
|
details = details .. ", " .. numFlags .. " flags"
|
|
end
|
|
|
|
minetest.chat_send_player(name, ">> " .. tname ..
|
|
" (" .. details .. ")")
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Count number of players in a team
|
|
function ctf.count_players_in_team(team)
|
|
local count = 0
|
|
for name, player in pairs(ctf.team(team).players) do
|
|
count = count + 1
|
|
end
|
|
return count
|
|
end
|
|
|
|
function ctf.new_player(name)
|
|
if name then
|
|
ctf.players[name] = {
|
|
name = name
|
|
}
|
|
else
|
|
ctf.error("team", "Can't create a blank player")
|
|
ctf.log("team", debug.traceback())
|
|
end
|
|
end
|
|
|
|
-- get a player
|
|
function ctf.player(name)
|
|
if not ctf.players[name] then
|
|
ctf.new_player(name)
|
|
end
|
|
return ctf.players[name]
|
|
end
|
|
|
|
function ctf.player_or_nil(name)
|
|
return ctf.players[name]
|
|
end
|
|
|
|
function ctf.remove_player(name)
|
|
ctf.log("team", "Removing player ".. dump(name))
|
|
local player = ctf.players[name]
|
|
if player then
|
|
local team = ctf.team(player.team)
|
|
if team then
|
|
team.players[name] = nil
|
|
end
|
|
ctf.players[name] = nil
|
|
ctf.needs_save = true
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
ctf.registered_on_join_team = {}
|
|
function ctf.register_on_join_team(func)
|
|
if ctf._mt_loaded then
|
|
error("You can't register callbacks at game time!")
|
|
end
|
|
table.insert(ctf.registered_on_join_team, func)
|
|
end
|
|
|
|
-- Player joins team
|
|
-- Called by /join, /team join or auto allocate.
|
|
ctf.registered_on_join_team = {}
|
|
function ctf.register_on_join_team(func)
|
|
if ctf._mt_loaded then
|
|
error("You can't register callbacks at game time!")
|
|
end
|
|
table.insert(ctf.registered_on_join_team, func)
|
|
end
|
|
|
|
-- Player makes an application to team manager to join a team
|
|
-- Called by /apply
|
|
function ctf.application_join(name, tname)
|
|
if not name or name == "" or not tname or tname == "" then
|
|
ctf.log("teams", "Missing parameters to ctf.request_join")
|
|
end
|
|
local player = ctf.player(name)
|
|
|
|
if player.team and player.team == tname then
|
|
minetest.chat_send_player(name, "You are already a member of team " .. tname)
|
|
return false
|
|
end
|
|
|
|
if not ctf.setting("players_can_change_team") and player.team and ctf.team(player.team) then
|
|
ctf.action("teams", name .. " requested to change to " .. tname)
|
|
minetest.chat_send_player(name, "You are not allowed to switch teams, traitor!")
|
|
return false
|
|
end
|
|
|
|
local team_data = ctf.team(tname)
|
|
if not team_data then
|
|
minetest.chat_send_player(name, "No such team.")
|
|
ctf.list_teams(name)
|
|
minetest.log("action", name .. " requested to join to " .. tname .. ", which doesn't exist")
|
|
return false
|
|
end
|
|
|
|
table.insert(team_data.applications,name)
|
|
--ctf.post(tname, {msg = name .. " has applied to join!" })
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
|
|
function ctf.decide_application(applicant_name, acceptor_name, team_name, decision)
|
|
if not applicant_name then
|
|
return false
|
|
end
|
|
local applicant = ctf.player(applicant_name)
|
|
if not applicant then
|
|
return false
|
|
end
|
|
if decision == "Accept" then
|
|
if applicant.team and ctf.setting("players_can_change_team") then
|
|
minetest.chat_send_player(acceptor_name, "Player " .. applicant_name .. " already a member of team " .. applicant.team)
|
|
else
|
|
ctf.join(applicant_name, team_name, true, acceptor_name)
|
|
if not ctf.teams[team_name].log then
|
|
ctf.teams[team_name].log = {}
|
|
end
|
|
table.insert(ctf.teams[team_name].log,{msg=applicant_name .. " was recruited " .. acceptor_name .. "!"})
|
|
end
|
|
end
|
|
for key, field in pairs(ctf.teams) do
|
|
ctf.delete_application(applicant_name, key)
|
|
end
|
|
remove_application_log_entry(team_name, applicant_name)
|
|
end
|
|
|
|
function ctf.delete_application(name, tname)
|
|
if not name or name == "" or not tname or tname == "" then
|
|
ctf.log("teams", "Missing parameters to ctf.delete_application")
|
|
end
|
|
local team = ctf.team(tname)
|
|
if not team then
|
|
minetest.chat_send_player(name, "No such team.")
|
|
return false
|
|
end
|
|
for key, field in pairs(team.applications) do
|
|
if field == name then
|
|
table.remove(team.applications, key)
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function ctf.gen_access_table(t)
|
|
if not t.access then
|
|
t.access = {}
|
|
end
|
|
if not t.access.players then
|
|
t.access.players = {}
|
|
end
|
|
if not t.access.teams then
|
|
t.access.teams = {}
|
|
end
|
|
if t.access.open == nil then
|
|
t.access.open = true
|
|
end
|
|
return t
|
|
end
|
|
|
|
function ctf.access_add(team, flag, team_or_player)
|
|
local t = ctf.team(team)
|
|
if flag == "all" then
|
|
t = ctf.gen_access_table(t)
|
|
if team_or_player ~= team and ctf.team(team_or_player) then
|
|
t.access.teams[team_or_player] = 1
|
|
ctf.teams[team] = t
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
if ctf.players[team_or_player] then
|
|
t.access.players[team_or_player] = 1
|
|
ctf.teams[team] = t
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
else
|
|
for i = 1, #t.flags do
|
|
if t.flags[i].name == flag then
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
if team_or_player ~= team and ctf.team(team_or_player) then
|
|
t.flags[i].access.teams[team_or_player] = 1
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
if ctf.players[team_or_player] then
|
|
t.flags[i].access.players[team_or_player] = 1
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function ctf.access_remove(team, flag, team_or_player)
|
|
local t = ctf.team(team)
|
|
if flag == "all" then
|
|
t = ctf.gen_access_table(t)
|
|
if team_or_player ~= team and ctf.team(team_or_player) then
|
|
t.access.teams[team_or_player] = nil
|
|
ctf.teams[team] = t
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
if ctf.players[team_or_player] then
|
|
t.access.players[team_or_player] = nil
|
|
ctf.teams[team] = t
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
else
|
|
for i = 1, #t.flags do
|
|
if t.flags[i].name == flag then
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
if team_or_player ~= team and ctf.team(team_or_player) then
|
|
t.flags[i].access.teams[team_or_player] = nil
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
if ctf.players[team_or_player] then
|
|
t.flags[i].access.players[team_or_player] = nil
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function ctf.access_clear(team, flag, team_or_player)
|
|
local t = ctf.team(team)
|
|
if flag == "all" then
|
|
t = ctf.gen_access_table(t)
|
|
if team_or_player == "all" then
|
|
t.access.teams = {}
|
|
t.access.players = {}
|
|
for i = 1, #t.flags do
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
t.flags[i].access.teams = {}
|
|
t.flags[i].access.players = {}
|
|
end
|
|
ctf.teams[team] = t
|
|
ctf.needs_save = true
|
|
return true
|
|
elseif team_or_player == "teams" then
|
|
t.access.teams = {}
|
|
for i = 1, #t.flags do
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
t.flags[i].access.teams = {}
|
|
end
|
|
ctf.teams[team] = t
|
|
ctf.needs_save = true
|
|
return true
|
|
elseif team_or_player == "players" then
|
|
t.access.players = {}
|
|
for i = 1, #t.flags do
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
t.flags[i].access.players = {}
|
|
end
|
|
ctf.teams[team] = t
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
else
|
|
for i = 1, #t.flags do
|
|
if t.flags[i].name == flag then
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
if team_or_player == "all" then
|
|
t.flags[i].access.teams = {}
|
|
t.flags[i].access.players = {}
|
|
ctf.needs_save = true
|
|
return true
|
|
elseif team_or_player == "teams" then
|
|
t.flags[i].access.teams = {}
|
|
ctf.needs_save = true
|
|
return true
|
|
elseif team_or_player == "players" then
|
|
t.flags[i].access.players = {}
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function ctf.access_list(name, team, flag)
|
|
local t = ctf.team(team)
|
|
if flag == "all" then
|
|
t = ctf.gen_access_table(t)
|
|
minetest.chat_send_player(name,"Teams:")
|
|
for i in pairs(t.access.teams) do
|
|
minetest.chat_send_player(name,i .. " (all)")
|
|
end
|
|
for i = 1, #t.flags do
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
for l in pairs(t.flags[i].access.teams) do
|
|
minetest.chat_send_player(name, l .. " (" .. t.flags[i].name .. ")")
|
|
end
|
|
end
|
|
minetest.chat_send_player(name,"Players:")
|
|
for i in pairs(t.access.players) do
|
|
minetest.chat_send_player(name, i .. " (all)")
|
|
end
|
|
for i = 1, #t.flags do
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
for l in pairs(t.flags[i].access.players) do
|
|
minetest.chat_send_player(name,l .. " (" .. t.flags[i].name .. ")")
|
|
end
|
|
end
|
|
return true
|
|
else
|
|
for i = 1, #t.flags do
|
|
if t.flags[i].name == flag then
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
minetest.chat_send_player(name,"Teams:")
|
|
for l in pairs(t.flags[i].access.teams) do
|
|
minetest.chat_send_player(name,l .. " (" .. t.flags[i].name .. ")")
|
|
end
|
|
minetest.chat_send_player(name,"Players:")
|
|
for l in pairs(t.flags[i].access.players) do
|
|
minetest.chat_send_player(name,l .. " (" .. t.flags[i].name .. ")")
|
|
end
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function ctf.access_open(team, flag)
|
|
local t = ctf.team(team)
|
|
if flag == "all" then
|
|
for i = 1, #t.flags do
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
t.flags[i].access.open = true
|
|
ctf.teams[team] = t
|
|
ctf.needs_save = true
|
|
end
|
|
return true
|
|
else
|
|
for i = 1, #t.flags do
|
|
if t.flags[i].name == flag then
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
t.flags[i].access.open = true
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function ctf.access_close(team, flag)
|
|
local t = ctf.team(team)
|
|
if flag == "all" then
|
|
for i = 1, #t.flags do
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
t.flags[i].access.open = false
|
|
ctf.teams[team] = t
|
|
ctf.needs_save = true
|
|
end
|
|
return true
|
|
else
|
|
for i = 1, #t.flags do
|
|
if t.flags[i].name == flag then
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
t.flags[i].access.open = false
|
|
ctf.needs_save = true
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
function ctf.access_remove_team_all(name)
|
|
for i in pairs(ctf.teams) do
|
|
local t = ctf.teams[i]
|
|
t = ctf.gen_access_table(t)
|
|
t.access.teams[name] = nil
|
|
for i = 1, #t.flags do
|
|
t.flags[i] = ctf.gen_access_table(t.flags[i])
|
|
t.flags[i].access.teams[name] = nil
|
|
end
|
|
ctf.teams[i] = t
|
|
end
|
|
ctf.needs_save = true
|
|
end
|
|
|
|
-- Player joins team
|
|
-- Called by /join, /team join, auto allocate or by response of the team manager.
|
|
function ctf.join(name, team, force, by)
|
|
if not name or name == "" or not team or team == "" then
|
|
ctf.log("team", "Missing parameters to ctf.join")
|
|
return false
|
|
end
|
|
|
|
local player = ctf.player(name)
|
|
|
|
if not force and not ctf.setting("players_can_change_team")
|
|
and player.team and ctf.team(player.team) then
|
|
if by then
|
|
if by == name then
|
|
ctf.action("teams", name .. " attempted to change to " .. team)
|
|
minetest.chat_send_player(by, "You are not allowed to switch teams, traitor!")
|
|
else
|
|
ctf.action("teams", by .. " attempted to change " .. name .. " to " .. team)
|
|
minetest.chat_send_player(by, "Failed to add " .. name .. " to " .. team ..
|
|
" as players_can_change_team = false")
|
|
end
|
|
else
|
|
ctf.log("teams", "failed to add " .. name .. " to " .. team ..
|
|
" as players_can_change_team = false")
|
|
end
|
|
return false
|
|
end
|
|
|
|
local team_data = ctf.team(team)
|
|
if not team_data then
|
|
if by then
|
|
minetest.chat_send_player(by, "No such team.")
|
|
ctf.list_teams(by)
|
|
if by == name then
|
|
minetest.log("action", by .. " tried to move " .. name .. " to " .. team .. ", which doesn't exist")
|
|
else
|
|
minetest.log("action", name .. " attempted to join " .. team .. ", which doesn't exist")
|
|
end
|
|
else
|
|
ctf.log("teams", "failed to add " .. name .. " to " .. team ..
|
|
" as team does not exist")
|
|
end
|
|
return false
|
|
end
|
|
|
|
if player.team then
|
|
local oldteam = ctf.team(player.team)
|
|
if oldteam then
|
|
oldteam.players[player.name] = nil
|
|
end
|
|
end
|
|
|
|
player.team = team
|
|
team_data.players[player.name] = player
|
|
|
|
ctf.needs_save = true
|
|
|
|
minetest.log("action", name .. " joined team " .. team)
|
|
minetest.chat_send_all(name.." has joined team "..team)
|
|
|
|
for i = 1, #ctf.registered_on_join_team do
|
|
ctf.registered_on_join_team[i](name, team)
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- Cleans up the player lists
|
|
function ctf.clean_player_lists()
|
|
ctf.log("utils", "Cleaning player lists")
|
|
for _, str in pairs(ctf.players) do
|
|
if str and str.team and ctf.teams[str.team] then
|
|
ctf.log("utils", " - Adding player "..str.name.." to team "..str.team)
|
|
ctf.teams[str.team].players[str.name] = str
|
|
else
|
|
ctf.log("utils", " - Skipping player "..str.name)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Sees if the player can change stuff in a team
|
|
function ctf.can_mod(player,team)
|
|
local privs = minetest.get_player_privs(player)
|
|
|
|
if privs then
|
|
if privs.ctf_admin == true then
|
|
return true
|
|
end
|
|
end
|
|
|
|
if player and ctf.teams[team] and ctf.teams[team].players and ctf.teams[team].players[player] then
|
|
if ctf.teams[team].players[player].auth == true then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- post a message to a team board
|
|
function ctf.post(team, msg)
|
|
if not ctf.team(team) then
|
|
return false
|
|
end
|
|
|
|
if not ctf.team(team).log then
|
|
ctf.team(team).log = {}
|
|
end
|
|
|
|
|
|
ctf.log("team", "message posted to team board")
|
|
|
|
table.insert(ctf.team(team).log, 1, msg)
|
|
ctf.needs_save = true
|
|
|
|
return true
|
|
end
|
|
|
|
-- Automatic Allocation
|
|
function ctf.autoalloc(name, alloc_mode)
|
|
if alloc_mode == 0 then
|
|
return
|
|
end
|
|
local max_players = ctf.setting("maximum_in_team")
|
|
|
|
local mtot = false -- more than one team
|
|
for key, team in pairs(ctf.teams) do
|
|
mtot = true
|
|
break
|
|
end
|
|
if not mtot then
|
|
ctf.error("autoalloc", "No teams to allocate " .. name .. " to!")
|
|
return
|
|
end
|
|
|
|
if alloc_mode == 1 then
|
|
local index = {}
|
|
|
|
for key, team in pairs(ctf.teams) do
|
|
if max_players == -1 or ctf.count_players_in_team(key) < max_players then
|
|
table.insert(index, key)
|
|
end
|
|
end
|
|
|
|
if #index == 0 then
|
|
ctf.error("autoalloc", "No teams to join!")
|
|
else
|
|
return index[math.random(1, #index)]
|
|
end
|
|
elseif alloc_mode == 2 then
|
|
local one = nil
|
|
local one_count = -1
|
|
local two = nil
|
|
local two_count = -1
|
|
for key, team in pairs(ctf.teams) do
|
|
local count = ctf.count_players_in_team(key)
|
|
if (max_players == -1 or count < max_players) then
|
|
if count > one_count then
|
|
two = one
|
|
two_count = one_count
|
|
one = key
|
|
one_count = count
|
|
end
|
|
|
|
if count > two_count then
|
|
two = key
|
|
two_count = count
|
|
end
|
|
end
|
|
end
|
|
|
|
if not one and not two then
|
|
ctf.error("autoalloc", "No teams to join!")
|
|
elseif one and two then
|
|
if math.random() > 0.5 then
|
|
return one
|
|
else
|
|
return two
|
|
end
|
|
else
|
|
if one then
|
|
return one
|
|
else
|
|
return two
|
|
end
|
|
end
|
|
elseif alloc_mode == 3 then
|
|
local smallest = nil
|
|
local smallest_count = 1000
|
|
for key, team in pairs(ctf.teams) do
|
|
local count = ctf.count_players_in_team(key)
|
|
if not smallest or count < smallest_count then
|
|
smallest = key
|
|
smallest_count = count
|
|
end
|
|
end
|
|
|
|
if not smallest then
|
|
ctf.error("autoalloc", "No teams to join!")
|
|
else
|
|
return smallest
|
|
end
|
|
else
|
|
ctf.error("autoalloc", "Unknown allocation mode: "..ctf.setting("allocate_mode"))
|
|
end
|
|
end
|
|
|
|
-- updates the spawn position for a team
|
|
function ctf.get_spawn(team)
|
|
if ctf.team(team) and ctf.team(team).spawn then
|
|
return ctf.team(team).spawn
|
|
else
|
|
return nil
|
|
end
|
|
end
|
|
|
|
function ctf.move_to_spawn(name)
|
|
local player = minetest.get_player_by_name(name)
|
|
local tplayer = ctf.player(name)
|
|
if ctf.team(tplayer.team) then
|
|
local spawn = ctf.get_spawn(tplayer.team)
|
|
if spawn then
|
|
player:moveto(spawn, false)
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
--[[
|
|
minetest.register_on_respawnplayer(function(player)
|
|
if not player then
|
|
return false
|
|
end
|
|
|
|
return ctf.move_to_spawn(player:get_player_name())
|
|
end)--]]
|
|
|
|
function ctf.get_territory_owner(pos)
|
|
if pos.y < -100 then
|
|
return nil
|
|
end
|
|
local pd = ctf.setting("flag.protect_distance")
|
|
local pdSQ = pd * pd
|
|
for tname, team in pairs(ctf.teams) do
|
|
for f = 1, #team.flags do
|
|
local fPos = team.flags[f]
|
|
local diffX = fPos.x - pos.x
|
|
local diffZ = fPos.z - pos.z
|
|
local distSQ = diffX * diffX + diffZ * diffZ
|
|
if distSQ < pdSQ then
|
|
return tname, f
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
minetest.register_on_newplayer(function(player)
|
|
local alloc_mode = tonumber(ctf.setting("allocate_mode"))
|
|
if alloc_mode == 0 then
|
|
return
|
|
end
|
|
local name = player:get_player_name()
|
|
local team = ctf.autoalloc(name, alloc_mode)
|
|
if team then
|
|
ctf.log("autoalloc", name .. " was allocated to " .. team)
|
|
ctf.join(name, team)
|
|
ctf.move_to_spawn(player:get_player_name())
|
|
end
|
|
end)
|
|
|
|
|
|
minetest.register_on_joinplayer(function(player)
|
|
if not ctf.setting("autoalloc_on_joinplayer") then
|
|
return
|
|
end
|
|
|
|
local name = player:get_player_name()
|
|
if ctf.team(ctf.player(name).team) then
|
|
return
|
|
end
|
|
|
|
local alloc_mode = tonumber(ctf.setting("allocate_mode"))
|
|
if alloc_mode == 0 then
|
|
return
|
|
end
|
|
local team = ctf.autoalloc(name, alloc_mode)
|
|
if team then
|
|
ctf.log("autoalloc", name .. " was allocated to " .. team)
|
|
ctf.join(name, team)
|
|
ctf.move_to_spawn(player:get_player_name())
|
|
end
|
|
end)
|
|
|
|
-- Disable friendly fire.
|
|
ctf.registered_on_killedplayer = {}
|
|
function ctf.register_on_killedplayer(func)
|
|
if ctf._mt_loaded then
|
|
error("You can't register callbacks at game time!")
|
|
end
|
|
table.insert(ctf.registered_on_killedplayer, func)
|
|
end
|
|
local dead_players = {}
|
|
minetest.register_on_respawnplayer(function(player)
|
|
dead_players[player:get_player_name()] = nil
|
|
end)
|
|
minetest.register_on_joinplayer(function(player)
|
|
dead_players[player:get_player_name()] = nil
|
|
end)
|
|
minetest.register_on_punchplayer(function(player, hitter,
|
|
time_from_last_punch, tool_capabilities, dir, damage)
|
|
if player and hitter then
|
|
local to = ctf.player(player:get_player_name())
|
|
local from = ctf.player(hitter:get_player_name())
|
|
|
|
if dead_players[player:get_player_name()] then
|
|
return
|
|
end
|
|
|
|
if to.team == from.team and to.team ~= "" and to.team ~= nil and to.name ~= from.name then
|
|
minetest.chat_send_player(hitter:get_player_name(), player:get_player_name() .. " is on your team!")
|
|
if not ctf.setting("friendly_fire") then
|
|
return true
|
|
end
|
|
end
|
|
|
|
if player:get_hp() - damage <= 0 then
|
|
dead_players[player:get_player_name()] = true
|
|
local wielded = hitter:get_wielded_item()
|
|
local wname = wielded:get_name()
|
|
print(wname)
|
|
local type = "sword"
|
|
if wname:sub(1, 8) == "shooter:" then
|
|
if wname == "shooter:grenade" then
|
|
type = "grenade"
|
|
else
|
|
type = "bullet"
|
|
end
|
|
end
|
|
if tool_capabilities.damage_groups.grenade then
|
|
type = "grenade"
|
|
end
|
|
for i = 1, #ctf.registered_on_killedplayer do
|
|
ctf.registered_on_killedplayer[i](player:get_player_name(), hitter:get_player_name(), type)
|
|
end
|
|
return false
|
|
end
|
|
end
|
|
end)
|