diff --git a/config/file_loader.lua b/config/file_loader.lua index 790aa6c6..72016f49 100644 --- a/config/file_loader.lua +++ b/config/file_loader.lua @@ -38,4 +38,5 @@ return { 'config.command_auth_runtime_disable', -- allows commands to be enabled and disabled during runtime 'config.permission_groups', -- loads some predefined permission groups 'config.roles', -- loads some predefined roles + 'expcore.store_test' } \ No newline at end of file diff --git a/control.lua b/control.lua index 02ff8cec..ec8f0068 100644 --- a/control.lua +++ b/control.lua @@ -30,7 +30,7 @@ local errors = {} for index,path in pairs(files) do -- Loads the next file in the list - log(string.format('[INFO] Loading files %3d/%s',index,total_file_count)) + log(string.format('[INFO] Loading files %3d/%s (%s)',index,total_file_count,path)) local success,file = pcall(require,path) -- Error Checking diff --git a/expcore/commands.lua b/expcore/commands.lua index c96dcce4..c7698802 100644 --- a/expcore/commands.lua +++ b/expcore/commands.lua @@ -218,7 +218,7 @@ ]] local Game = require 'utils.game' -local player_return = ext_require('expcore.common','player_return') +local player_return,write_json = ext_require('expcore.common','player_return','write_json') local Commands = { defines={ -- common values are stored error like signals @@ -580,14 +580,14 @@ end -- logs command usage to file local function command_log(player,command,comment,params,raw,details) local player_name = player and player.name or '' - game.write_file('log/commands.log',game.table_to_json{ + write_json('log/commands.log',{ player_name=player_name, command_name=command.name, comment=comment, details=details, params=params, raw=raw - }..'\n',true,0) + }) end --- Main event function that is ran for all commands, used internally please avoid direct use diff --git a/expcore/common.lua b/expcore/common.lua index 481fc4b1..8e8c6e72 100644 --- a/expcore/common.lua +++ b/expcore/common.lua @@ -7,12 +7,34 @@ 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.write_json(path,tbl) --- Writes a table object to a file in json format 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 + + Public.format_time(ticks,options) --- Formats tick into a clean format, denominations from highest to lowest + + Public.move_items(items,surface,position,radius,chest_type) --- Moves items to the position and stores them in the closest entity of the type given + + Public.print_grid_value(value, surface, position, scale, offset, immutable) --- Prints a colored value on a location. + Public.print_colored_grid_value(value, surface, position, offset, immutable, + color_value, base_color, delta_color, under_bound, over_bound) --- Prints a colored value on a location. with extra settings. + Public.clear_flying_text(surface) --- Clears all flying text entites on a surface + + Public.string_contains(s, contains) --- Tests if a string contains a given substring. + + Public.extract_keys(tbl,...) --- Extracts certain keys from a table + Public.enum(tbl) --- Converts a table to an enum + Public.auto_complete(options,input,use_key,rtn_key) --- Returns the closest match to the input + Public.table_keys(tbl) --- Returns all the keys of a table + Public.table_values(tbl) --- Returns all the values of a table + Public.table_alphanumsort(tbl) --- Returns the list is a sorted way that would be expected by people (this is by key) + Public.table_keysort(tbl) --- Returns the list is a sorted way that would be expected by people (this is by key) (faster alterative than above) + + Public.format_chat_colour(message,color) --- Returns a message with valid chat tags to change its colour + Public.format_chat_colour_localized(message,color) --- Returns a message with valid chat tags to change its colour, using localization + Public.format_chat_player_name(player,raw_string) --- Returns the players name in the players color ]] local Colours = require 'resources.color_presets' @@ -61,19 +83,6 @@ function Public.param_check(value,test_type,param_name,param_number) 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 @@ -86,8 +95,8 @@ function Public.player_return(value,colour,player) player = player or game.player -- converts the value to a string local returnAsString - if Public.type_check(value,'table') then - if Public.type_check(value.__self,'userdata') then + if Public.type_check(value,'table') or type(value) == 'userdata' then + if Public.type_check(value.__self,'userdata') or type(value) == 'userdata' then -- value is userdata returnAsString = 'Cant Display Userdata' elseif Public.type_check(value[1],'string') and string.find(value[1],'.+[.].+') and not string.find(value[1],'%s') then @@ -115,6 +124,13 @@ function Public.player_return(value,colour,player) else rcon.print(returnAsString) end end +--- Writes a table object to a file in json format +-- @tparam path string the path of the file to write include / to use dir +-- @tpatam tbl table the table that will be converted to a json string and wrote to file +function Public.write_json(path,tbl) + game.write_file(path,game.table_to_json(tbl)..'\n',true,0) +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 @@ -413,6 +429,8 @@ function Public.print_colored_grid_value(value, surface, position, offset, immut }.active = false end +--- Clears all flying text entites on a surface +-- @tparam surface LuaSurface the surface to clear function Public.clear_flying_text(surface) local entities = surface.find_entities_filtered{name ='flying-text'} for _,entity in pairs(entities) do @@ -430,7 +448,41 @@ function Public.string_contains(s, contains) return s and string.find(s, contains) ~= nil end ---- Returns the closest match to a key +--- 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 + +--- Converts a table to an enum +-- @tparam tbl table the table that will be converted +-- @treturn table the new table that acts like an enum +function Public.enum(tbl) + local rtn = {} + for k,v in pairs(tbl) do + if type(k) ~= 'number' then + rtn[v]=k + end + end + for k,v in pairs(tbl) do + if type(k) == 'number' then + table.insert(rtn,v) + end + end + for k,v in pairs(rtn) do + rtn[v]=k + end + return rtn +end + +--- Returns the closest match to the input -- @tparam options table a table of options for the auto complete -- @tparam input string the input string that will be completed -- @tparam[opt=false] use_key boolean when true the keys of options will be used as the options diff --git a/expcore/roles.lua b/expcore/roles.lua index 11df21dc..a2dca09e 100644 --- a/expcore/roles.lua +++ b/expcore/roles.lua @@ -160,6 +160,7 @@ local Global = require 'utils.global' local Event = require 'utils.event' local Groups = require 'expcore.permission_groups' local Colours = require 'resources.color_presets' +local write_json = ext_require('expcore.common','write_json') local Roles = { config={ @@ -223,12 +224,12 @@ local function emit_player_roles_updated(player,type,roles,by_player_name,skip_g by_player_index=by_player_index, roles=roles }) - game.write_file('log/roles.log',game.table_to_json{ + write_json('log/roles.log',{ player_name=player.name, by_player_name=by_player_name, type=type, roles_changed=role_names - }..'\n',true,0) + }) end --- Returns a string which contains all roles in index order displaying all data for them diff --git a/expcore/store.lua b/expcore/store.lua new file mode 100644 index 00000000..e03036f9 --- /dev/null +++ b/expcore/store.lua @@ -0,0 +1,257 @@ +--- This module is for storing and watching values for updates, useful for config settings or limiting what can be changed +--[[ +>>>> When to use this system + This system is to be used when you want to store a value and watch when it is changed or watch any value for changes. + Examples would include runtime config settings where something needs to change when the value is updated or when you have + values entered in a gui and you want them to be persistent between players like a force modifer gui + +>>>> What store type to use + There are different types of store that can be used each is designed to be used in a certain situation: + local - this store type doesnt actually store any data and it has its use in only triggering the setter function when you use + the set function rather than watching for updates, this might be used as an interface between modules where when you change the + local varible you dont want it to trigger but when an outside source uses set it will trigger the setter. + player - this will use the sub_location as a player so each player will have they own entry in the store location, this can be used + with player modifiers where even if set is not used the update will still be detected. + force - this will use the sub_location as a force so each force will have its own entry in the store location, this can be used to store + custom settings for a force where if a player uses a gui to edit the setting it will detect the update and call the setter where you + can update the value on the gui for other players. + surface - this will use the sub_location as a surface so each surface will have its own entry in the store location, this will have the + same use case as force but for a surface rather than a force. + game - this will store all a single value so any sub_location string can be used, this is the general case so you really can store what + ever values you want to in this and watch for external updates, this would be used when its not a local varible for example if you are + watching the number of online players. + global - this will store all of its data in an external source indepentent of the lua code, this means that you can store data between + maps and even instances, when the value is updated it will trigger an emit where some external code should send a message to the other + connected instances to update they value. lcoal set -> emit update -> local setter -> remote set -> remote setter + +>>>> Force mining speed example: + For this will print a message when the force mining speed has been updated, we will use the force type since each force will have its own + mining speed and our getter will just return the current minning speed of the force. + + Store.register('force.mining_speed','force',function(force) + return force.manual_mining_speed_modifier + end,function(force,value) + force.manual_mining_speed_modifier = value + game.print(force.name..' how has '..value..' mining speed') + end) + + Note that because we used type force the getter and setter are passed the force which the current check/update effects; if we used player or surface + the same would be true. However for local, game and global they are passed the sub_location string which allows you to store multiple things in the same + location; however one limitation is that a sub_location is required even if you only plan to store one value. + + Store.set('force.mining_speed','player',2) + game.forces.player.manual_mining_speed_modifier = 2 + + The two cases above will have the effect of both setting the minning speed and outputing the update message. This can be quite useful when you start to + indroduce custom settings or do more than just output that the value was updated. + + Store.get('force.mining_speed','player') + + In a similar way get can be used to get the current value that is stored, if no value is stored then the getter function is called to get the value, this + function is more useful when you have custom settings since they would be no other way to access them. + +>>>> Optimise the watching + When you use player,force or surface you will be checking alot of values for updates for this reason you might want to limit which sub_locations are checked + for updates because by default every player/force/surface is checked. You might also want to do this if you want a sub_location that is nil but still want to + check for it being updated (because by deafult it only checks non nil sub_locations). To do both these things you will use Store.watch + + Store.watch('force.mining_speed','player') + For our force example we dont care about the enemy or neutral force only the player force, so we tell it to watch player and these means that the values for + the other forces are not be watched for updates (although Store.get and Store.set will still work). Store.watch will also accept a table of sub_locations in + case you want more than one thing to be watch. + +>>>> Functions: + Store.register(location,store_type,getter,setter,no_error) --- Register a new location to store a value, the valu returned from getter will be watched for updates + Store.set(location,sub_location,value) --- Sets the stored values at the location, will call the setter function + Store.get(location,sub_location) --- Gets the value at the location, if the value is nil then the getter function is called + Store.watch(location,sub_location,state) --- If used then only sub_locations marked to be watched will be watched for updates, this will also midigate the nil value problem + Store.check(location,sub_location) --- Checks if the store value needs updating, and if true will update it calling the setter function +]] + + +local Global = require 'utils.global' +local Event = require 'utils.event' +local Game = require 'utils.game' +local Enum,write_json,table_keys = ext_require('expcore.common','enum','write_json','table_keys') + +local Store = { + data={}, + watching={}, + locations={}, + types = Enum{ + 'local', -- data is not stored with any sub_location, updates caused only by set + 'player', -- data is stroed per player, updates caused by watch and set + 'force', -- data is stroed per force, updates caused by watch and set + 'surface', -- data is stroed per surface, updates caused by watch and set + 'game', -- data is stored with any sub_location, updates caused by watch and set + 'global' -- data is stored externaly with any sub_location, updates casued by watch, set and the external source + } +} +Global.register({Store.data,Store.watching},function(tbl) + Store.data = tbl[1] + Store.watching = tbl[2] +end) + +--- Returns a factorio object for the sub_location +local function get_sub_location_object(store_type,sub_location) + if store_type == Store.types.player then + sub_location = Game.get_player_from_any(sub_location) + if not sub_location then return error('Invalid player for sub_location',3) end + return sub_location + elseif store_type == Store.types.force then + sub_location = type(sub_location) == 'table' and type(sub_location.__self) == 'userdata' and sub_location or game.forces[sub_location] + if not sub_location then return error('Invalid force for sub_location',3) end + return sub_location + elseif store_type == Store.types.surface then + sub_location = type(sub_location) == 'table' and type(sub_location.__self) == 'userdata' and sub_location or game.surfaces[sub_location] + if not sub_location then return error('Invalid surface for sub_location',3) end + return sub_location + end +end + +--- Returns three common parts that are used +local function get_location_parts(location,sub_location) + location = Store.locations[location] + local sub_location_object = get_sub_location_object(location.store_type,sub_location) + sub_location = sub_location_object and sub_location_object.name or sub_location + return location, sub_location, sub_location_object +end + +--- Emits an event to the external store that a value was updated +local function set_global_location_value(location,sub_location,value) + write_json('log/store.log',{ + location=location, + sub_location=sub_location, + value=value + }) +end + +--- Register a new location to store a value, the valu returned from getter will be watched for updates +-- @tparam location string the location path for the data must be unqiue +-- @tparam store_type string the type of store this is, see Store.types +-- @tparam getter function will be called to get the value for the store, the value is watched for updates +-- @tparam setter function when the store value changes the setter will be called +-- @tparam[opt=false] no_error boolean when true will skip check for location already registered +function Store.register(location,store_type,getter,setter,no_error) + if not no_error and Store.locations[location] then + return error('The location is already registed: '..location,2) + end + store_type = type(store_type) == 'string' and Store.types[store_type] or store_type + Store.locations[location] = { + location=location, + store_type=store_type, + getter=getter, + setter=setter + } +end + +--- Sets the stored values at the location, will call the setter function +-- @tparam location string the location to be updated, must be registed +-- @tparam sub_location string sub_location to set, either string,player,force or surface depending on store type +-- @tparam value any the value to set at the location +function Store.set(location,sub_location,value) + if not Store.locations[location] then + return error('The location is not registed: '..location) + end + local location, sub_location, sub_location_object = get_location_parts(location,sub_location) + if location.store_type ~= Store.types['local'] then + if not Store.data[location.location] then Store.data[location.location] = {} end + Store.data[location.location][sub_location] = value + end + if location.store_type == Store.types.global then + set_global_location_value(location.location,value) + end + location.setter(sub_location_object or sub_location,value) + return true +end + +--- Gets the value at the location, if the value is nil then the getter function is called +-- @tparam location string the location to be returned, must be registed +-- @tparam sub_location string sub_location to get, either string,player,force or surface depending on store type +-- @treturn any the value that was at this location +function Store.get(location,sub_location) + if not Store.locations[location] then return end + local location, sub_location, sub_location_object = get_location_parts(location,sub_location) + local rtn = Store.data[location.location][sub_location] + if rtn == nil or Store.watching[location.location] and not Store.watching[location.location][sub_location] then + rtn = location.getter(sub_location_object or sub_location) + end + return rtn +end + +--- If used then only sub_locations marked to be watched will be watched for updates, this will also midigate the nil value problem +-- @tparam location string the location to be returned, must be registed +-- @tparam sub_location string sub_location to watch, either string,player,force or surface depending on store type, can be a table of sub_locations +-- @tparam[opt=true] state boolean when true it will be marked to be watched, when false it will be removed +function Store.watch(location,sub_location,state) + if not Store.locations[location] then + return error('The location is not registed: '..location) + end + if type(sub_location) ~= 'table' or type(sub_location.__self) == 'userdata' then + sub_location = {sub_location} + end + for _,v in pairs(sub_location) do + if not Store.watching[location] then Store.watching[location] = {} end + if state == false then Store.watching[location][v] = nil + else Store.watching[location][v] = true end + end + if #table_keys(Store.watching[location]) == 0 then Store.watching[location] = nil end +end + +--- Checks if the store value needs updating, and if true will update it calling the setter function +-- @tparam location string the location to be check, must be registed +-- @tparam sub_location string sub_location to check, either string,player,force or surface depending on store type +-- @treturn boolean if the value was updated and setter function called +function Store.check(location,sub_location) + if not Store.locations[location] then return false end + location = Store.locations[location] + local sub_location_object = get_sub_location_object(location.store_type,sub_location) + sub_location = sub_location_object and sub_location_object.name or sub_location + local store,getter = Store.data[location.location][sub_location],location.getter(sub_location_object or sub_location) + if store ~= getter then + if not Store.data[location.location] then Store.data[location.location] = {} end + Store.data[location.location][sub_location] = getter + location.setter(sub_location_object or sub_location,getter) + return true + end + return false +end + +--- Checks once per second for changes to the store values +Event.on_nth_tick(60,function() + local types = {} + for _,location in pairs(Store.locations) do + if location.store_type ~= Store.types['local'] then + if not types[location.store_type] then types[location.store_type] = {} end + table.insert(types[location.store_type],location) + end + end + for store_type,locations in pairs(types) do + local keys + if store_type == Store.types.player then keys = game.players + elseif store_type == Store.types.force then keys = game.forces + elseif store_type == Store.types.surface then keys = game.surfaces + end + if keys then + for _,sub_location in pairs(keys) do + for _,location in pairs(locations) do + if not Store.watching[location.location] or Store.watching[location.location][sub_location.name] then + if not Store.data[location.location] then Store.data[location.location] = {} end + Store.check(location.location,sub_location) + end + end + end + else + for _,location in pairs(locations) do + if not Store.data[location.location] then Store.data[location.location] = {} end + if Store.watching[location.location] then keys = Store.watching[location.location] + else keys = table_keys(Store.data[location.location]) end + for _,sub_location in pairs(keys) do + Store.check(location.location,sub_location) + end + end + end + end +end) + +return Store \ No newline at end of file diff --git a/modules/commands/interface.lua b/modules/commands/interface.lua index 6e5b89b0..98452174 100644 --- a/modules/commands/interface.lua +++ b/modules/commands/interface.lua @@ -9,7 +9,8 @@ local interface_modules = { ['Commands']=Commands, ['output']=Common.player_return, ['Group']='expcore.permission_groups', - ['Roles']='expcore.roles' + ['Roles']='expcore.roles', + ['Store']='expcore.store' } -- loads all the modules given in the above table