989 lines
40 KiB
Lua
989 lines
40 KiB
Lua
FPP = FPP or {}
|
|
|
|
util.AddNetworkString("FPP_Groups")
|
|
util.AddNetworkString("FPP_GroupMembers")
|
|
util.AddNetworkString("FPP_RestrictedToolList")
|
|
util.AddNetworkString("FPP_BlockedModels")
|
|
|
|
FPP.Blocked = FPP.Blocked or {}
|
|
FPP.Blocked.Physgun1 = FPP.Blocked.Physgun1 or {}
|
|
FPP.Blocked.Spawning1 = FPP.Blocked.Spawning1 or {}
|
|
FPP.Blocked.Gravgun1 = FPP.Blocked.Gravgun1 or {}
|
|
FPP.Blocked.Toolgun1 = FPP.Blocked.Toolgun1 or {}
|
|
FPP.Blocked.PlayerUse1 = FPP.Blocked.PlayerUse1 or {}
|
|
FPP.Blocked.EntityDamage1 = FPP.Blocked.EntityDamage1 or {}
|
|
|
|
FPP.BlockedModels = FPP.BlockedModels or {}
|
|
|
|
FPP.RestrictedTools = FPP.RestrictedTools or {}
|
|
FPP.RestrictedToolsPlayers = FPP.RestrictedToolsPlayers or {}
|
|
|
|
FPP.Groups = FPP.Groups or {}
|
|
FPP.GroupMembers = FPP.GroupMembers or {}
|
|
|
|
function FPP.Notify(ply, text, bool, total_time)
|
|
if ply:EntIndex() == 0 then
|
|
ServerLog(text)
|
|
return
|
|
end
|
|
umsg.Start("FPP_Notify", ply)
|
|
umsg.String(text)
|
|
umsg.Bool(bool)
|
|
umsg.Float(total_time or 6)
|
|
umsg.End()
|
|
ply:PrintMessage(HUD_PRINTCONSOLE, text)
|
|
end
|
|
|
|
function FPP.NotifyAll(text, bool, total_time)
|
|
umsg.Start("FPP_Notify")
|
|
umsg.String(text)
|
|
umsg.Bool(bool)
|
|
umsg.Float(total_time or 6)
|
|
umsg.End()
|
|
for _, ply in ipairs(player.GetAll()) do
|
|
ply:PrintMessage(HUD_PRINTCONSOLE, text)
|
|
end
|
|
end
|
|
|
|
local function getSettingsChangedEntities(settingsType, setting)
|
|
local plys, entities = {}, {}
|
|
|
|
local blockedString = string.sub(settingsType, 5, 5) .. string.lower(string.sub(settingsType, 6))
|
|
|
|
blockedString = blockedString == "Playeruse1" and "PlayerUse1" or blockedString -- dirty hack for stupid naming system.
|
|
blockedString = blockedString == "Entitydamage1" and "EntityDamage1" or blockedString -- dirty hack for stupid naming system.
|
|
|
|
if setting == "adminall" then
|
|
for _, v in ipairs(ents.GetAll()) do
|
|
if not IsValid(v) then continue end
|
|
local owner = v:CPPIGetOwner()
|
|
if IsValid(owner) then table.insert(entities, v) end
|
|
end
|
|
|
|
for _, v in ipairs(player.GetAll()) do
|
|
v.FPP_Privileges = v.FPP_Privileges or {}
|
|
if v.FPP_Privileges.FPP_TouchOtherPlayersProps then table.insert(plys, v) end
|
|
end
|
|
|
|
return plys, entities
|
|
elseif setting == "worldprops" or setting == "adminworldprops" then
|
|
for _, v in ipairs(ents.GetAll()) do
|
|
if FPP.Blocked[blockedString][string.lower(v:GetClass())] then continue end
|
|
|
|
local owner = v:CPPIGetOwner()
|
|
if not IsValid(owner) then table.insert(entities, v) end
|
|
end
|
|
|
|
for _, v in ipairs(player.GetAll()) do
|
|
v.FPP_Privileges = v.FPP_Privileges or {}
|
|
if v.FPP_Privileges.FPP_TouchOtherPlayersProps then table.insert(plys, v) end
|
|
end
|
|
return setting == "adminworldprops" and plys or player.GetAll(), entities
|
|
elseif setting == "canblocked" or setting == "admincanblocked" then
|
|
for _, v in ipairs(ents.GetAll()) do
|
|
if not FPP.Blocked[blockedString][string.lower(v:GetClass())] then continue end
|
|
table.insert(entities, v)
|
|
end
|
|
|
|
for _, v in ipairs(player.GetAll()) do
|
|
v.FPP_Privileges = v.FPP_Privileges or {}
|
|
if v.FPP_Privileges.FPP_TouchOtherPlayersProps then table.insert(plys, v) end
|
|
end
|
|
return setting == "admincanblocked" and plys or player.GetAll(), entities
|
|
elseif setting == "iswhitelist" then
|
|
return player.GetAll(), ents.GetAll()
|
|
end
|
|
end
|
|
|
|
util.AddNetworkString("FPP_Settings")
|
|
local function SendSettings(ply)
|
|
net.Start("FPP_Settings")
|
|
FPP.ForAllSettings(function(k, s, v)
|
|
net.WriteDouble(v)
|
|
end)
|
|
net.Send(ply)
|
|
end
|
|
|
|
util.AddNetworkString("FPP_Settings_Update")
|
|
local function updateFPPSetting(kind, setting, value)
|
|
local skipKind, skipSetting = 0, 0
|
|
FPP.Settings[kind][setting] = value
|
|
|
|
local finalSkipKind
|
|
FPP.ForAllSettings(function(k, s)
|
|
skipKind = skipKind + 1
|
|
|
|
if k ~= kind then return true end
|
|
finalSkipKind = skipKind - skipSetting
|
|
skipSetting = skipSetting + 1
|
|
if s ~= setting then return end
|
|
|
|
return true
|
|
end)
|
|
|
|
net.Start("FPP_Settings_Update")
|
|
net.WriteUInt(finalSkipKind, 8)
|
|
net.WriteUInt(skipSetting, 8)
|
|
net.WriteDouble(value)
|
|
net.Broadcast()
|
|
end
|
|
|
|
local function runIfAccess(priv, f)
|
|
return function(ply, cmd, args)
|
|
CAMI.PlayerHasAccess(ply, priv, function(allowed, _)
|
|
if allowed then return f(ply, cmd, args) end
|
|
|
|
FPP.Notify(ply, string.format("You need the '%s' privilege in order to be able to use this command", priv), false)
|
|
end)
|
|
end
|
|
end
|
|
|
|
local function FPP_SetSetting(ply, cmd, args)
|
|
if not args[1] then FPP.Notify(ply, "FPP_setting: First argument (setting name) not given!", false) return end
|
|
if not args[3] then FPP.Notify(ply, "FPP_setting: Third argument (the value of the setting) not given", false) return end
|
|
if not FPP.Settings[args[1]] then
|
|
FPP.Notify(ply, ("FPP_setting: Setting %s does not exist! Settings that DO exist:"):format(args[1]), false)
|
|
|
|
for setting, _ in pairs(FPP.Settings) do
|
|
FPP.Notify(ply, setting, false)
|
|
end
|
|
return
|
|
end
|
|
if not FPP.Settings[args[1]][args[2]] then FPP.Notify(ply, ("FPP_setting: Setting %s.%s does not exist!"):format(args[1], args[2]), false) return end
|
|
|
|
updateFPPSetting(args[1], args[2], tonumber(args[3]))
|
|
|
|
MySQLite.queryValue("SELECT var FROM " .. args[1] .. " WHERE var = " .. sql.SQLStr(args[2]) .. ";", function(data)
|
|
if not data then
|
|
MySQLite.query("INSERT INTO " .. args[1] .. " VALUES(" .. sql.SQLStr(args[2]) .. ", " .. args[3] .. ");")
|
|
elseif tonumber(data) ~= args[3] then
|
|
MySQLite.query("UPDATE " .. args[1] .. " SET setting = " .. args[3] .. " WHERE var = " .. sql.SQLStr(args[2]) .. ";")
|
|
end
|
|
|
|
FPP.NotifyAll(((ply.Nick and ply:Nick()) or "Console") .. " set " .. string.lower(string.gsub(args[1], "FPP_", "")) .. " " .. args[2] .. " to " .. tostring(args[3]), tobool(tonumber(args[3])))
|
|
end)
|
|
|
|
FPP.calculatePlayerPrivilege("FPP_TouchOtherPlayersProps", function()
|
|
local plys, entities = getSettingsChangedEntities(args[1], args[2])
|
|
if not plys or not entities or #plys == 0 or #entities == 0 then return end
|
|
|
|
FPP.recalculateCanTouch(plys, entities)
|
|
end)
|
|
end
|
|
concommand.Add("FPP_setting", runIfAccess("FPP_Settings", FPP_SetSetting))
|
|
|
|
local function AddBlocked(ply, cmd, args)
|
|
if not args[1] then FPP.Notify(ply, "FPP_AddBlocked: Block list not given", false) return end
|
|
if not args[2] then FPP.Notify(ply, "FPP_AddBlocked: Entity to block not given", false) return end
|
|
if not FPP.Blocked[args[1]] then FPP.Notify(ply, ("FPP_AddBlocked: Block list %s does not exist"):format(args[1]), false) return end
|
|
|
|
args[2] = string.lower(args[2])
|
|
if FPP.Blocked[args[1]][args[2]] then return end
|
|
FPP.Blocked[args[1]][args[2]] = true
|
|
|
|
MySQLite.query(string.format("INSERT INTO FPP_BLOCKED1 (var, setting) VALUES(%s, %s);", sql.SQLStr(args[1]), sql.SQLStr(args[2])))
|
|
|
|
FPP.NotifyAll(((ply.Nick and ply:Nick()) or "Console") .. " added " .. args[2] .. " to the " .. args[1] .. " black/whitelist", true)
|
|
|
|
FPP.recalculateCanTouch(player.GetAll(), ents.FindByClass(args[2]))
|
|
end
|
|
concommand.Add("FPP_AddBlocked", runIfAccess("FPP_Settings", AddBlocked))
|
|
|
|
-- Models can differ between server and client. Famous example being:
|
|
-- models/props_phx/cannonball_solid.mdl <-- serverside
|
|
-- models/props_phx/cannonball.mdl <-- clientside
|
|
-- Similar problems occur with effects
|
|
local function getIntendedBlockedModels(model, ent)
|
|
model = string.Replace(string.lower(model), "\\", "/")
|
|
|
|
if not IsValid(ent) then return {model} end
|
|
if ent:GetClass() == "prop_effect" then return {ent.AttachedEntity:GetModel()} end
|
|
if model ~= ent:GetModel() then return {model, ent:GetModel()} end
|
|
return {model}
|
|
end
|
|
|
|
local function AddBlockedModel(ply, cmd, args)
|
|
if not args[1] then FPP.Notify(ply, "FPP_AddBlockedModel: Model not given", false) return end
|
|
|
|
local models = getIntendedBlockedModels(args[1], tonumber(args[2]) and Entity(args[2]) or nil)
|
|
|
|
for _, model in pairs(models) do
|
|
if FPP.BlockedModels[model] then FPP.Notify(ply, string.format([["%s" is already in the black/whitelist]], model), false) continue end
|
|
FPP.BlockedModels[model] = true
|
|
MySQLite.query("REPLACE INTO FPP_BLOCKEDMODELS1 VALUES(" .. sql.SQLStr(model) .. ");")
|
|
FPP.NotifyAll(((ply.Nick and ply:Nick()) or "Console") .. " added " .. model .. " to the blocked models black/whitelist", true)
|
|
end
|
|
end
|
|
concommand.Add("FPP_AddBlockedModel", runIfAccess("FPP_Settings", AddBlockedModel))
|
|
|
|
local function RemoveBlocked(ply, cmd, args)
|
|
if not args[1] then FPP.Notify(ply, "FPP_RemoveBlocked: Block list not given", false) return end
|
|
if not args[2] then FPP.Notify(ply, "FPP_RemoveBlocked: Entity to block not given", false) return end
|
|
if not FPP.Blocked[args[1]] then FPP.Notify(ply, ("FPP_RemoveBlocked: Block list %s does not exist"):format(args[1]), false) return end
|
|
|
|
FPP.Blocked[args[1]][args[2]] = nil
|
|
|
|
MySQLite.query("DELETE FROM FPP_BLOCKED1 WHERE var = " .. sql.SQLStr(args[1]) .. " AND setting = " .. sql.SQLStr(args[2]) .. ";")
|
|
FPP.NotifyAll(((ply.Nick and ply:Nick()) or "Console") .. " removed " .. args[2] .. " from the " .. args[1] .. " black/whitelist", false)
|
|
FPP.recalculateCanTouch(player.GetAll(), ents.FindByClass(args[2]))
|
|
end
|
|
concommand.Add("FPP_RemoveBlocked", runIfAccess("FPP_Settings", RemoveBlocked))
|
|
|
|
local function RemoveBlockedModel(ply, cmd, args)
|
|
if not args[1] then FPP.Notify(ply, "FPP_RemoveBlockedModel: Model not given", false) return end
|
|
local models = getIntendedBlockedModels(args[1], tonumber(args[2]) and Entity(args[2]) or nil)
|
|
|
|
for _, model in pairs(models) do
|
|
FPP.BlockedModels[model] = nil
|
|
|
|
MySQLite.query("DELETE FROM FPP_BLOCKEDMODELS1 WHERE model = " .. sql.SQLStr(model) .. ";")
|
|
FPP.NotifyAll(((ply.Nick and ply:Nick()) or "Console") .. " removed " .. model .. " from the blocked models black/whitelist", false)
|
|
end
|
|
end
|
|
concommand.Add("FPP_RemoveBlockedModel", runIfAccess("FPP_Settings", RemoveBlockedModel))
|
|
|
|
local allowedShares = {
|
|
SharePhysgun1 = true,
|
|
ShareGravgun1 = true,
|
|
SharePlayerUse1 = true,
|
|
ShareEntityDamage1 = true,
|
|
ShareToolgun1 = true
|
|
}
|
|
local function ShareProp(ply, cmd, args)
|
|
if not args[1] then FPP.Notify(ply, "FPP_ShareProp: Entity not given", false) return end
|
|
if not IsValid(Entity(args[1])) then FPP.Notify(ply, "FPP_ShareProp: Entity not valid", false) return end
|
|
if not args[2] then FPP.Notify(ply, "FPP_ShareProp: Player to share with not given", false) return end
|
|
|
|
local ent = Entity(args[1])
|
|
|
|
if ent:CPPIGetOwner() ~= ply then
|
|
FPP.Notify(ply, "You do not have the right to share this entity.", false)
|
|
return
|
|
end
|
|
|
|
if not tonumber(args[2]) or not IsValid(Player(tonumber(args[2]))) then -- This is for sharing prop per utility
|
|
if not allowedShares[args[2]] then
|
|
FPP.Notify(ply, "FPP_ShareProp: Player to share with doesn't exist", false)
|
|
return
|
|
end
|
|
ent[args[2]] = tobool(args[3])
|
|
else -- This is for sharing prop per player
|
|
local target = Player(tonumber(args[2]))
|
|
local toggle = tobool(args[3])
|
|
-- Make the table if it isn't there
|
|
if not ent.AllowedPlayers and toggle then
|
|
ent.AllowedPlayers = {target}
|
|
else
|
|
if toggle and not table.HasValue(ent.AllowedPlayers, target) then
|
|
table.insert(ent.AllowedPlayers, target)
|
|
FPP.Notify(target, ply:Nick() .. " shared an entity with you!", true)
|
|
elseif not toggle then
|
|
for k, v in pairs(ent.AllowedPlayers or {}) do
|
|
if v == target then
|
|
table.remove(ent.AllowedPlayers, k)
|
|
FPP.Notify(target, ply:Nick() .. " unshared an entity with you!", false)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
FPP.recalculateCanTouch(player.GetAll(), {ent})
|
|
end
|
|
concommand.Add("FPP_ShareProp", ShareProp)
|
|
|
|
local function RetrieveSettings()
|
|
MySQLite.begin()
|
|
for k in pairs(FPP.Settings) do
|
|
MySQLite.queueQuery("SELECT setting, var FROM " .. k .. ";", function(data)
|
|
if not data then return end
|
|
|
|
for _, value in pairs(data) do
|
|
if FPP.Settings[k][value.var] == nil then
|
|
-- Likely an old setting that has since been removed from FPP.
|
|
-- This setting however still exists in the DB. Time to remove it.
|
|
MySQLite.query("DELETE FROM " .. k .. " WHERE var = " .. sql.SQLStr(value.var) .. ";")
|
|
continue
|
|
end
|
|
|
|
FPP.Settings[k][value.var] = tonumber(value.setting)
|
|
end
|
|
end)
|
|
end
|
|
MySQLite.commit(function()
|
|
SendSettings(player.GetAll())
|
|
end)
|
|
end
|
|
|
|
local defaultBlocked = {
|
|
Physgun1 = {
|
|
["func_breakable_surf"] = true,
|
|
["func_brush"] = true,
|
|
["func_button"] = true,
|
|
["func_door"] = true,
|
|
["prop_door_rotating"] = true,
|
|
["func_door_rotating"] = true
|
|
},
|
|
Spawning1 = {
|
|
["func_breakable_surf"] = true,
|
|
["player"] = true,
|
|
["func_door"] = true,
|
|
["prop_door_rotating"] = true,
|
|
["func_door_rotating"] = true,
|
|
["ent_explosivegrenade"] = true,
|
|
["ent_mad_grenade"] = true,
|
|
["ent_flashgrenade"] = true,
|
|
["gmod_wire_field_device"] = true
|
|
},
|
|
Gravgun1 = {["func_breakable_surf"] = true, ["vehicle_"] = true},
|
|
Toolgun1 = {
|
|
["func_breakable_surf"] = true,
|
|
["func_button"] = true,
|
|
["player"] = true,
|
|
["func_door"] = true,
|
|
["prop_door_rotating"] = true,
|
|
["func_door_rotating"] = true
|
|
},
|
|
PlayerUse1 = {},
|
|
EntityDamage1 = {}
|
|
}
|
|
|
|
-- Fills the FPP blocked table with default things that are to be blocked
|
|
function FPP.FillDefaultBlocked()
|
|
local count = 0
|
|
MySQLite.begin()
|
|
|
|
-- All values that are to be inserted
|
|
local allValues = {}
|
|
|
|
for k, v in pairs(defaultBlocked) do
|
|
for a in pairs(v) do
|
|
FPP.Blocked[k][a] = true
|
|
count = count + 1
|
|
|
|
if not MySQLite.isMySQL() then
|
|
MySQLite.query("REPLACE INTO FPP_BLOCKED1 VALUES(" .. count .. ", " .. sql.SQLStr(k) .. ", " .. sql.SQLStr(a) .. ");")
|
|
else
|
|
table.insert(allValues, string.format("(%i, %s, %s)", count, sql.SQLStr(k), sql.SQLStr(a)))
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Run it all in a single query if using MySQL.
|
|
if MySQLite.isMySQL() then
|
|
MySQLite.query(string.format("INSERT IGNORE INTO FPP_BLOCKED1 VALUES %s", table.concat(allValues, ",")))
|
|
end
|
|
MySQLite.commit()
|
|
end
|
|
|
|
local function RetrieveBlocked()
|
|
MySQLite.query("SELECT * FROM FPP_BLOCKED1;", function(data)
|
|
if istable(data) then
|
|
for _, v in pairs(data) do
|
|
if not FPP.Blocked[v.var] then
|
|
ErrorNoHalt((v.var or "(nil var)") .. " blocked type does not exist! (Setting: " .. (v.setting or "") .. ")")
|
|
continue
|
|
end
|
|
|
|
FPP.Blocked[v.var][string.lower(v.setting)] = true
|
|
end
|
|
else
|
|
-- Give third party addons 5 seconds to add default blocked items
|
|
timer.Simple(5, FPP.FillDefaultBlocked)
|
|
end
|
|
end)
|
|
end
|
|
|
|
--[[-------------------------------------------------------------------------
|
|
Default blocked entities
|
|
Only save in the database on first start
|
|
---------------------------------------------------------------------------]]
|
|
function FPP.AddDefaultBlocked(types, classname)
|
|
classname = string.lower(classname)
|
|
|
|
if isstring(types) then
|
|
defaultBlocked[types] = defaultBlocked[types] or {}
|
|
defaultBlocked[types][classname] = true
|
|
return
|
|
end
|
|
|
|
for _, v in pairs(types) do
|
|
defaultBlocked[v] = defaultBlocked[v] or {}
|
|
defaultBlocked[v][classname] = true
|
|
end
|
|
end
|
|
|
|
local function RetrieveBlockedModels()
|
|
FPP.BlockedModels = FPP.BlockedModels or {}
|
|
-- Sometimes when the database retrieval is corrupt,
|
|
-- only parts of the table will be retrieved
|
|
-- This is a workaround
|
|
if not MySQLite.isMySQL() then
|
|
local count = MySQLite.queryValue("SELECT COUNT(*) FROM FPP_BLOCKEDMODELS1;") or 0
|
|
if tonumber(count) == 0 then
|
|
FPP.AddDefaultBlockedModels() -- Load the default blocked models on first run
|
|
end
|
|
|
|
-- Select with offsets of a thousand.
|
|
-- That's about the maximum it can receive properly at once
|
|
for i = 0, count, 1000 do
|
|
MySQLite.query("SELECT * FROM FPP_BLOCKEDMODELS1 LIMIT 1000 OFFSET " .. i .. ";", function(data)
|
|
for _, v in ipairs(data or {}) do
|
|
FPP.BlockedModels[v.model] = true
|
|
end
|
|
end)
|
|
end
|
|
|
|
return
|
|
end
|
|
|
|
-- Retrieve the data normally from MySQL
|
|
MySQLite.query("SELECT * FROM FPP_BLOCKEDMODELS1;", function(data)
|
|
if not data or #data == 0 then
|
|
FPP.AddDefaultBlockedModels() -- Load the default blocked models on first run
|
|
end
|
|
|
|
for _, v in ipairs(data or {}) do
|
|
if not v.model then continue end
|
|
FPP.BlockedModels[v.model] = true
|
|
end
|
|
end)
|
|
end
|
|
|
|
local function RetrieveRestrictedTools()
|
|
MySQLite.query("SELECT * FROM FPP_TOOLADMINONLY;", function(data)
|
|
if istable(data) then
|
|
for _, v in ipairs(data) do
|
|
FPP.RestrictedTools[v.toolname] = {}
|
|
FPP.RestrictedTools[v.toolname]["admin"] = tonumber(v.adminonly)
|
|
end
|
|
end
|
|
end)
|
|
|
|
MySQLite.query("SELECT * FROM FPP_TOOLRESTRICTPERSON1;", function(perplayerData)
|
|
if not istable(perplayerData) then return end
|
|
for _, v in ipairs(perplayerData) do
|
|
FPP.RestrictedToolsPlayers[v.toolname] = FPP.RestrictedToolsPlayers[v.toolname] or {}
|
|
FPP.RestrictedToolsPlayers[v.toolname][v.steamid] = tobool(v.allow)
|
|
end
|
|
end)
|
|
|
|
MySQLite.query("SELECT * FROM FPP_TOOLTEAMRESTRICT;", function(data)
|
|
if not data then return end
|
|
|
|
for _, v in ipairs(data) do
|
|
FPP.RestrictedTools[v.toolname] = FPP.RestrictedTools[v.toolname] or {}
|
|
FPP.RestrictedTools[v.toolname]["team"] = FPP.RestrictedTools[v.toolname]["team"] or {}
|
|
|
|
table.insert(FPP.RestrictedTools[v.toolname]["team"], tonumber(v.team))
|
|
end
|
|
end)
|
|
end
|
|
|
|
local function RetrieveGroups()
|
|
MySQLite.query("SELECT * FROM FPP_GROUPS3;", function(data)
|
|
if not istable(data) then
|
|
MySQLite.query("REPLACE INTO FPP_GROUPS3 VALUES('default', 1);")
|
|
FPP.Groups["default"] = {}
|
|
FPP.Groups["default"].tools = {}
|
|
FPP.Groups["default"].allowdefault = true
|
|
return
|
|
end -- if there are no groups then there isn't much to load
|
|
|
|
for _, v in ipairs(data) do
|
|
FPP.Groups[v.groupname] = {}
|
|
FPP.Groups[v.groupname].tools = {}
|
|
FPP.Groups[v.groupname].allowdefault = tobool(v.allowdefault)
|
|
end
|
|
|
|
MySQLite.query("SELECT * FROM FPP_GROUPTOOL;", function(grouptooldata)
|
|
if not grouptooldata then return end
|
|
|
|
for _, v in ipairs(grouptooldata) do
|
|
FPP.Groups[v.groupname] = FPP.Groups[v.groupname] or {}
|
|
FPP.Groups[v.groupname].tools = FPP.Groups[v.groupname].tools or {}
|
|
|
|
table.insert(FPP.Groups[v.groupname].tools, v.tool)
|
|
end
|
|
end)
|
|
|
|
MySQLite.query("SELECT * FROM FPP_GROUPMEMBERS1;", function(members)
|
|
if not istable(members) then return end
|
|
for _, v in ipairs(members) do
|
|
FPP.GroupMembers[v.steamid] = v.groupname
|
|
end
|
|
end)
|
|
end)
|
|
end
|
|
|
|
hook.Add("PlayerInitialSpawn", "FPP_SendSettings", SendSettings)
|
|
|
|
local function AddGroup(ply, cmd, args)
|
|
if not args[1] then FPP.Notify(ply, "Invalid argument(s)", false) return end-- Args: 1 = name, optional: 2 = allowdefault
|
|
local name = string.lower(args[1])
|
|
local allowdefault = tonumber(args[2]) or 1
|
|
|
|
if FPP.Groups[name] then
|
|
FPP.Notify(ply, "Group already exists", false)
|
|
return
|
|
end
|
|
|
|
FPP.Groups[name] = {}
|
|
FPP.Groups[name].allowdefault = tobool(allowdefault)
|
|
FPP.Groups[name].tools = {}
|
|
|
|
MySQLite.query("REPLACE INTO FPP_GROUPS3 VALUES(" .. sql.SQLStr(name) .. ", " .. sql.SQLStr(allowdefault) .. ");")
|
|
FPP.Notify(ply, "Group added successfully", true)
|
|
end
|
|
concommand.Add("FPP_AddGroup", runIfAccess("FPP_Settings", AddGroup))
|
|
|
|
hook.Add("InitPostEntity", "FPP_Load_CAMI", function()
|
|
if not CAMI then return end
|
|
for groupName, _ in pairs(CAMI.GetUsergroups()) do
|
|
if FPP.Groups[groupName] then continue end
|
|
|
|
FPP.Groups[groupName] = {}
|
|
FPP.Groups[groupName].allowdefault = true
|
|
FPP.Groups[groupName].tools = {}
|
|
end
|
|
end)
|
|
|
|
local function RemoveGroup(ply, cmd, args)
|
|
if not args[1] then FPP.Notify(ply, "Invalid argument(s)", false) return end-- Args: 1 = name
|
|
local name = string.lower(args[1])
|
|
|
|
if not FPP.Groups[name] then
|
|
FPP.Notify(ply, "Group does not exists", false)
|
|
return
|
|
end
|
|
|
|
if name == "default" then
|
|
FPP.Notify(ply, "Can not remove default group", false)
|
|
return
|
|
end
|
|
|
|
FPP.Groups[name] = nil
|
|
MySQLite.query("DELETE FROM FPP_GROUPS3 WHERE groupname = " .. sql.SQLStr(name) .. ";")
|
|
MySQLite.query("DELETE FROM FPP_GROUPTOOL WHERE groupname = " .. sql.SQLStr(name) .. ";")
|
|
|
|
for k, v in pairs(FPP.GroupMembers) do
|
|
if v == name then
|
|
FPP.GroupMembers[k] = nil -- Set group to standard if group is removed
|
|
end
|
|
end
|
|
FPP.Notify(ply, "Group removed successfully", true)
|
|
end
|
|
concommand.Add("FPP_RemoveGroup", runIfAccess("FPP_Settings", RemoveGroup))
|
|
|
|
local function GroupChangeAllowDefault(ply, cmd, args)
|
|
if not args[2] then FPP.Notify(ply, "Invalid argument(s)", false) return end-- Args: 1 = groupname, 2 = new value 1/0
|
|
|
|
local name = string.lower(args[1])
|
|
local newval = tonumber(args[2])
|
|
|
|
if not FPP.Groups[name] then
|
|
FPP.Notify(ply, "Group does not exists", false)
|
|
return
|
|
end
|
|
|
|
FPP.Groups[name].allowdefault = tobool(newval)
|
|
MySQLite.query("REPLACE INTO FPP_GROUPS3 VALUES(" .. sql.SQLStr(name) .. ", " .. sql.SQLStr(newval) .. ");")
|
|
FPP.Notify(ply, "Group status changed successfully", true)
|
|
end
|
|
concommand.Add("FPP_ChangeGroupStatus", runIfAccess("FPP_Settings", GroupChangeAllowDefault))
|
|
|
|
local function GroupAddTool(ply, cmd, args)
|
|
if not args[2] then FPP.Notify(ply, "Invalid argument(s)", false) return end-- Args: 1 = groupname, 2 = tool
|
|
|
|
local name = args[1]
|
|
local tool = string.lower(args[2])
|
|
|
|
if not FPP.Groups[name] then
|
|
FPP.Notify(ply, "Group does not exists", false)
|
|
return
|
|
end
|
|
|
|
FPP.Groups[name].tools = FPP.Groups[name].tools or {}
|
|
|
|
if table.HasValue(FPP.Groups[name].tools, tool) then
|
|
FPP.Notify(ply, "Tool is already in group!", false)
|
|
return
|
|
end
|
|
|
|
table.insert(FPP.Groups[name].tools, tool)
|
|
|
|
MySQLite.query("REPLACE INTO FPP_GROUPTOOL VALUES(" .. sql.SQLStr(name) .. ", " .. sql.SQLStr(tool) .. ");")
|
|
FPP.Notify(ply, "Tool added successfully", true)
|
|
end
|
|
concommand.Add("FPP_AddGroupTool", runIfAccess("FPP_Settings", GroupAddTool))
|
|
|
|
local function GroupRemoveTool(ply, cmd, args)
|
|
if not args[2] then FPP.Notify(ply, "Invalid argument(s)", false) return end-- Args: 1 = groupname, 2 = tool
|
|
|
|
local name = args[1]
|
|
local tool = string.lower(args[2])
|
|
|
|
if not FPP.Groups[name] then
|
|
FPP.Notify(ply, "Group does not exists", false)
|
|
return
|
|
end
|
|
|
|
if not table.HasValue(FPP.Groups[name].tools, tool) then
|
|
FPP.Notify(ply, "Tool does not exist in group!", false)
|
|
return
|
|
end
|
|
|
|
for k, v in pairs(FPP.Groups[name].tools) do
|
|
if v == tool then
|
|
table.remove(FPP.Groups[name].tools, k)
|
|
end
|
|
end
|
|
|
|
MySQLite.query("DELETE FROM FPP_GROUPTOOL WHERE groupname = " .. sql.SQLStr(name) .. " AND tool = " .. sql.SQLStr(tool) .. ";")
|
|
|
|
FPP.Notify(ply, "Tool removed successfully", true)
|
|
end
|
|
concommand.Add("FPP_RemoveGroupTool", runIfAccess("FPP_Settings", GroupRemoveTool))
|
|
|
|
-- Args: 1 = player, 2 = group
|
|
local function PlayerSetGroup(ply, cmd, args)
|
|
if not args[2] then FPP.Notify(ply, "Group not given", false) return end
|
|
|
|
local name = args[1]
|
|
local group = string.lower(args[2])
|
|
if IsValid(Player(tonumber(name) or 0)) then name = Player(tonumber(name)):SteamID()
|
|
elseif not string.find(name, "STEAM") and name ~= "UNKNOWN" and name ~= "BOT" then FPP.Notify(ply, "Player not found", false) return end
|
|
|
|
if not FPP.Groups[group] and (not CAMI or not CAMI.GetUsergroup(group)) then
|
|
FPP.Notify(ply, "Group does not exists", false)
|
|
return
|
|
end
|
|
|
|
if group ~= "default" then
|
|
MySQLite.query("REPLACE INTO FPP_GROUPMEMBERS1 VALUES(" .. sql.SQLStr(name) .. ", " .. sql.SQLStr(group) .. ");")
|
|
FPP.GroupMembers[name] = group
|
|
else
|
|
FPP.GroupMembers[name] = nil
|
|
MySQLite.query("DELETE FROM FPP_GROUPMEMBERS1 WHERE steamid = " .. sql.SQLStr(name) .. ";")
|
|
end
|
|
|
|
FPP.Notify(ply, "Player group successfully set", true)
|
|
end
|
|
concommand.Add("FPP_SetPlayerGroup", runIfAccess("FPP_Settings", PlayerSetGroup))
|
|
|
|
local function SendGroupData(ply, cmd, args)
|
|
net.Start("FPP_Groups")
|
|
net.WriteTable(FPP.Groups)
|
|
net.Send(ply)
|
|
end
|
|
concommand.Add("FPP_SendGroups", runIfAccess("FPP_Settings", SendGroupData))
|
|
|
|
local function SendGroupMemberData(ply, cmd, args)
|
|
net.Start("FPP_GroupMembers")
|
|
net.WriteTable(FPP.GroupMembers)
|
|
net.Send(ply)
|
|
end
|
|
concommand.Add("FPP_SendGroupMembers", runIfAccess("FPP_Settings", SendGroupMemberData))
|
|
|
|
local function SendBlocked(ply, cmd, args)
|
|
if not args[1] or not FPP.Blocked[args[1]] then return end
|
|
|
|
ply.FPPUmsg1 = ply.FPPUmsg1 or {}
|
|
ply.FPPUmsg1[args[1]] = ply.FPPUmsg1[args[1]] or 0
|
|
if ply.FPPUmsg1[args[1]] > CurTime() - 5 then return end
|
|
ply.FPPUmsg1[args[1]] = CurTime()
|
|
|
|
for k in pairs(FPP.Blocked[args[1]]) do
|
|
umsg.Start("FPP_blockedlist", ply)
|
|
umsg.String(args[1])
|
|
umsg.String(k)
|
|
umsg.End()
|
|
end
|
|
end
|
|
concommand.Add("FPP_sendblocked", SendBlocked)
|
|
|
|
local function SendBlockedModels(ply, cmd, args)
|
|
ply.FPPUmsg2 = ply.FPPUmsg2 or 0
|
|
if ply.FPPUmsg2 > CurTime() - 10 then return end
|
|
ply.FPPUmsg2 = CurTime()
|
|
|
|
local models = {}
|
|
|
|
for k in pairs(FPP.BlockedModels) do table.insert(models, k) end
|
|
|
|
local data = util.Compress(table.concat(models, "\0"))
|
|
|
|
if not data then return end
|
|
|
|
net.Start("FPP_BlockedModels")
|
|
net.WriteData(data, #data)
|
|
net.Send(ply)
|
|
end
|
|
concommand.Add("FPP_sendblockedmodels", SendBlockedModels)
|
|
|
|
local function SendRestrictedTools(ply, cmd, args)
|
|
ply.FPPUmsg3 = ply.FPPUmsg3 or 0
|
|
if ply.FPPUmsg3 > CurTime() - 5 then return end
|
|
ply.FPPUmsg3 = CurTime()
|
|
|
|
if not args[1] then return end
|
|
net.Start("FPP_RestrictedToolList")
|
|
net.WriteString(args[1]) -- tool name
|
|
net.WriteUInt(FPP.RestrictedTools[args[1]] and FPP.RestrictedTools[args[1]].admin or 0, 2) -- user, admin or superadmin
|
|
|
|
local teams = FPP.RestrictedTools[args[1]] and FPP.RestrictedTools[args[1]].team or {}
|
|
net.WriteUInt(#teams, 10)
|
|
for _, t in pairs(teams) do
|
|
net.WriteUInt(t, 10)
|
|
end
|
|
net.Send(ply)
|
|
end
|
|
concommand.Add("FPP_SendRestrictTool", SendRestrictedTools)
|
|
|
|
-- Fallback owner, will own entities after disconnect
|
|
local function setFallbackOwner(ply, fallback)
|
|
ply.FPPFallbackOwner = fallback:SteamID()
|
|
end
|
|
|
|
local function changeFallbackOwner(ply, _, args)
|
|
local fallback = tonumber(args[1]) and Player(tonumber(args[1]))
|
|
|
|
if tonumber(args[1]) == -1 then
|
|
ply.FPPFallbackOwner = nil
|
|
FPP.Notify(ply, "Fallback owner set", true)
|
|
return
|
|
end
|
|
|
|
if not IsValid(fallback) or not fallback:IsPlayer() or fallback == ply then FPP.Notify(ply, "Player invalid", false) return end
|
|
|
|
setFallbackOwner(ply, fallback)
|
|
FPP.Notify(ply, "Fallback owner set", true)
|
|
end
|
|
concommand.Add("FPP_FallbackOwner", changeFallbackOwner)
|
|
|
|
--Buddies!
|
|
local function changeBuddies(ply, buddy, settings)
|
|
if not IsValid(ply) then return end
|
|
|
|
ply.Buddies = ply.Buddies or {}
|
|
ply.Buddies[buddy] = settings
|
|
|
|
local CPPIBuddies = {}
|
|
for k, v in pairs(ply.Buddies) do if table.HasValue(v, true) then table.insert(CPPIBuddies, k) end end
|
|
-- Also run at player spawn because clients send their buddies through this command
|
|
hook.Run("CPPIFriendsChanged", ply, CPPIBuddies)
|
|
|
|
-- Update the prop protection
|
|
local affectedProps = {}
|
|
for _, v in ipairs(ents.GetAll()) do
|
|
local owner = v:CPPIGetOwner()
|
|
if owner ~= ply then continue end
|
|
table.insert(affectedProps, v)
|
|
end
|
|
|
|
FPP.recalculateCanTouch({buddy}, affectedProps)
|
|
FPP.RecalculateConstrainedEntities({buddy}, affectedProps)
|
|
end
|
|
|
|
local function SetBuddy(ply, cmd, args)
|
|
if not args[6] then FPP.Notify(ply, "FPP_SetBuddy: Not enough arguments given!", false) return end
|
|
local buddy = tonumber(args[1]) and Player(tonumber(args[1]))
|
|
if not IsValid(buddy) then FPP.Notify(ply, "Player invalid", false) return end
|
|
|
|
for k, v in pairs(args) do args[k] = tonumber(v) end
|
|
local settings = {Physgun = tobool(args[2]), Gravgun = tobool(args[3]), Toolgun = tobool(args[4]), PlayerUse = tobool(args[5]), EntityDamage = tobool(args[6])}
|
|
|
|
-- Antispam measure
|
|
timer.Create("FPP_BuddiesUpdate" .. ply:UserID() .. ", " .. buddy:UserID(), 1, 1, function() changeBuddies(ply, buddy, settings) end)
|
|
end
|
|
concommand.Add("FPP_SetBuddy", SetBuddy)
|
|
|
|
local function CleanupDisconnected(ply, cmd, args)
|
|
if not args[1] then FPP.Notify(ply, "Invalid argument", false) return end
|
|
|
|
if args[1] == "disconnected" then
|
|
for _, v in ipairs(ents.GetAll()) do
|
|
local owner = v:CPPIGetOwner()
|
|
|
|
if owner and not IsValid(owner) then
|
|
v:Remove()
|
|
end
|
|
end
|
|
|
|
FPP.NotifyAll(((ply.Nick and ply:Nick()) or "Console") .. " removed all disconnected players' props", true)
|
|
|
|
return
|
|
elseif not tonumber(args[1]) or not IsValid(Player(tonumber(args[1]))) then
|
|
FPP.Notify(ply, "Invalid player", false)
|
|
|
|
return
|
|
end
|
|
|
|
local target_ply = Player(args[1])
|
|
|
|
for _, v in ipairs(ents.GetAll()) do
|
|
local owner = v:CPPIGetOwner()
|
|
|
|
if owner == target_ply then
|
|
if v:IsWeapon() and IsValid(v:GetOwner()) then
|
|
continue
|
|
end
|
|
|
|
v:Remove()
|
|
end
|
|
end
|
|
|
|
FPP.NotifyAll(((ply.Nick and ply:Nick()) or "Console") .. " removed " .. target_ply:Nick() .. "'s entities", true)
|
|
end
|
|
concommand.Add("FPP_Cleanup", runIfAccess("FPP_Cleanup", CleanupDisconnected))
|
|
|
|
local function SetToolRestrict(ply, cmd, args)
|
|
if not args[3] then FPP.Notify(ply, "Invalid argument(s)", false) return end--FPP_restricttool <toolname> <type(admin/team)> <toggle(1/0)>
|
|
local toolname = args[1]
|
|
local RestrictWho = tonumber(args[2]) or args[2]-- "team" or "admin"
|
|
local teamtoggle = tonumber(args[4]) --this argument only exists when restricting a tool for a team
|
|
|
|
FPP.RestrictedTools[toolname] = FPP.RestrictedTools[toolname] or {}
|
|
|
|
if RestrictWho == "admin" then
|
|
FPP.RestrictedTools[toolname].admin = args[3] --weapons.Get("gmod_tool").Tool
|
|
|
|
--Save to database!
|
|
MySQLite.query("REPLACE INTO FPP_TOOLADMINONLY VALUES(" .. sql.SQLStr(toolname) .. ", " .. sql.SQLStr(args[3]) .. ");")
|
|
FPP.NotifyAll(((ply.Nick and ply:Nick()) or "Console") .. " changed the admin status of " .. toolname , true)
|
|
elseif RestrictWho == "team" then
|
|
FPP.RestrictedTools[toolname]["team"] = FPP.RestrictedTools[toolname]["team"] or {}
|
|
if teamtoggle == 0 then
|
|
for k, v in pairs(FPP.RestrictedTools[toolname]["team"]) do
|
|
if v == tonumber(args[3]) then
|
|
table.remove(FPP.RestrictedTools[toolname]["team"], k)
|
|
break
|
|
end
|
|
end
|
|
elseif not table.HasValue(FPP.RestrictedTools[toolname]["team"], tonumber(args[3])) and teamtoggle == 1 then
|
|
table.insert(FPP.RestrictedTools[toolname]["team"], tonumber(args[3]))
|
|
end --Remove from the table if it's in there AND it's 0 otherwise do nothing
|
|
|
|
if tobool(teamtoggle) then -- if the team restrict is enabled
|
|
FPP.NotifyAll(((ply.Nick and ply:Nick()) or "Console") .. " restricted " .. toolname .. " to certain teams", true)
|
|
MySQLite.query("REPLACE INTO FPP_TOOLTEAMRESTRICT VALUES(" .. sql.SQLStr(toolname) .. ", " .. tonumber(args[3]) .. ");")
|
|
else -- otherwise if the restriction for the team is being removed
|
|
FPP.NotifyAll(((ply.Nick and ply:Nick()) or "Console") .. " removed teamrestrictions from " .. toolname, true)
|
|
MySQLite.query("DELETE FROM FPP_TOOLTEAMRESTRICT WHERE toolname = " .. sql.SQLStr(toolname) .. " AND team = " .. tonumber(args[3]))
|
|
end
|
|
end
|
|
end
|
|
concommand.Add("FPP_restricttool", runIfAccess("FPP_Settings", SetToolRestrict))
|
|
|
|
local function RestrictToolPerson(ply, cmd, args)
|
|
if not args[3] then FPP.Notify(ply, "Invalid argument(s)", false) return end--FPP_restricttoolperson <toolname> <userid> <disallow, allow, remove(0,1,2)>
|
|
|
|
local toolname = args[1]
|
|
local target = Player(tonumber(args[2]))
|
|
local access = tonumber(args[3])
|
|
if not target:IsValid() then FPP.Notify(ply, "Invalid argument(s)", false) return end
|
|
if access < 0 or access > 2 then FPP.Notify(ply, "Invalid argument(s)", false) return end
|
|
|
|
FPP.RestrictedToolsPlayers[toolname] = FPP.RestrictedToolsPlayers[toolname] or {}
|
|
|
|
-- Disallow, even if other people can use it
|
|
if access == 0 or access == 1 then
|
|
FPP.RestrictedToolsPlayers[toolname][target:SteamID()] = access == 1
|
|
MySQLite.query("REPLACE INTO FPP_TOOLRESTRICTPERSON1 VALUES(" .. sql.SQLStr(toolname) .. ", " .. sql.SQLStr(target:SteamID()) .. ", " .. access .. ");")
|
|
elseif access == 2 then
|
|
-- reset tool status(make him like everyone else)
|
|
FPP.RestrictedToolsPlayers[toolname][target:SteamID()] = nil
|
|
MySQLite.query("DELETE FROM FPP_TOOLRESTRICTPERSON1 WHERE toolname = " .. sql.SQLStr(toolname) .. " AND steamid = " .. sql.SQLStr(target:SteamID()) .. ";")
|
|
end
|
|
FPP.Notify(ply, "Tool restrictions set successfully", true)
|
|
end
|
|
concommand.Add("FPP_restricttoolplayer", runIfAccess("FPP_Settings", RestrictToolPerson))
|
|
|
|
local function resetAllSetting(ply)
|
|
MySQLite.begin()
|
|
MySQLite.queueQuery("DELETE FROM FPP_PHYSGUN1")
|
|
MySQLite.queueQuery("DELETE FROM FPP_GRAVGUN1")
|
|
MySQLite.queueQuery("DELETE FROM FPP_TOOLGUN1")
|
|
MySQLite.queueQuery("DELETE FROM FPP_PLAYERUSE1")
|
|
MySQLite.queueQuery("DELETE FROM FPP_ENTITYDAMAGE1")
|
|
MySQLite.queueQuery("DELETE FROM FPP_GLOBALSETTINGS1")
|
|
MySQLite.queueQuery("DELETE FROM FPP_ANTISPAM1")
|
|
MySQLite.queueQuery("DELETE FROM FPP_BLOCKMODELSETTINGS1")
|
|
MySQLite.commit(function()
|
|
FPP.Settings = nil
|
|
FPP.Settings = table.Copy(FPP.InitialSettings)
|
|
SendSettings(player.GetAll())
|
|
|
|
if not IsValid(ply) then return end
|
|
FPP.Notify(ply, "Settings successfully reset.", true)
|
|
end)
|
|
end
|
|
concommand.Add("FPP_ResetAllSettings", runIfAccess("FPP_Settings", resetAllSetting))
|
|
|
|
local function resetBlockedModels(ply)
|
|
FPP.BlockedModels = {}
|
|
|
|
MySQLite.query("DELETE FROM FPP_BLOCKEDMODELS1", FPP.AddDefaultBlockedModels)
|
|
FPP.Notify(ply, "Settings successfully reset.", true)
|
|
end
|
|
concommand.Add("FPP_ResetBlockedModels", runIfAccess("FPP_Settings", resetBlockedModels))
|
|
|
|
local function refreshPrivatePlayerSettings(ply)
|
|
timer.Remove("FPP_RefreshPrivatePlayerSettings" .. ply:EntIndex())
|
|
|
|
timer.Create("FPP_RefreshPrivatePlayerSettings" .. ply:EntIndex(), 4, 1, function() FPP.recalculateCanTouch({ply}, ents.GetAll()) end)
|
|
end
|
|
concommand.Add("_FPP_RefreshPrivatePlayerSettings", refreshPrivatePlayerSettings)
|
|
|
|
--[[-------------------------------------------------------------------------
|
|
Load all FPP settings
|
|
---------------------------------------------------------------------------]]
|
|
function FPP.Init(callback)
|
|
MySQLite.begin()
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_BLOCKED1(id INTEGER NOT NULL, var VARCHAR(40) NOT NULL, setting VARCHAR(100) NOT NULL, PRIMARY KEY(id));")
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_PHYSGUN1(var VARCHAR(40) NOT NULL, setting INTEGER NOT NULL, PRIMARY KEY(var));")
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_GRAVGUN1(var VARCHAR(40) NOT NULL, setting INTEGER NOT NULL, PRIMARY KEY(var));")
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_TOOLGUN1(var VARCHAR(40) NOT NULL, setting INTEGER NOT NULL, PRIMARY KEY(var));")
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_PLAYERUSE1(var VARCHAR(40) NOT NULL, setting INTEGER NOT NULL, PRIMARY KEY(var));")
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_ENTITYDAMAGE1(var VARCHAR(40) NOT NULL, setting INTEGER NOT NULL, PRIMARY KEY(var));")
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_GLOBALSETTINGS1(var VARCHAR(40) NOT NULL, setting INTEGER NOT NULL, PRIMARY KEY(var));")
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_BLOCKMODELSETTINGS1(var VARCHAR(40) NOT NULL, setting INTEGER NOT NULL, PRIMARY KEY(var));")
|
|
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_ANTISPAM1(var VARCHAR(40) NOT NULL, setting INTEGER NOT NULL, PRIMARY KEY(var));")
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_TOOLADMINONLY(toolname VARCHAR(40) NOT NULL, adminonly INTEGER NOT NULL, PRIMARY KEY(toolname));")
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_TOOLTEAMRESTRICT(toolname VARCHAR(40) NOT NULL, team INTEGER NOT NULL, PRIMARY KEY(toolname, team));")
|
|
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_TOOLRESTRICTPERSON1(toolname VARCHAR(40) NOT NULL, steamid VARCHAR(40) NOT NULL, allow INTEGER NOT NULL, PRIMARY KEY(steamid, toolname));")
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_GROUPS3(groupname VARCHAR(40) NOT NULL, allowdefault INTEGER NOT NULL, PRIMARY KEY(groupname));")
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_GROUPTOOL(groupname VARCHAR(40) NOT NULL, tool VARCHAR(45) NOT NULL, PRIMARY KEY(groupname, tool));")
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_GROUPMEMBERS1(steamid VARCHAR(40) NOT NULL, groupname VARCHAR(40) NOT NULL, PRIMARY KEY(steamid));")
|
|
|
|
MySQLite.queueQuery("CREATE TABLE IF NOT EXISTS FPP_BLOCKEDMODELS1(model VARCHAR(140) NOT NULL PRIMARY KEY);")
|
|
|
|
if MySQLite.isMySQL() then
|
|
MySQLite.queueQuery("ALTER TABLE FPP_BLOCKED1 CHANGE id id INTEGER AUTO_INCREMENT;")
|
|
end
|
|
|
|
MySQLite.commit(function()
|
|
|
|
RetrieveBlocked()
|
|
RetrieveBlockedModels()
|
|
RetrieveRestrictedTools()
|
|
RetrieveGroups()
|
|
RetrieveSettings()
|
|
|
|
-- Callback when FPP is done creating the tables
|
|
if callback then callback() end
|
|
end)
|
|
end
|
|
|
|
local assbackup = ASS_RegisterPlugin -- Suddenly after witing this code, ASS spamprotection and propprotection broke. I have no clue why. I guess you should use FPP then
|
|
if assbackup then
|
|
function ASS_RegisterPlugin(plugin, ...)
|
|
if plugin.Name == "Sandbox Spam Protection" or plugin.Name == "Sandbox Prop Protection" then
|
|
return
|
|
end
|
|
return assbackup(plugin, ...)
|
|
end
|
|
end
|