420 lines
12 KiB
Lua
420 lines
12 KiB
Lua
-- This is the controll mod of Subgames for all!
|
|
subgames = {}
|
|
|
|
player_lobby = {}
|
|
subgames.games = {}
|
|
|
|
dofile(minetest.get_modpath("subgames") .."/spectator.lua")
|
|
dofile(minetest.get_modpath("subgames") .."/hud.lua")
|
|
dofile(minetest.get_modpath("subgames") .."/functions.lua")
|
|
dofile(minetest.get_modpath("subgames") .."/map.lua")
|
|
if minetest.get_modpath("sfinv") then
|
|
dofile(minetest.get_modpath("subgames") .."/sfinv.lua")
|
|
end
|
|
|
|
--[[
|
|
Def should be:
|
|
{
|
|
fullname = "Mesewars"
|
|
object = mesewars (Not used yet)
|
|
area = {
|
|
[1] = {x=(-700), y=1000, z=-700},
|
|
[2] = {x=75, y=1302, z=(-17)}
|
|
}
|
|
|
|
optional...
|
|
node_dig = function(pos, node, digger)
|
|
item_place_node = function(itemstack, placer, pointed_thing, param2)
|
|
drop = function(pos, itemname, player)
|
|
remove_player = function(name)
|
|
crafting = true
|
|
}
|
|
|
|
]]
|
|
function subgames.register_game(name, def)
|
|
def.name = name
|
|
subgames.games[name] = def
|
|
end
|
|
|
|
-- Add a register on chat message (name, message)
|
|
subgames.on_chat_message = {}
|
|
function subgames.register_on_chat_message(func)
|
|
table.insert(subgames.on_chat_message, func)
|
|
end
|
|
|
|
minetest.register_on_chat_message(function(name, message)
|
|
local toreturn = nil
|
|
for _, value in pairs(subgames.on_chat_message) do
|
|
if value(name, message, player_lobby[name]) == true then
|
|
toreturn = true
|
|
end
|
|
end
|
|
return toreturn
|
|
end)
|
|
|
|
-- Add a register on dieplayer (player)
|
|
subgames.on_dieplayer = {}
|
|
function subgames.register_on_dieplayer(func)
|
|
table.insert(subgames.on_dieplayer, func)
|
|
end
|
|
|
|
minetest.register_on_dieplayer(function(player)
|
|
local name = player:get_player_name()
|
|
for _, value in pairs(subgames.on_dieplayer) do
|
|
value(player, player_lobby[name])
|
|
end
|
|
end)
|
|
|
|
local death = {}
|
|
local redeath = {}
|
|
|
|
-- Add a register on kill player (killer, killed)
|
|
subgames.on_kill_player = {}
|
|
function subgames.register_on_kill_player(func)
|
|
table.insert(subgames.on_kill_player, func)
|
|
end
|
|
|
|
minetest.register_on_punchplayer(function(player, hitter, time_from_last_punch, tool_capabilities, dir, damage)
|
|
if player and hitter then
|
|
local name = player:get_player_name()
|
|
if player:get_hp() - damage <= 0 and not death[name] then
|
|
death[name] = true
|
|
if damage <= 0 then
|
|
return true
|
|
end
|
|
local killname = hitter:get_player_name()
|
|
if player_lobby[name] == player_lobby[killname] then
|
|
for _, func in pairs(subgames.on_kill_player) do
|
|
func(hitter, player, player_lobby[name])
|
|
end
|
|
else minetest.kick_player(name)
|
|
minetest.kick_player(killname)
|
|
end
|
|
end
|
|
end
|
|
end)
|
|
|
|
-- Add a register on respawn player (player)
|
|
subgames.on_respawnplayer = {}
|
|
function subgames.register_on_respawnplayer(func)
|
|
table.insert(subgames.on_respawnplayer, func)
|
|
end
|
|
|
|
minetest.register_on_respawnplayer(function(player)
|
|
local name = player:get_player_name()
|
|
death[name] = nil
|
|
redeath[name] = nil
|
|
for _, value in pairs(subgames.on_respawnplayer) do
|
|
value(player, player_lobby[name])
|
|
end
|
|
end)
|
|
|
|
-- Add a register on dig node (pos, oldnode, digger)
|
|
subgames.on_dignode = {}
|
|
function subgames.register_on_dignode(func)
|
|
table.insert(subgames.on_dignode, func)
|
|
end
|
|
|
|
minetest.register_on_dignode(function(pos, oldnode, digger)
|
|
if digger and digger:is_player() then
|
|
local name = digger:get_player_name()
|
|
for _, value in pairs(subgames.on_dignode) do
|
|
value(pos, oldnode, digger, player_lobby[name])
|
|
end
|
|
end
|
|
end)
|
|
|
|
local old_node_dig = minetest.node_dig
|
|
function minetest.node_dig(pos, node, digger)
|
|
local lobby
|
|
if digger then
|
|
local name = digger:get_player_name()
|
|
lobby = player_lobby[name]
|
|
else lobby = subgames.get_lobby_from_pos(pos)
|
|
end
|
|
if not lobby then return end
|
|
if subgames.games[lobby].node_dig then
|
|
local result = subgames.games[lobby].node_dig(pos, node, digger)
|
|
if result == true then
|
|
return old_node_dig(pos, node, digger)
|
|
else return
|
|
end
|
|
else return old_node_dig(pos, node, digger)
|
|
end
|
|
end
|
|
|
|
-- Add a register on place node (pos, newnode, placer, oldnode, itemstack, pointed_thing)
|
|
subgames.on_placenode = {}
|
|
function subgames.register_on_placenode(func)
|
|
table.insert(subgames.on_placenode, func)
|
|
end
|
|
|
|
local placing = {}
|
|
minetest.register_on_placenode(function(pos, newnode, placer, oldnode, itemstack, pointed_thing)
|
|
local rlname = ""
|
|
if placer and placer:is_player() then
|
|
local name = placer:get_player_name()
|
|
rlname = player_lobby[name]
|
|
else
|
|
rlname = subgames.get_lobby_from_pos(pos)
|
|
end
|
|
local toreturn
|
|
for _,value in pairs(subgames.on_placenode) do
|
|
if value(pos, newnode, placer, oldnode, itemstack, pointed_thing, rlname) == true then
|
|
toreturn = true
|
|
end
|
|
end
|
|
return toreturn
|
|
end)
|
|
|
|
local old_node_place = minetest.item_place_node
|
|
function minetest.item_place_node(itemstack, placer, pointed_thing, param2)
|
|
local lobby
|
|
if placer then
|
|
local name = placer:get_player_name()
|
|
lobby = player_lobby[name]
|
|
else local pos = minetest.get_pointed_thing_position(pointed_thing, false)
|
|
lobby = subgames.get_lobby_from_pos(pos)
|
|
end
|
|
if not lobby then return end
|
|
if subgames.games[lobby].item_place_node then
|
|
local result = subgames.games[lobby].item_place_node(itemstack, placer, pointed_thing, param2)
|
|
if result == true then
|
|
return old_node_place(itemstack, placer, pointed_thing, param2)
|
|
else return
|
|
end
|
|
else return old_node_place(itemstack, placer, pointed_thing, param2)
|
|
end
|
|
end
|
|
|
|
-- Add a register on punchplayer (player, hitter, time_from_last_punch, tool_capabilities, dir, damage)
|
|
subgames.on_punchplayer = {}
|
|
function subgames.register_on_punchplayer(func)
|
|
table.insert(subgames.on_punchplayer, func)
|
|
end
|
|
|
|
minetest.register_on_punchplayer(function(player, hitter, time_from_last_punch, tool_capabilities, dir, damage)
|
|
if player and hitter then
|
|
local name = player:get_player_name()
|
|
local killname = hitter:get_player_name()
|
|
local to_return = nil
|
|
if player_lobby[name] == player_lobby[killname] then
|
|
for _, func in pairs(subgames.on_punchplayer) do
|
|
if func(player, hitter, time_from_last_punch, tool_capabilities, dir, damage, player_lobby[name]) then
|
|
to_return = true
|
|
end
|
|
end
|
|
end
|
|
return to_return
|
|
end
|
|
end)
|
|
|
|
-- Add a register on join player (player)
|
|
subgames.on_joinplayer = {}
|
|
function subgames.register_on_joinplayer(func)
|
|
table.insert(subgames.on_joinplayer, func)
|
|
end
|
|
|
|
function subgames.call_join_callbacks(player, lobby)
|
|
local name = player:get_player_name()
|
|
player_lobby[name] = lobby
|
|
subgames.clear_inv(player)
|
|
sfinv.set_page(player, "3d_armor:armor")
|
|
local privs = minetest.get_player_privs(name)
|
|
privs.armor = true
|
|
privs.craft = nil -- Compatibility
|
|
minetest.set_player_privs(name, privs)
|
|
sfinv.set_player_inventory_formspec(player)
|
|
for _,value in pairs(subgames.on_joinplayer) do
|
|
value(player, lobby)
|
|
end
|
|
end
|
|
|
|
-- Add a register on leave player (player)
|
|
subgames.on_leaveplayer = {}
|
|
function subgames.register_on_leaveplayer(func)
|
|
table.insert(subgames.on_leaveplayer, func)
|
|
end
|
|
|
|
function subgames.call_leave_callbacks(player)
|
|
local name = player:get_player_name()
|
|
for _,value in pairs(subgames.on_leaveplayer) do
|
|
value(player, player_lobby[name])
|
|
end
|
|
player:set_nametag_attributes({color = {a = 255, r = 255, g = 255, b = 255}})
|
|
subgames.unspectate(player)
|
|
player_lobby[name] = nil
|
|
end
|
|
|
|
minetest.register_on_leaveplayer(function(player)
|
|
subgames.call_leave_callbacks(player)
|
|
end)
|
|
|
|
-- Add auto respawn
|
|
minetest.register_on_dieplayer(function(player)
|
|
local name = player:get_player_name()
|
|
if redeath[name] then return end
|
|
redeath[name] = true
|
|
minetest.after(0.5, function()
|
|
if player:is_player_connected() == true then
|
|
minetest.close_formspec(name, "")
|
|
player:set_hp(20)
|
|
death[name] = nil
|
|
redeath[name] = nil
|
|
for _,value in pairs(subgames.on_respawnplayer) do
|
|
value(player, player_lobby[name])
|
|
end
|
|
end
|
|
end)
|
|
end)
|
|
|
|
-- Add a special command register
|
|
subgames.registered_chatcommands = {}
|
|
function subgames.handle_command_func(name, param, cname)
|
|
local lobby = player_lobby[name]
|
|
if subgames.registered_chatcommands[lobby] then
|
|
local todo = subgames.registered_chatcommands[lobby][cname]
|
|
if todo then
|
|
todo(name, param)
|
|
end
|
|
end
|
|
end
|
|
|
|
function subgames.register_chatcommand(cname, def)
|
|
if not subgames.registered_chatcommands[def.lobby] then
|
|
subgames.registered_chatcommands[def.lobby] = {}
|
|
end
|
|
subgames.registered_chatcommands[def.lobby][cname]=def.func
|
|
if not minetest.registered_chatcommands[cname] then
|
|
minetest.register_chatcommand(cname, {
|
|
params = def.params,
|
|
description = def.description,
|
|
privs = def.privs,
|
|
func = function(name, param)
|
|
subgames.handle_command_func(name, param, cname)
|
|
end,
|
|
})
|
|
end
|
|
end
|
|
|
|
|
|
-- Add a register on item eat (hp_change, replace_with_item, itemstack, user, pointed_thing)
|
|
subgames.on_item_eat = {}
|
|
function subgames.register_on_item_eat(func)
|
|
table.insert(subgames.on_item_eat, func)
|
|
end
|
|
|
|
minetest.register_on_item_eat(function(hp_change, replace_with_item, itemstack, user, pointed_thing)
|
|
local name = user:get_player_name()
|
|
for _,value in pairs(subgames.on_item_eat) do
|
|
value(hp_change, replace_with_item, itemstack, user, pointed_thing, player_lobby[name])
|
|
end
|
|
end)
|
|
|
|
-- Add a register on punch node (pos, node, puncher, pointed_thing)
|
|
subgames.on_punchnode = {}
|
|
function subgames.register_on_punchnode(func)
|
|
table.insert(subgames.on_punchnode, func)
|
|
end
|
|
|
|
minetest.register_on_punchnode(function(pos, node, puncher, pointed_thing)
|
|
local name = puncher:get_player_name()
|
|
for _,value in pairs(subgames.on_punchnode) do
|
|
value(pos, node, puncher, pointed_thing, player_lobby[name])
|
|
end
|
|
end)
|
|
|
|
-- Add a register on drop (itemstack, dropper, pos)
|
|
subgames.on_drop = {}
|
|
function subgames.register_on_drop(func)
|
|
table.insert(subgames.on_drop, func)
|
|
end
|
|
local dropfuncs = {}
|
|
|
|
function subgames.handle_drop(itemstack, dropper, pos)
|
|
if dropper and dropper:is_player() then
|
|
local name = dropper:get_player_name()
|
|
local lobby = player_lobby[name]
|
|
local todrop = true
|
|
for _,value in pairs(subgames.on_drop) do
|
|
if value(itemstack, dropper, pos, lobby) == false then
|
|
todrop = false
|
|
end
|
|
end
|
|
if todrop then
|
|
if dropfuncs[itemstack:get_name()] then
|
|
return dropfuncs[itemstack:get_name()](itemstack, dropper, pos)
|
|
else minetest.item_drop(itemstack, dropper, pos)
|
|
return itemstack:take_item()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local old_node_drops = minetest.handle_node_drops
|
|
function minetest.handle_node_drops(pos, itemname, player)
|
|
local name = player:get_player_name()
|
|
local lobby = player_lobby[name]
|
|
if not lobby then
|
|
lobby = subgames.get_lobby_from_pos(pos)
|
|
if not lobby then
|
|
return false
|
|
end
|
|
end
|
|
local func = subgames.games[lobby].drop
|
|
if not func then
|
|
return false
|
|
elseif func(pos, itemname, player) then
|
|
old_node_drops(pos, itemname, player)
|
|
end
|
|
end
|
|
|
|
minetest.override_item("tnt:tnt_burning", {description="TNT"})
|
|
|
|
-- Register on blas (pos, intensity)
|
|
subgames.on_blast = {}
|
|
function subgames.register_on_blast(func)
|
|
table.insert(subgames.on_blast, func)
|
|
end
|
|
local blastfuncs = {}
|
|
|
|
function subgames.handle_blast(pos, intensity)
|
|
local lobby = subgames.get_lobby_from_pos(pos)
|
|
if lobby then
|
|
local toblast = true
|
|
for _,value in pairs(subgames.on_blast) do
|
|
if value(pos, intensity, lobby) == false then
|
|
toblast = false
|
|
end
|
|
end
|
|
if toblast then
|
|
if blastfuncs[minetest.get_node(pos).name] then
|
|
blastfuncs[minetest.get_node(pos).name](pos, intensity)
|
|
else minetest.remove_node(pos)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
minetest.after(1, function()
|
|
for name, def in pairs(minetest.registered_items) do
|
|
if def.on_drop then
|
|
dropfuncs[name] = def.on_drop
|
|
end
|
|
minetest.override_item(name, {on_drop=subgames.handle_drop})
|
|
end
|
|
for name, def in pairs(minetest.registered_nodes) do
|
|
if def.on_blast then
|
|
blastfuncs[name] = def.on_blast
|
|
end
|
|
minetest.override_item(name, {on_blast=subgames.handle_blast})
|
|
end
|
|
end)
|
|
|
|
minetest.register_on_craft(function(itemstack, player, old_craft_grid, craft_inv)
|
|
local name = player:get_player_name()
|
|
if subgames.games[lobby] and subgames.games[lobby] == false then
|
|
return true
|
|
end
|
|
end)
|