aperx/factorio-scenario-ExpCluster
1
0
Fork 0
mirror of https://github.com/PHIDIAS0303/ExpCluster.git synced 2025-12-27 19:45:22 +09:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'release/5.1.0'

Browse Source
This commit is contained in:
Cooldude2606
2019-03-15 15:40:15 +00:00
parent d64bf50381 2982fc993e
commit c735dd8cd4
13 changed files with 516 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
modules/commands/admin-only-auth.lua → config/command_auth_admin.lua
View File

0
expcore/common_parse.lua → config/command_parse_general.lua
View File

135
config/permission_groups.lua Normal file
View File

@@ -0,0 +1,135 @@
local Event = require 'utils.event'
local Game = require 'utils.game'
local Permission_Groups = require 'expcore.permission_groups'
Permission_Groups.new_group('Admin')
:allow_all()
:disallow{
'add_permission_group', -- admin
'delete_permission_group',
--'edit_permission_group', -- removed for admin till role script added
'import_permissions_string',
'map_editor_action',
'toggle_map_editor',
'change_multiplayer_config',
'set_heat_interface_mode',
'set_heat_interface_temperature',
'set_infinity_container_filter_item',
'set_infinity_container_remove_unfiltered_items',
'set_infinity_pipe_filter'
}
Permission_Groups.new_group('Trusted')
:allow_all()
:disallow{
'add_permission_group', -- admin
'delete_permission_group',
'edit_permission_group',
'import_permissions_string',
'map_editor_action',
'toggle_map_editor',
'change_multiplayer_config',
'set_heat_interface_mode',
'set_heat_interface_temperature',
'set_infinity_container_filter_item',
'set_infinity_container_remove_unfiltered_items',
'set_infinity_pipe_filter',
'admin_action' -- trusted
}
Permission_Groups.new_group('Standard')
:allow_all()
:disallow{
'add_permission_group', -- admin
'delete_permission_group',
'edit_permission_group',
'import_permissions_string',
'map_editor_action',
'toggle_map_editor',
'change_multiplayer_config',
'set_heat_interface_mode',
'set_heat_interface_temperature',
'set_infinity_container_filter_item',
'set_infinity_container_remove_unfiltered_items',
'set_infinity_pipe_filter',
'admin_action', -- trusted
'change_programmable_speaker_alert_parameters', -- standard
'drop_item',
'reset_assembling_machine',
'set_auto_launch_rocket',
'cancel_research'
}
Permission_Groups.new_group('Guest')
:allow_all()
:disallow{
'add_permission_group', -- admin
'delete_permission_group',
'edit_permission_group',
'import_permissions_string',
'map_editor_action',
'toggle_map_editor',
'change_multiplayer_config',
'set_heat_interface_mode',
'set_heat_interface_temperature',
'set_infinity_container_filter_item',
'set_infinity_container_remove_unfiltered_items',
'set_infinity_pipe_filter',
'admin_action', -- trusted
'change_programmable_speaker_alert_parameters', -- standard
'drop_item',
'reset_assembling_machine',
'set_auto_launch_rocket',
'cancel_research',
'change_programmable_speaker_parameters', -- guest
'change_train_stop_station',
'deconstruct',
'remove_cables',
'remove_train_station',
'reset_assembling_machine',
'rotate_entity',
'use_artillery_remote',
'launch_rocket'
}
Permission_Groups.new_group('Restricted')
:disallow_all()
:allow('write_to_console')
--- These events are used until a role system is added to make it easier for our admins
local trusted_time = 60*60*60*10 -- 10 hour
local standard_time = 60*60*60*3 -- 3 hour
local function assign_group(player)
if player.admin then
Permission_Groups.set_player_group(player,'Admin')
elseif player.online_time > trusted_time then
Permission_Groups.set_player_group(player,'Trusted')
elseif player.online_time > standard_time then
Permission_Groups.set_player_group(player,'Standard')
else
Permission_Groups.set_player_group(player,'Guest')
end
end
Event.add(defines.events.on_player_joined_game,function(event)
local player = Game.get_player_by_index(event.player_index)
assign_group(player)
end)
Event.add(defines.events.on_player_promoted,function(event)
local player = Game.get_player_by_index(event.player_index)
assign_group(player)
end)
Event.add(defines.events.on_player_demoted,function(event)
local player = Game.get_player_by_index(event.player_index)
assign_group(player)
end)
local check_interval = 60*60*15 -- 15 minutes
Event.on_nth_tick(check_interval,function(event)
for _,player in pairs(game.connected_players) do
assign_group(player)
end
end)

1
control.lua
View File

@@ -24,6 +24,7 @@ local files = {
'modules.commands.cheat-mode',
'modules.commands.interface',
'modules.commands.help',
'config.permission_groups'
}
-- Loads all files in array above and logs progress

87
expcore/common.lua
View File

@@ -1,11 +1,28 @@
--- Adds some commonly used functions used in many modules
-- @author cooldude2606
-- @module Public
--[[
>>>>Functions List (see function for more detail):
Public.type_check(value,test_type) --- Compare types faster for faster validation of prams
Public.type_check_error(value,test_type,error_message,level) --- Raises an error if the value is of the incorrect type
Public.param_check(value,test_type,param_name,param_number) --- Raises an error when the value is the incorrect type, uses a consistent error message format
Public.extract_keys(tbl,...) --- Extracts certain keys from a table
Public.player_return(value,colour,player) --- Will return a value of any type to the player/server console, allows colour for in-game players
Public.opt_require(path) --- Calls a require that will not error if the file is not found
Public.ext_require(path,...) --- Calls a require and returns only the keys given, file must return a table
]]
local Colours = require 'resources.color_presets'
local Game = require 'utils.game'
local Public = {}
--- Compare types faster for faster validation of prams
-- @usage is_type('foo','string') -- return true
-- @usage is_type('foo') -- return false
--- Compare types faster for faster validation of params
-- @usage type_check('foo','string') -- return true
-- @usage type_check('foo') -- return false
-- @param v the value to be tested
-- @tparam[opt=nil] string test_type the type to test for if not given then it tests for nil
-- @treturn boolean is v of type test_type
@@ -13,6 +30,47 @@ function Public.type_check(value,test_type)
return test_type and value and type(value) == test_type or not test_type and not value or false
end
--- Raises an error if the value is of the wrong type
-- @usage type_check_error('foo','number','Value must be a number') -- will raise error "Value must be a number"
-- @tparam value any the value that you want to test the type of
-- @tparam test_type string the type that the value should be
-- @tparam error_message string the error message that is returned
-- @tparam level number the level to call the error on (level = 1 means the caller)
-- @treturn boolean true if no error was called
function Public.type_check_error(value,test_type,error_message,level)
level = level and level+1 or 2
return Public.test_type(value,test_type) or error(error_message,level)
end
--- Raises an error when the value is the incorrect type, uses a consistent error message format
-- @usage param_check('foo','number','repeat_count',2) -- will raise error "Invalid param #02 given to <anon>; repeat_count is not of type number"
-- @tparam value any the value that you want to test the type of
-- @tparam test_type string the type that the value should be
-- @tparam param_name string the name of the param
-- @tparam param_number number the number param it is
-- @treturn boolean true if no error was raised
function Public.param_check(value,test_type,param_name,param_number)
if not Public.test_type(value,test_type) then
local function_name = debug.getinfo(2,'n').name or '<anon>'
local error_message = string.format('Invalid param #%2d given to %s; %s is not of type %s',param_number,function_name,param_name,test_type)
return error(error_message,3)
end
return true
end
--- Extracts certain keys from a table
-- @usage local key_three, key_one = extract({key_one='foo',key_two='bar',key_three=true},'key_three','key_one')
-- @tparam tbl table the table which contains the keys
-- @tparam ... string the names of the keys you want extracted
-- @return the keys in the order given
function Public.extract_keys(tbl,...)
local values = {}
for _,key in pairs({...}) do
table.insert(values,tbl[key])
end
return unpack(values)
end
--- Will return a value of any type to the player/server console, allows colour for in-game players
-- @usage player_return('Hello, World!') -- returns 'Hello, World!' to game.player or server console
-- @usage player_return('Hello, World!','green') -- returns 'Hello, World!' to game.player with colour green or server console
@@ -54,4 +112,27 @@ function Public.player_return(value,colour,player)
else rcon.print(returnAsString) end
end
--- Calls a require that will not error if the file is not found
-- @usage local file = opt_require('file.not.present') -- will not cause any error
-- @tparam path string the path that you want to require
-- @return the returns from that file or nil, error if not loaded
function Public.opt_require(path)
local success, rtn = pcall(require,path)
if success then return rtn
else return nil,rtn end
end
--- Calls a require and returns only the keys given, file must return a table
-- @useage local extract, param_check = ext_require('expcore.common','extract','param_check')
-- @tparam path string the path that you want to require
-- @tparam ... string the name of the keys that you want returned
-- @return the keys in the order given
function Public.ext_require(path,...)
local rtn = require(path)
if type(rtn) ~= 'table' then
error('File did not return a table, can not extract keys.',2)
end
return Public.extract_keys(rtn,...)
end
return Public

283
expcore/permission_groups.lua Normal file
View File

@@ -0,0 +1,283 @@
--- Permission group making for factorio so you never have to make one by hand again
-- @author Cooldude2606
-- @module Permissions_Groups
--[[
>>>>Example Group (Allow All)
-- here we will create an admin group however we do not want them to use the map editor or mess with the permission groups
Permission_Groups.new_group('Admin') -- this defines a new group called "Admin"
:allow_all() -- this makes the default to allow any input action unless set other wise
:disallow{ -- here we disallow the input action we dont want them to use
'add_permission_group',
'delete_permission_group',
'import_permissions_string',
'map_editor_action',
'toggle_map_editor'
}
>>>>Example Group (Disallow All)
-- here we will create a group that cant do anything but talk in chat
Permission_Groups.new_group('Restricted') -- this defines a new group called "Restricted"
:disallow_all() -- this makes the default to disallow any input action unless set other wise
:allow('write_to_console') -- here we allow them to chat, {} can be used here if we had more than one action
>>>>Functions List (see function for more detail):
Permissions_Groups.new_group(name) --- Defines a new permission group that can have it actions set in the config
Permissions_Groups.get_group_by_name(name) --- Returns the group with the given name, case sensitive
Permissions_Groups.get_group_from_player(player) --- Returns the group that a player is in
Permissions_Groups.reload_permissions() --- Reloads/creates all permission groups and sets them to they configured state
Permissions_Groups.lockdown_permissions(exempt) --- Removes all permissions from every permission group except for "Default" and any passed as exempt
Permissions_Groups.set_player_group(player,group) --- Sets a player's group to the one given, a player can only have one group at a time
Permissions_Groups._prototype:set_action(action,state) --- Sets the allow state of an action for this group, used internally but is safe to use else where
Permissions_Groups._prototype:allow(actions) --- Sets an action or actions to be allowed for this group even with disallow_all triggered, Do not use in runtime
Permissions_Groups._prototype:disallow(actions) --- Sets an action or actions to be disallowed for this group even with allow_all triggered, Do not use in runtime
Permissions_Groups._prototype:allow_all() --- Sets the default state for any actions not given to be allowed, useful with :disallow
Permissions_Groups._prototype:disallow_all() --- Sets the default state for any action not given to be disallowed, useful with :allow
Permissions_Groups._prototype:is_allowed(action) --- Returns if an input action is allowed for this group
Permissions_Groups._prototype:get_raw() --- Returns the LuaPermissionGroup that was created with this group object, used internally
Permissions_Groups._prototype:create() --- Creates or updates the permission group with the configured actions, used internally
Permissions_Groups._prototype:add_player(player) --- Adds a player to this group
Permissions_Groups._prototype:remove_player(player) --- Removes a player from this group
Permissions_Groups._prototype:get_players(online) --- Returns all player that are in this group with the option to filter to online/offline only
Permissions_Groups._prototype:print(message) --- Prints a message to every player in this group
]]
local Game = require 'utils.game'
local Event = require 'utils.event'
local Permissions_Groups = {
groups={}, -- store for the different groups that are created
_prototype={} -- stores functions that are used on group instances
}
--- Defines a new permission group that can have it actions set in the config
-- @tparam name string the name of the new group
-- @treturn Permissions_Groups._prototype the new group made with function to allow and disallow actions
function Permissions_Groups.new_group(name)
local group = setmetatable({
name=name,
actions={},
allow_all_actions=true
},{
__index= Permissions_Groups._prototype
})
Permissions_Groups.groups[name] = group
return group
end
--- Returns the group with the given name, case sensitive
-- @tparam name string the name of the group to get
-- @treturn ?Permissions_Groups._prototype|nil the group with that name or nil if non found
function Permissions_Groups.get_group_by_name(name)
return Permissions_Groups.groups[name]
end
--- Returns the group that a player is in
-- @tparam LuaPlayer the player to get the group of can be LuaPlayer name index etc
-- @treturn ?Permissions_Groups._prototype|nil the group with that player or nil if non found
function Permissions_Groups.get_group_from_player(player)
player = Game.get_player_from_any(player)
if not player then return end
local group = player.permission_group
if group then
return Permissions_Groups.groups[group.name]
end
end
--- Reloads/creates all permission groups and sets them to they configured state
function Permissions_Groups.reload_permissions()
for _,group in pairs(Permissions_Groups.groups) do
group:create()
end
end
--- Removes all permissions from every permission group except for "Default" and any passed as exempt
-- @tparam string|Array<string> any groups that you want to be except, "Default" is always exempt
-- @treturn number the number of groups that had they permissions removed
function Permissions_Groups.lockdown_permissions(exempt)
local count = 0
if type(exempt) ~= 'table' then
exempt = {exempt}
end
for _,group in pairs(exempt) do
if type(group) == 'string' then
exempt[group:lower()] = true
elseif type(group) == 'table' then
exempt[group.name:lower()] = true
end
end
for _,group in pairs(game.permissions.groups) do
if not exempt[group.name:lower()] and not group.name == 'Default' then
count = count +1
for _,action in pairs(defines.input_action) do
group.set_allows_action(action,false)
end
end
end
return count
end
--- Sets a player's group to the one given, a player can only have one group at a time
-- @tparam LuaPlayer the player to effect can be LuaPlayer name index etc
-- @tparam string the name of the group to give to the player
-- @treturn boolean true if the player was added successfully, false other wise
function Permissions_Groups.set_player_group(player,group)
player = Game.get_player_from_any(player)
local group = Permissions_Groups.get_group_by_name(group)
if not group or not player then return false end
group:add_player(player)
return true
end
--- Sets the allow state of an action for this group, used internally but is safe to use else where
-- @tparam action ?string|defines.input_action the action that you want to set the state of
-- @tparam state boolean the state that you want to set it to, true = allow, false = disallow
-- @treturn Permissions_Groups._prototype returns self so function can be chained
function Permissions_Groups._prototype:set_action(action,state)
if type(action) == 'string' then
action = defines.input_action[action]
end
self.actions[action] = state
return self
end
--- Sets an action or actions to be allowed for this group even with disallow_all triggered, Do not use in runtime
-- @tparam string|Array<string> the action or actions that you want to allow for this group
-- @treturn Permissions_Groups._prototype returns self so function can be chained
function Permissions_Groups._prototype:allow(actions)
if type(actions) ~= 'table' then
actions = {actions}
end
for _,action in pairs(actions) do
self:set_action(action,true)
end
return self
end
--- Sets an action or actions to be disallowed for this group even with allow_all triggered, Do not use in runtime
-- @tparam string|Array<string> the action or actions that you want to disallow for this group
-- @treturn Permissions_Groups._prototype returns self so function can be chained
function Permissions_Groups._prototype:disallow(actions)
if type(actions) ~= 'table' then
actions = {actions}
end
for _,action in pairs(actions) do
self:set_action(action,false)
end
return self
end
--- Sets the default state for any actions not given to be allowed, useful with :disallow
-- @treturn Permissions_Groups._prototype returns self so function can be chained
function Permissions_Groups._prototype:allow_all()
self.allow_all_actions = true
return self
end
--- Sets the default state for any action not given to be disallowed, useful with :allow
-- @treturn Permissions_Groups._prototype returns self so function can be chained
function Permissions_Groups._prototype:disallow_all()
self.allow_all_actions = false
return self
end
--- Returns if an input action is allowed for this group
-- @tparam action ?string|defines.input_action the action that you want to test for
-- @treturn boolean true if the group is allowed the action, false other wise
function Permissions_Groups._prototype:is_allowed(action)
if type(action) == 'string' then
action = defines.input_action[action]
end
local state = self.actions[action]
if state == nil then
state = self.allow_all_actions
end
return state
end
--- Returns the LuaPermissionGroup that was created with this group object, used internally
-- @treturn LuaPermissionGroup the raw lua permission group
function Permissions_Groups._prototype:get_raw()
return game.permissions.get_group(self.name)
end
--- Creates or updates the permission group with the configured actions, used internally
-- @treturn LuaPermissionGroup the permission group that was created
function Permissions_Groups._prototype:create()
local group = self:get_raw()
if not group then
group = game.permissions.create_group(self.name)
end
for _,action in pairs(defines.input_action) do
group.set_allows_action(action,self:is_allowed(action))
end
return group
end
--- Adds a player to this group
-- @tparam player LuaPlayer the player you want to add to this group can be LuaPlayer name or index etc
-- @treturn boolean true if the player was added successfully, false other wise
function Permissions_Groups._prototype:add_player(player)
player = Game.get_player_from_any(player)
local group = self:get_raw()
if not group or not player then return false end
group.add_player(player)
return true
end
--- Removes a player from this group
-- @tparam player LuaPlayer the player you want to remove from this group can be LuaPlayer name or index etc
-- @treturn boolean true if the player was removed successfully, false other wise
function Permissions_Groups._prototype:remove_player(player)
player = Game.get_player_from_any(player)
local group = self:get_raw()
if not group or not player then return false end
group.remove_player(player)
return true
end
--- Returns all player that are in this group with the option to filter to online/offline only
-- @tparam[opt] online boolean if nil returns all players, if true online players only, if false returns online players only
-- @treturn table a table of players that are in this group; filtered if online param is given
function Permissions_Groups._prototype:get_players(online)
local players = {}
local group = self:get_raw()
if group then
if online == nil then
return group.players
else
for _,player in pairs(group.players) do
if player.connected == online then
table.insert(player,player)
end
end
end
end
return players
end
--- Prints a message to every player in this group
-- @tparam message string the message that you want to send to the players
-- @treturn number the number of players that received the message
function Permissions_Groups._prototype:print(message)
local players = self:get_players(true)
for _,player in pairs(players) do
player.print(message)
end
return #players
end
-- when the game starts it will make the permission groups
Event.on_init(function()
Permissions_Groups.reload_permissions()
end)
return Permissions_Groups

4
modules/commands/admin-chat.lua
View File

@@ -1,6 +1,6 @@
local Commands = require 'expcore.commands'
require 'expcore.common_parse'
require 'modules.commands.admin-only-auth'
require 'config.command_parse_general'
require 'config.command_auth_admin'
Commands.new_command('admin-chat','Sends a message in chat that only admins can see.')
:add_param('message',false) -- the message to send in the admin chat

4
modules/commands/cheat-mode.lua
View File

@@ -1,6 +1,6 @@
local Commands = require 'expcore.commands'
require 'expcore.common_parse'
require 'modules.commands.admin-only-auth'
require 'config.command_parse_general'
require 'config.command_auth_admin'
Commands.new_command('toggle-cheat-mode','Toggles cheat mode for your player, or another player.')
:add_param('player',true,'player') -- player to toggle chest mode of, can be nil for self

2
modules/commands/help.lua
View File

@@ -1,6 +1,6 @@
local Commands = require 'expcore.commands'
local Global = require 'utils.global'
require 'expcore.common_parse'
require 'config.command_parse_general'
local results_per_page = 5

5
modules/commands/interface.lua
View File

@@ -1,13 +1,14 @@
local Commands = require 'expcore.commands'
local Global = require 'utils.global'
local Common = require 'expcore.common'
require 'modules.commands.admin-only-auth'
require 'config.command_auth_admin'
-- modules that are loaded into the interface env to be accessed
local interface_modules = {
['Game']='utils.game',
['Commands']=Commands,
['output']=Common.player_return
['output']=Common.player_return,
['Group']='expcore.permission_groups'
}
-- loads all the modules given in the above table

4
modules/commands/kill.lua
View File

@@ -1,6 +1,6 @@
local Commands = require 'expcore.commands'
require 'expcore.common_parse'
require 'modules.commands.admin-only-auth'
require 'config.command_parse_general'
require 'config.command_auth_admin'
Commands.new_command('kill','Kills yourself or another player.')
:add_param('player',true,'player-alive') -- the player to kill, must be alive to be valid

2
modules/commands/tag.lua
View File

@@ -1,5 +1,5 @@
local Commands = require 'expcore.commands'
require 'expcore.common_parse'
require 'config.command_parse_general'
Commands.new_command('tag','Sets your player tag.')
:add_param('tag',false,'string-max-length',20) -- new tag for your player max 20 char

4
modules/commands/teleport.lua
View File

@@ -1,6 +1,6 @@
local Commands = require 'expcore.commands'
require 'expcore.common_parse'
require 'modules.commands.admin-only-auth'
require 'config.command_parse_general'
require 'config.command_auth_admin'
local function teleport(from_player,to_player)
local surface = to_player.surface