Updated player list

config/action_buttons.lua

@@ -15,8 +15,12 @@ local Jail = require 'modules.control.jail' --- @dep modules.control.jail
 local Colors = require 'resources.color_presets' --- @dep resources.color_presets
 local format_chat_player_name = ext_require('expcore.common','format_chat_player_name') --- @dep expcore.common
 
-local action_player_store = 'gui.left.player-list.action-player'
+local selected_player_store = ''
-local action_name_store = 'gui.left.player-list.action-name'
+local selected_action_store = ''
+local function set_store_uids(player,action)
+    selected_player_store = player
+    selected_action_store = action
+end
 
 -- common style used by all action buttons
 local function tool_button_style(style)
@@ -26,9 +30,9 @@ local function tool_button_style(style)
 end
 
 -- auth that will only allow when on player's of lower roles
-local function auth_lower_role(player,action_player_name)
+local function auth_lower_role(player,selected_player_name)
     local player_highest = Roles.get_player_highest_role(player)
-    local action_player_highest = Roles.get_player_highest_role(action_player_name)
+    local action_player_highest = Roles.get_player_highest_role(selected_player_name)
     if player_highest.index < action_player_highest.index then
         return true
     end
@@ -36,10 +40,10 @@ end
 
 -- gets the action player and a coloured name for the action to be used on
 local function get_action_player_name(player)
-    local action_player_name = Store.get(action_player_store,player.name)
+    local selected_player_name = Store.get(selected_player_store,player)
-    local action_player = Game.get_player_from_any(action_player_name)
+    local selected_player = Game.get_player_from_any(selected_player_name)
-    local action_player_name_color = format_chat_player_name(action_player)
+    local selected_player_color = format_chat_player_name(selected_player)
-    return action_player,action_player_name_color
+    return selected_player_name, selected_player_color
 end
 
 -- telports one player to another
@@ -60,12 +64,12 @@ Gui.new_button()
 :set_tooltip{'player-list.goto-player'}
 :set_style('tool_button',tool_button_style)
 :on_click(function(player,element)
-    local action_player_name = get_action_player_name(player)
+    local selected_player_name = get_action_player_name(player)
-    local action_player = Game.get_player_from_any(action_player_name)
+    local selected_player = Game.get_player_from_any(selected_player_name)
-    if not player.character or not action_player.character then
+    if not player.character or not selected_player.character then
         player.print({'expcore-commands.reject-player-alive'},Colors.orange_red)
     else
-        teleport(player,action_player)
+        teleport(player,selected_player)
     end
 end)
 
@@ -77,12 +81,12 @@ Gui.new_button()
 :set_tooltip{'player-list.bring-player'}
 :set_style('tool_button',tool_button_style)
 :on_click(function(player,element)
-    local action_player_name = get_action_player_name(player)
+    local selected_player_name = get_action_player_name(player)
-    local action_player = Game.get_player_from_any(action_player_name)
+    local selected_player = Game.get_player_from_any(selected_player_name)
-    if not player.character or not action_player.character then
+    if not player.character or not selected_player.character then
         player.print({'expcore-commands.reject-player-alive'},Colors.orange_red)
     else
-        teleport(action_player,player)
+        teleport(selected_player,player)
     end
 end)
 
@@ -94,10 +98,10 @@ Gui.new_button()
 :set_tooltip{'player-list.kill-player'}
 :set_style('tool_button',tool_button_style)
 :on_click(function(player,element)
-    local action_player_name = get_action_player_name(player)
+    local selected_player_name = get_action_player_name(player)
-    local action_player = Game.get_player_from_any(action_player_name)
+    local selected_player = Game.get_player_from_any(selected_player_name)
-    if action_player.character then
+    if selected_player.character then
-        action_player.character.die()
+        selected_player.character.die()
     else
         player.print({'expcom-kill.already-dead'},Colors.orange_red)
     end
@@ -111,20 +115,20 @@ Gui.new_button()
 :set_tooltip{'player-list.report-player'}
 :set_style('tool_button',tool_button_style)
 :on_click(function(player,element)
-    local action_player_name = get_action_player_name(player)
+    local selected_player_name = get_action_player_name(player)
-    if Reports.is_reported(action_player_name,player.name) then
+    if Reports.is_reported(selected_player_name,player.name) then
         player.print({'expcom-report.already-reported'},Colors.orange_red)
     else
-        Store.set(action_name_store,player.name,'command/report')
+        Store.set(selected_action_store,player,'command/report')
     end
 end)
 
 local function report_player_callback(player,reason)
-    local action_player_name,action_player_name_color = get_action_player_name(player)
+    local selected_player_name, selected_player_color = get_action_player_name(player)
     local by_player_name_color = format_chat_player_name(player)
-    game.print{'expcom-report.non-admin',action_player_name_color,reason}
+    game.print{'expcom-report.non-admin', selected_player_color,reason}
-    Roles.print_to_roles_higher('Trainee',{'expcom-report.admin',action_player_name_color,by_player_name_color,reason})
+    Roles.print_to_roles_higher('Trainee',{'expcom-report.admin', selected_player_color,by_player_name_color,reason})
-    Reports.report_player(action_player_name,player.name,reason)
+    Reports.report_player(selected_player_name,player.name,reason)
 end
 
 --- Gives the action player a warning, requires a reason
@@ -135,14 +139,14 @@ Gui.new_button()
 :set_tooltip{'player-list.warn-player'}
 :set_style('tool_button',tool_button_style)
 :on_click(function(player,element)
-    Store.set(action_name_store,player.name,'command/give-warning')
+    Store.set(selected_action_store,player,'command/give-warning')
 end)
 
 local function warn_player_callback(player,reason)
-    local action_player_name,action_player_name_color = get_action_player_name(player)
+    local selected_player_name, selected_player_color = get_action_player_name(player)
     local by_player_name_color = format_chat_player_name(player)
-    game.print{'expcom-warnings.received',action_player_name_color,by_player_name_color,reason}
+    game.print{'expcom-warnings.received', selected_player_color,by_player_name_color,reason}
-    Warnings.add_warning(action_player_name,player.name,reason)
+    Warnings.add_warning(selected_player_name,player.name,reason)
 end
 
 --- Jails the action player, requires a reason
@@ -153,19 +157,19 @@ Gui.new_button()
 :set_tooltip{'player-list.jail-player'}
 :set_style('tool_button',tool_button_style)
 :on_click(function(player,element)
-    local action_player_name,action_player_name_color = get_action_player_name(player)
+    local selected_player_name, selected_player_color = get_action_player_name(player)
-    if Jail.is_jailed(action_player_name) then
+    if Jail.is_jailed(selected_player_name) then
-        player.print({'expcom-jail.already-jailed',action_player_name_color},Colors.orange_red)
+        player.print({'expcom-jail.already-jailed', selected_player_color},Colors.orange_red)
     else
-        Store.set(action_name_store,player.name,'command/jail')
+        Store.set(selected_action_store,player,'command/jail')
     end
 end)
 
 local function jail_player_callback(player,reason)
-    local action_player_name,action_player_name_color = get_action_player_name(player)
+    local selected_player_name, selected_player_color = get_action_player_name(player)
     local by_player_name_color = format_chat_player_name(player)
-    game.print{'expcom-jail.give',action_player_name_color,by_player_name_color,reason}
+    game.print{'expcom-jail.give', selected_player_color,by_player_name_color,reason}
-    Jail.jail_player(action_player_name,player.name,reason)
+    Jail.jail_player(selected_player_name,player.name,reason)
 end
 
 --- Temp bans the action player, requires a reason
@@ -176,19 +180,19 @@ Gui.new_button()
 :set_tooltip{'player-list.temp-ban-player'}
 :set_style('tool_button',tool_button_style)
 :on_click(function(player,element)
-    local action_player_name,action_player_name_color = get_action_player_name(player)
+    local selected_player_name, selected_player_color = get_action_player_name(player)
-    if Jail.is_jailed(action_player_name) then
+    if Jail.is_jailed(selected_player_name) then
-        player.print({'expcom-jail.already-banned',action_player_name_color},Colors.orange_red)
+        player.print({'expcom-jail.already-banned', selected_player_color},Colors.orange_red)
     else
-        Store.set(action_name_store,player.name,'command/temp-ban')
+        Store.set(selected_action_store,player,'command/temp-ban')
     end
 end)
 
 local function temp_ban_player_callback(player,reason)
-    local action_player,action_player_name_color = get_action_player_name(player)
+    local selected_player, selected_player_color = get_action_player_name(player)
     local by_player_name_color = format_chat_player_name(player)
-    game.print{'expcom-jail.temp-ban',action_player_name_color,by_player_name_color,reason}
+    game.print{'expcom-jail.temp-ban', selected_player_color,by_player_name_color,reason}
-    Jail.temp_ban_player(action_player,player.name,reason)
+    Jail.temp_ban_player(selected_player,player.name,reason)
 end
 
 --- Kicks the action player, requires a reason
@@ -199,12 +203,12 @@ Gui.new_button()
 :set_tooltip{'player-list.kick-player'}
 :set_style('tool_button',tool_button_style)
 :on_click(function(player,element)
-    Store.set(action_name_store,player.name,'command/kick')
+    Store.set(selected_action_store,player,'command/kick')
 end)
 
 local function kick_player_callback(player,reason)
-    local action_player = get_action_player_name(player)
+    local selected_player = get_action_player_name(player)
-    game.kick_player(action_player,reason)
+    game.kick_player(selected_player,reason)
 end
 
 --- Bans the action player, requires a reason
@@ -215,64 +219,67 @@ Gui.new_button()
 :set_tooltip{'player-list.ban-player'}
 :set_style('tool_button',tool_button_style)
 :on_click(function(player,element)
-    Store.set(action_name_store,player.name,'command/ban')
+    Store.set(selected_action_store,player,'command/ban')
 end)
 
 local function ban_player_callback(player,reason)
-    local action_player = get_action_player_name(player)
+    local selected_player = get_action_player_name(player)
-    game.ban_player(action_player,reason)
+    game.ban_player(selected_player,reason)
 end
 
 return {
-    ['command/teleport'] = {
+    set_store_uids = set_store_uids,
-        auth=function(player,action_player)
+    buttons = {
-            return player.name ~= action_player.name
+        ['command/teleport'] = {
-        end, -- cant teleport to your self
+            auth=function(player,selected_player)
-        goto_player,
+                return player.name ~= selected_player.name
-        bring_player
+            end, -- cant teleport to your self
-    },
+            goto_player,
-    ['command/kill'] = {
+            bring_player
-        auth=function(player,action_player)
+        },
-            if player.name == action_player.name then
+        ['command/kill'] = {
-                return true
+            auth=function(player,selected_player)
-            elseif Roles.player_allowed(player,'command/kill/always') then
+                if player.name == selected_player.name then
-                return auth_lower_role(player,action_player)
+                    return true
-            end
+                elseif Roles.player_allowed(player,'command/kill/always') then
-        end, -- player must be lower role, or your self
+                    return auth_lower_role(player,selected_player)
-        kill_player
+                end
-    },
+            end, -- player must be lower role, or your self
-    ['command/report'] = {
+            kill_player
-        auth=function(player,action_player)
+        },
-            if not Roles.player_allowed(player,'command/give-warning') then
+        ['command/report'] = {
-                return not Roles.player_has_flag(action_player,'report-immune')
+            auth=function(player,selected_player)
-            end
+                if not Roles.player_allowed(player,'command/give-warning') then
-        end, -- can report any player that isn't immune and you aren't able to give warnings
+                    return not Roles.player_has_flag(selected_player,'report-immune')
-        reason_callback=report_player_callback,
+                end
-        report_player
+            end, -- can report any player that isn't immune and you aren't able to give warnings
-    },
+            reason_callback=report_player_callback,
-    ['command/give-warning'] = {
+            report_player
-        auth=auth_lower_role, -- warn a lower user, replaces report
+        },
-        reason_callback=warn_player_callback,
+        ['command/give-warning'] = {
-        warn_player
+            auth=auth_lower_role, -- warn a lower user, replaces report
-    },
+            reason_callback=warn_player_callback,
-    ['command/jail'] = {
+            warn_player
-        auth=auth_lower_role,
+        },
-        reason_callback=jail_player_callback,
+        ['command/jail'] = {
-        jail_player
+            auth=auth_lower_role,
-    },
+            reason_callback=jail_player_callback,
-    ['command/temp-ban'] = {
+            jail_player
-        auth=auth_lower_role,
+        },
-        reason_callback=temp_ban_player_callback,
+        ['command/temp-ban'] = {
-        temp_ban_player
+            auth=auth_lower_role,
-    },
+            reason_callback=temp_ban_player_callback,
-    ['command/kick'] = {
+            temp_ban_player
-        auth=auth_lower_role,
+        },
-        reason_callback=kick_player_callback,
+        ['command/kick'] = {
-        kick_player
+            auth=auth_lower_role,
-    },
+            reason_callback=kick_player_callback,
-    ['command/ban'] = {
+            kick_player
-        auth=auth_lower_role,
+        },
-        reason_callback=ban_player_callback,
+        ['command/ban'] = {
-        ban_player
+            auth=auth_lower_role,
+            reason_callback=ban_player_callback,
+            ban_player
+        }
     }
 }

expcore/store.lua

@@ -50,12 +50,15 @@ local Store = {
     serializers = {},
     --- An array of watchers that stores will trigger, key is store uids
     -- @table watchers
-    watchers = {}
+    watchers = {},
+    --- An index used for debuging to find the file where different stores where registered
+    -- @table file_paths
+    file_paths = {}
 }
 
 -- All data is stored in global.data_store and is accessed here with data_store
 local data_store = {}
-global.data_store = {}
+global.data_store = data_store
 Event.on_load(function()
     data_store = global.data_store
 end)
@@ -95,15 +98,17 @@ function Store.validate(store,key,error_stack)
         -- Key is present and so it is serialized and returned
         local serializer = Store.serializers[store]
         if type(key) ~= 'string' then
-            local success, key = pcall(serializer,key)
+            local success, serialized_key = pcall(serializer,key)
 
             if not success then
                 -- Serializer casued an error while serializing the key
                 error('Store watcher casued an error:\n\t'..key,error_stack+1)
-            elseif type(key) ~= 'string' then
+            elseif type(serialized_key) ~= 'string' then
                 -- Serializer was successful but failed to return a string value
                 error('Store key serializer did not return a string; recived type '..type(key),error_stack+1)
             end
+
+            return serialized_key
         end
 
         return key
@@ -139,6 +144,10 @@ function Store.register(serializer)
         Store.serializers[uid] = serializer
     end
 
+    -- Add entry in the debug table
+    local file_path = debug.getinfo(2, 'S').source:match('^.+/currently%-playing/(.+)$'):sub(1, -5)
+    Store.file_paths[uid] = file_path
+
     -- Return the new uid
     return uid
 end

modules/gui/debug/expcore_store_view.lua

@@ -0,0 +1,128 @@
+local Gui = require 'utils.gui' --- @dep utils.gui
+local Store = require 'expcore.store' --- @dep utils.global
+local Color = require 'resources.color_presets' --- @dep resources.color_presets
+local Model = require 'modules.gui.debug.model' --- @dep modules.gui.debug.model
+
+local dump = Model.dump
+local dump_text = Model.dump_text
+local concat = table.concat
+
+local Public = {}
+
+local header_name = Gui.uid_name()
+local left_panel_name = Gui.uid_name()
+local right_panel_name = Gui.uid_name()
+local input_text_box_name = Gui.uid_name()
+local refresh_name = Gui.uid_name()
+
+Public.name = 'Store'
+
+function Public.show(container)
+    local main_flow = container.add {type = 'flow', direction = 'horizontal'}
+
+    local left_panel = main_flow.add {type = 'scroll-pane', name = left_panel_name}
+    local left_panel_style = left_panel.style
+    left_panel_style.width = 300
+
+    for store_id, token_name in pairs(Store.file_paths) do
+        local header = left_panel.add({type = 'flow'}).add {type = 'label', name = header_name, caption = store_id..' - '..token_name}
+        Gui.set_data(header, store_id)
+    end
+
+    local right_flow = main_flow.add {type = 'flow', direction = 'vertical'}
+
+    local right_top_flow = right_flow.add {type = 'flow', direction = 'horizontal'}
+
+    local input_text_box = right_top_flow.add {type = 'text-box', name = input_text_box_name}
+    local input_text_box_style = input_text_box.style
+    input_text_box_style.horizontally_stretchable = true
+    input_text_box_style.height = 32
+    input_text_box_style.maximal_width = 1000
+
+    local refresh_button =
+        right_top_flow.add {type = 'sprite-button', name = refresh_name, sprite = 'utility/reset', tooltip = 'refresh'}
+    local refresh_button_style = refresh_button.style
+    refresh_button_style.width = 32
+    refresh_button_style.height = 32
+
+    local right_panel = right_flow.add {type = 'text-box', name = right_panel_name}
+    right_panel.read_only = true
+    right_panel.selectable = true
+
+    local right_panel_style = right_panel.style
+    right_panel_style.vertically_stretchable = true
+    right_panel_style.horizontally_stretchable = true
+    right_panel_style.maximal_width = 1000
+    right_panel_style.maximal_height = 1000
+
+    local data = {
+        right_panel = right_panel,
+        input_text_box = input_text_box,
+        selected_header = nil
+    }
+
+    Gui.set_data(input_text_box, data)
+    Gui.set_data(left_panel, data)
+    Gui.set_data(refresh_button, data)
+end
+
+Gui.on_click(
+    header_name,
+    function(event)
+        local element = event.element
+        local store_id = Gui.get_data(element)
+
+        local left_panel = element.parent.parent
+        local data = Gui.get_data(left_panel)
+        local right_panel = data.right_panel
+        local selected_header = data.selected_header
+        local input_text_box = data.input_text_box
+
+        if selected_header then
+            selected_header.style.font_color = Color.white
+        end
+
+        element.style.font_color = Color.orange
+        data.selected_header = element
+
+        input_text_box.text = concat {'global.data_store[', store_id, ']'}
+        input_text_box.style.font_color = Color.black
+
+        local content = dump(Store.get(store_id)) or 'nil'
+        right_panel.text = content
+    end
+)
+
+local function update_dump(text_input, data, player)
+    local suc, ouput = dump_text(text_input.text, player)
+    if not suc then
+        text_input.style.font_color = Color.red
+    else
+        text_input.style.font_color = Color.black
+        data.right_panel.text = ouput
+    end
+end
+
+Gui.on_text_changed(
+    input_text_box_name,
+    function(event)
+        local element = event.element
+        local data = Gui.get_data(element)
+
+        update_dump(element, data, event.player)
+    end
+)
+
+Gui.on_click(
+    refresh_name,
+    function(event)
+        local element = event.element
+        local data = Gui.get_data(element)
+
+        local input_text_box = data.input_text_box
+
+        update_dump(input_text_box, data, event.player)
+    end
+)
+
+return Public

modules/gui/debug/global_view.lua

@@ -8,7 +8,7 @@ local concat = table.concat
 
 local Public = {}
 
-local ignore = {tokens = true}
+local ignore = {tokens = true, data_store = true}
 
 local header_name = Gui.uid_name()
 local left_panel_name = Gui.uid_name()

modules/gui/debug/main_view.lua

@@ -5,6 +5,7 @@ local Public = {}
 
 local pages = {
     require 'modules.gui.debug.redmew_global_view',
+    require 'modules.gui.debug.expcore_store_view',
     require 'modules.gui.debug.global_view',
     require 'modules.gui.debug.package_view',
     require 'modules.gui.debug._g_view',

modules/gui/player-list.lua

@@ -13,26 +13,36 @@ local format_time = ext_require('expcore.common','format_time') --- @dep expcore
 local config = require 'config.action_buttons' --- @dep config.action_buttons
 local Colors = require 'resources.color_presets' --- @dep resources.color_presets
 
-local action_player_store = 'gui.left.player-list.action-player'
+-- Stores the name of the player a player has selected
-local action_name_store = 'gui.left.player-list.action-name'
+local selected_player_store = Store.register(function(player)
+    return player.name
+end)
 
---- used on player name label to allow zoom to map
+-- Stores the current action that a player wants to do
+local selected_action_store = Store.register(function(player)
+    return player.name
+end)
+
+-- Set the config to use these stores
+config.set_store_uids(selected_player_store,selected_action_store)
+
+--- Used to open the map on a player or toggle the settings
 local zoom_to_map_name = Gui.uid_name()
 Gui.on_click(zoom_to_map_name,function(event)
-    local action_player_name = event.element.caption
+    local selected_player_name = event.element.caption
-    local action_player = Game.get_player_from_any(action_player_name)
+    local selected_player = Game.get_player_from_any(selected_player_name)
     if event.button == defines.mouse_button_type.left then
-        -- lmb will zoom to map
+        -- LMB will open the map to the selected player
-        local position = action_player.position
+        local position = selected_player.position
         event.player.zoom_to_world(position,1.75)
     else
-        -- rmb will open settings
+        -- RMB will toggle the settings
-        local player_name = event.player.name
+        local player = event.player
-        local old_action_player_name = Store.get(action_player_store,player_name)
+        local old_selected_player_name = Store.get(selected_player_store,player)
-        if action_player_name == old_action_player_name then
+        if selected_player_name == old_selected_player_name then
-            Store.clear(action_player_store,player_name) -- will close if already open
+            Store.clear(selected_player_store,player)
         else
-            Store.set(action_player_store,player_name,action_player_name)
+            Store.set(selected_player_store,player,selected_player_name)
         end
     end
 end)
@@ -43,8 +53,8 @@ local open_action_bar =
 Gui.new_button()
 :set_sprites('utility/expand_dots_white')
 :set_tooltip{'player-list.open-action-bar'}
-:set_embedded_flow(function(element,action_player_name)
+:set_embedded_flow(function(element,selected_player_name)
-    return action_player_name
+    return selected_player_name
 end)
 :set_style('frame_button',function(style)
     Gui.set_padding_style(style,-2,-2,-2,-2)
@@ -52,12 +62,12 @@ end)
     style.height = 14
 end)
 :on_click(function(player,element)
-    local new_action_player_name = element.parent.name
+    local selected_player_name = element.parent.name
-    local action_player_name = Store.get(action_player_store,player.name)
+    local old_selected_player_name = Store.get(selected_player_store,player)
-    if action_player_name == new_action_player_name then
+    if selected_player_name == old_selected_player_name then
-        Store.clear(action_player_store,player.name) -- will close if already open
+        Store.clear(selected_player_store,player)
     else
-        Store.set(action_player_store,player.name,new_action_player_name)
+        Store.set(selected_player_store,player,selected_player_name)
     end
 end)
 
@@ -73,8 +83,8 @@ Gui.new_button()
     style.width = 28
 end)
 :on_click(function(player,element)
-    Store.clear(action_player_store,player.name)
+    Store.clear(selected_player_store,player)
-    Store.clear(action_name_store,player.name)
+    Store.clear(selected_action_store,player)
 end)
 
 --- Button used to confirm a reason
@@ -90,11 +100,11 @@ Gui.new_button()
 end)
 :on_click(function(player,element)
     local reason = element.parent.entry.text or 'Non Given'
-    local action_name = Store.get(action_name_store,player.name)
+    local action_name = Store.get(selected_action_store,player)
-    local reason_callback = config[action_name].reason_callback
+    local reason_callback = config.buttons[action_name].reason_callback
     reason_callback(player,reason)
-    Store.clear(action_player_store,player.name)
+    Store.clear(selected_player_store,player)
-    Store.clear(action_name_store,player.name)
+    Store.clear(selected_action_store,player)
     element.parent.entry.text = ''
 end)
 
@@ -143,7 +153,7 @@ local function generate_container(player,element)
     Gui.set_padding(reason_bar,-1,-1,3,3)
     reason_bar.style.horizontally_stretchable = true
     reason_bar.style.height = 35
-    local action_name = Store.get(action_name_store,player.name)
+    local action_name = Store.get(selected_action_store,player)
     reason_bar.visible = action_name ~= nil
 
     -- text entry for the reason bar
@@ -166,9 +176,9 @@ end
 --- Adds buttons and permission flows to the action bar
 local function generate_action_bar(player,element)
     close_action_bar(element)
-    local action_player = Store.get(action_player_store,player.name)
+    local selected_player_name = Store.get(selected_player_store,player)
 
-    for action_name,buttons in pairs(config) do
+    for action_name,buttons in pairs(config.buttons) do
         local permission_flow =
         element.add{
             type='flow',
@@ -183,12 +193,12 @@ local function generate_action_bar(player,element)
             permission_flow.visible = false
         end
 
-        if buttons.auth and action_player and not buttons.auth(player,action_player) then
+        if buttons.auth and selected_player_name and not buttons.auth(player,selected_player_name) then
             permission_flow.visible = false
         end
     end
 
-    if not action_player then
+    if not selected_player_name then
         element.visible = false
     end
 end
@@ -198,25 +208,30 @@ local player_list_name
 local function update_action_bar(player)
     local frame = Gui.classes.left_frames.get_frame(player_list_name,player)
     local element = frame.container.action_bar
-    local action_player_name = Store.get(action_player_store,player.name)
+    local selected_player_name = Store.get(selected_player_store,player)
 
-    if not action_player_name then
+    if not selected_player_name then
         element.visible = false
+
     else
-        local action_player = Game.get_player_from_any(action_player_name)
+        local selected_player = Game.get_player_from_any(selected_player_name)
-        if not action_player.connected then
+        if not selected_player.connected then
+            -- If the player is offline then reest stores
             element.visible = false
-            Store.clear(action_player_store,player.name) -- clears store if player is offline
+            Store.clear(selected_player_store,player)
-            Store.clear(action_name_store,player.name)
+            Store.clear(selected_action_store,player)
+
         else
+            -- Otherwise check what actions the player is allowed to use
             element.visible = true
-            for action_name,buttons in pairs(config) do
+            for action_name,buttons in pairs(config.buttons) do
-                if buttons.auth and not buttons.auth(player,action_player) then
+                if buttons.auth and not buttons.auth(player,selected_player) then
                     element[action_name].visible = false
                 elseif Roles.player_allowed(player,action_name) then
                     element[action_name].visible = true
                 end
             end
+
         end
     end
 end
@@ -323,10 +338,11 @@ end)
 player_list_name = player_list:uid()
 
 --- When the action player is changed the action bar will update
-Store.register(action_player_store,function(value,category)
+Store.watch(selected_player_store,function(value,player_name)
-    local player = Game.get_player_from_any(category)
+    local player = Game.get_player_from_any(player_name)
     update_action_bar(player)
 
+    -- Change the style of the option buttons
     local frame = player_list:get_frame(player)
     local data_table = frame.container.scroll.table
     for _,next_player in pairs(game.connected_players) do
@@ -343,21 +359,25 @@ Store.register(action_player_store,function(value,category)
 end)
 
 --- When the action name is changed the reason input will update
-Store.register(action_name_store,function(value,category)
+Store.watch(selected_action_store,function(value,player_name)
-    local player = Game.get_player_from_any(category)
+    local player = Game.get_player_from_any(player_name)
     local frame = Gui.classes.left_frames.get_frame(player_list_name,player)
     local element = frame.container.reason_bar
     if value then
-        local action_player_name = Store.get(action_player_store,category)
+        -- if there is a new value then check the player is still online
-        local action_player = Game.get_player_from_any(action_player_name)
+        local selected_player_name = Store.get(selected_player_store,player_name)
-        if action_player.connected then
+        local selected_player = Game.get_player_from_any(selected_player_name)
+        if selected_player.connected then
             element.visible = true
         else
-            Store.clear(action_player_store,category) -- clears store if player is offline
+            -- Clear if the player is offline
-            Store.clear(action_name_store,category)
+            Store.clear(selected_player_store,player_name)
+            Store.clear(selected_action_store,player_name)
         end
+
     else
         element.visible = false
+
     end
 end)