193 lines
7.4 KiB
Lua
193 lines
7.4 KiB
Lua
-- advtrains
|
|
-- protection.lua: privileges and rail protection, and some helpers
|
|
|
|
|
|
-- Privileges to control TRAIN DRIVING/COUPLING
|
|
minetest.register_privilege("train_operator", {
|
|
description = "Without this privilege, a player can't do anything about trains, neither place or remove them nor drive or couple them (but he can build tracks if he has track_builder)",
|
|
give_to_singleplayer= true,
|
|
});
|
|
|
|
minetest.register_privilege("train_admin", {
|
|
description = "Player may drive, place or remove any trains from/to anywhere, regardless of owner, whitelist or protection",
|
|
give_to_singleplayer= true,
|
|
});
|
|
|
|
-- Privileges to control TRACK BUILDING
|
|
minetest.register_privilege("track_builder", {
|
|
description = "Player can place and/or dig rails not protected from him. If he also has protection_bypass, he can place/dig any rails",
|
|
give_to_singleplayer= true,
|
|
});
|
|
|
|
-- Privileges to control OPERATING TURNOUTS/SIGNALS
|
|
minetest.register_privilege("railway_operator", {
|
|
description = "Player can operate turnouts and signals not protected from him. If he also has protection_bypass, he can operate any turnouts/signals",
|
|
give_to_singleplayer= true,
|
|
});
|
|
|
|
-- there is a configuration option "allow_build_only_owner". If this is active, a player having track_builder can only build rails and operate signals/turnouts in an area explicitly belonging to him
|
|
-- (checked using a dummy player called "*dummy*" (which is not an allowed player name))
|
|
|
|
--[[
|
|
Protection/privilege concept:
|
|
Tracks:
|
|
Protected 1 node all around a rail and 4 nodes upward (maybe make this dynamically determined by the rail...)
|
|
if track_builder privilege:
|
|
if not protected from* player:
|
|
if allow_build_only_owner:
|
|
if unprotected:
|
|
deny
|
|
else:
|
|
allow
|
|
deny
|
|
Wagons in general:
|
|
Players can only place/destroy wagons if they have train_operator
|
|
Wagon driving controls:
|
|
The former seat_access tables are unnecessary, instead there is a whitelist for the driving stands
|
|
on player trying to access a driver stand:
|
|
if is owner or is on whitelist:
|
|
allow
|
|
else:
|
|
deny
|
|
Wagon coupling:
|
|
Derived from the privileges for driving stands. The whitelist is shared (and also settable on non-driverstand wagons)
|
|
for each of the two bordering wagons:
|
|
if is owner or is on whitelist:
|
|
allow
|
|
|
|
*"protected from" means the player is not allowed to do things, while "protected by" means that the player is (one of) the owner(s) of this area
|
|
|
|
]]--
|
|
|
|
local boo = minetest.settings:get_bool("advtrains_allow_build_to_owner")
|
|
|
|
-- temporarily prevent scanning for neighboring rail nodes recursively
|
|
local nocheck
|
|
|
|
local old_is_protected = minetest.is_protected
|
|
|
|
-- Check if the node we are about to check is in the range of a track that is protected from a player
|
|
minetest.is_protected = function(pos, pname)
|
|
|
|
-- old_is_protected:
|
|
-- If an earlier callback decided that pos is protected, we wouldn't have been called
|
|
-- if a later callback decides it, get that here.
|
|
-- this effectively puts this function into a final-choice position
|
|
local oprot = old_is_protected(pos, pname)
|
|
if oprot then
|
|
return true
|
|
end
|
|
|
|
if nocheck or pname=="" then
|
|
return false
|
|
end
|
|
|
|
-- Special exception: to allow seamless rail connections between 2 separately protected
|
|
-- networks, rails itself are not affected by the radius setting. So, if the node here is
|
|
-- a rail, we skip the check and just use check_track_protection on same pos.
|
|
local node = minetest.get_node(pos)
|
|
if minetest.get_item_group(node.name, "advtrains_track") > 0 then
|
|
-- by here, we know that no other protection callback has this protected, we can safely pass "false".
|
|
-- hope this doesn't lead to bugs!
|
|
return not advtrains.check_track_protection(pos, pname, nil, false)
|
|
end
|
|
|
|
local r, vr = 1, 3
|
|
local nodes = minetest.find_nodes_in_area(
|
|
{x = pos.x - r, y = pos.y - vr, z = pos.z - r},
|
|
{x = pos.x + r, y = pos.y + 1, z = pos.z + r},
|
|
{"group:advtrains_track"})
|
|
for _,npos in ipairs(nodes) do
|
|
if not advtrains.check_track_protection(npos, pname, pos) then
|
|
return true
|
|
end
|
|
end
|
|
nocheck=false
|
|
return false
|
|
end
|
|
|
|
-- Check whether the player is permitted to modify this track
|
|
-- Shall be called only for nodes that are or are about to become tracks.
|
|
-- The range check from is_track_near_protected is disabled here.
|
|
-- this splits in 1. track_builder privilege and 2. is_protected
|
|
-- also respects the allow_build_to_owner property.
|
|
--WARN: true means here that the action is allowed!
|
|
function advtrains.check_track_protection(pos, pname, near, prot_p)
|
|
-- Parameter "near" is an optional position, the original node that the player
|
|
-- was about to affect, while "pos" represents the checked rail node
|
|
-- if "near" is not set, pos is the same node.
|
|
local nears = near and "near " or ""
|
|
local apos = near or pos
|
|
|
|
-- note that having protection_bypass implicitly implies having track_builder, because else it would be possible to dig rails
|
|
-- (only checked by is_protected, which is not respected) but not place them.
|
|
-- We won't impose restrictions on protection_bypass owners.
|
|
if minetest.check_player_privs(pname, {protection_bypass = true}) then
|
|
return true
|
|
end
|
|
|
|
nocheck = true
|
|
local priv = minetest.check_player_privs(pname, {track_builder = true})
|
|
|
|
-- note: is_protected above already checks the is_protected value against the current player, so checking it again is useless.
|
|
local prot = prot_p
|
|
if prot==nil then
|
|
prot = advtrains.is_protected(pos, pname)
|
|
end
|
|
local dprot = minetest.is_protected(pos, "*dummy*")
|
|
nocheck = false
|
|
|
|
--atdebug("CTP: ",pos,pname,near,prot_p,"priv=",priv,"prot=",prot,"dprot=",dprot)
|
|
|
|
if not priv and (not boo or prot or not dprot) then
|
|
minetest.chat_send_player(pname, "You are not allowed to build "..nears.."tracks without track_builder privilege")
|
|
minetest.log("action", pname.." tried to modify terrain "..nears.."track at "..minetest.pos_to_string(apos).." but is not permitted to (no privilege)")
|
|
return false
|
|
end
|
|
if prot then
|
|
minetest.chat_send_player(pname, "You are not allowed to build "..nears.."tracks at protected position!")
|
|
minetest.record_protection_violation(pos, pname)
|
|
minetest.log("action", pname.." tried to modify "..nears.."track at "..minetest.pos_to_string(apos).." but position is protected!")
|
|
return false
|
|
end
|
|
return true
|
|
end
|
|
|
|
--WARN: true means here that the action is allowed!
|
|
function advtrains.check_driving_couple_protection(pname, owner, whitelist)
|
|
if minetest.check_player_privs(pname, {train_admin = true}) then
|
|
return true
|
|
end
|
|
if not minetest.check_player_privs(pname, {train_operator = true}) then
|
|
return false
|
|
end
|
|
if not owner or owner == pname then
|
|
return true
|
|
end
|
|
if whitelist and string.find(" "..whitelist.." ", " "..pname.." ", nil, true) then
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
function advtrains.check_turnout_signal_protection(pos, pname)
|
|
nocheck=true
|
|
if not minetest.check_player_privs(pname, {railway_operator = true}) then
|
|
if boo and not advtrains.is_protected(pos, pname) and minetest.is_protected(pos, "*dummy*") then
|
|
nocheck=false
|
|
return true
|
|
else
|
|
minetest.chat_send_player(pname, "You are not allowed to operate turnouts and signals (missing railway_operator privilege)")
|
|
minetest.log("action", pname.." tried to operate turnout/signal at "..minetest.pos_to_string(pos).." but does not have railway_operator")
|
|
nocheck=false
|
|
return false
|
|
end
|
|
end
|
|
if advtrains.is_protected(pos, pname) then
|
|
minetest.record_protection_violation(pos, pname)
|
|
nocheck=false
|
|
return false
|
|
end
|
|
nocheck=false
|
|
return true
|
|
end
|