@expcluster/legacy 7.0.1

package/module/modules/data/quickbar.lua

@@ -0,0 +1,72 @@
+--[[-- Commands Module - Quickbar
+    - Adds a command that allows players to load Quickbar presets
+    @data Quickbar
+]]
+
+local Commands = require("modules/exp_commands")
+local config = require("modules.exp_legacy.config.preset_player_quickbar") --- @dep config.preset_player_quickbar
+
+--- Stores the quickbar filters for a player
+local PlayerData = require("modules.exp_legacy.expcore.player_data") --- @dep expcore.player_data
+local PlayerFilters = PlayerData.Settings:combine("QuickbarFilters")
+PlayerFilters:set_metadata{
+    permission = "exp_scenario.command.save_quickbar",
+    stringify = function(value)
+        if not value then return "No filters set" end
+        local count = 0
+        for _ in pairs(value) do count = count + 1 end
+
+        return count .. " filters set"
+    end,
+}
+
+--- Loads your quickbar preset
+PlayerFilters:on_load(function(player_name, filters)
+    if not filters then filters = config[player_name] end
+    if not filters then return end
+    local player = game.players[player_name]
+    for i, item_name in pairs(filters) do
+        if item_name ~= nil and item_name ~= "" then
+            player.set_quick_bar_slot(i, item_name)
+        end
+    end
+end)
+
+local ignored_items = {
+    ["blueprint"] = true,
+    ["blueprint-book"] = true,
+    ["deconstruction-planner"] = true,
+    ["spidertron-remote"] = true,
+    ["upgrade-planner"] = true,
+}
+
+--- Saves your quickbar preset to the script-output folder
+Commands.new("save-quickbar", "Saves your Quickbar preset items to file")
+    :add_aliases{ "save-toolbar" }
+    :add_flags{ "disabled" }
+    :register(function(player)
+        local filters = {}
+
+        error("2.1 changes to get_quick_bar_slot beak compatibility with 2.0; waiting for upstream")
+        -- Upstream may add method to compat, or change inventory sync to have a quickbar only mode
+        for i = 1, 100 do
+            --[[
+            local slot = player.get_quick_bar_slot(i)
+            -- Need to filter out blueprint and blueprint books because the slot is a LuaItemPrototype and does not contain a way to export blueprint data
+            if slot ~= nil then
+                local ignored = ignored_items[slot.name]
+                if ignored ~= true then
+                    filters[i] = slot.name
+                end
+            end
+            ]]
+        end
+
+        if next(filters) then
+            PlayerFilters:set(player, filters)
+        else
+            PlayerFilters:remove(player)
+        end
+
+        return Commands.status.success{ "quickbar.saved" }
+    end)

package/module/modules/data/statistics.lua

@@ -0,0 +1,181 @@
+local ExpUtil = require("modules/exp_util")
+local Event = require("modules/exp_legacy/utils/event") --- @dep utils.event
+local Storage = require("modules/exp_util/storage") --- @dep utils.global
+local config = require("modules.exp_legacy.config.statistics") --- @dep config.statistics
+local floor = math.floor
+local afk_required = 5 * 3600 -- 5 minutes
+
+--- Stores players who have been created, required to avoid loss of data
+local new_players = {}
+Storage.register(new_players, function(tbl)
+    new_players = tbl
+end)
+
+--- Stores the statistics on a player
+local PlayerData = require("modules.exp_legacy.expcore.player_data") --- @dep expcore.player_data
+local AllPlayerData = PlayerData.All
+local Statistics = PlayerData.Statistics
+Statistics:set_metadata{
+    display_order = config.display_order,
+}
+
+--- Update your statistics with any which happened before the data was valid
+Statistics:on_load(function(player_name, player_statistics)
+    local existing_data = AllPlayerData:get(player_name)
+    if existing_data and existing_data.valid then return end
+    local counters = config.counters
+
+    -- Merge all data from before you data loaded
+    for key, value in pairs(Statistics:get(player_name, {})) do
+        if config[key] or counters[key] then
+            if not player_statistics[key] then
+                player_statistics[key] = value
+            else
+                player_statistics[key] = player_statistics[key] + value
+            end
+        end
+    end
+
+    -- Increment your maps played if this is your first time on this map
+    if new_players[player_name] then
+        new_players[player_name] = nil
+        local ctn = player_statistics.MapsPlayed
+        player_statistics["MapsPlayed"] = ctn and ctn + 1 or 1
+    end
+
+    return player_statistics
+end)
+
+local long_time_format = ExpUtil.format_time_factory_locale{ format = "long", coefficient = 3600, hours = true, minutes = true }
+local short_time_format = ExpUtil.format_time_factory_locale{ format = "short", coefficient = 3600, hours = true, minutes = true }
+
+--- Add MapsPlayed if it is enabled
+if config.MapsPlayed then
+    Statistics:combine("MapsPlayed")
+    Event.add(defines.events.on_player_created, function(event)
+        local player = game.players[event.player_index]
+        new_players[player.name] = true
+    end)
+end
+
+--- Add Playtime and AfkTime if it is enabled
+if config.Playtime or config.AfkTime then
+    local playtime, afk_time
+    if config.Playtime then
+        playtime = Statistics:combine("Playtime")
+        playtime:set_metadata{ stringify = long_time_format, stringify_short = short_time_format }
+    end
+    if config.AfkTime then
+        afk_time = Statistics:combine("AfkTime")
+        afk_time:set_metadata{ stringify = long_time_format, stringify_short = short_time_format }
+    end
+    Event.on_nth_tick(3600, function()
+        if game.tick == 0 then return end
+        for _, player in pairs(game.connected_players) do
+            if playtime then playtime:increment(player) end
+            if afk_time and player.afk_time > afk_required then afk_time:increment(player) end
+        end
+    end)
+end
+
+--- Add DistanceTravelled if it is enabled
+if config.DistanceTravelled then
+    local stat = Statistics:combine("DistanceTravelled")
+    stat:set_metadata{ unit = " tiles" }
+    Event.add(defines.events.on_player_changed_position, function(event)
+        local player = game.players[event.player_index]
+        if not player.valid or not player.connected or player.afk_time > afk_required then return end
+        stat:increment(player)
+    end)
+end
+
+--- Add MachinesRemoved and TreesDestroyed and config.OreMined if it is enabled
+if config.MachinesRemoved or config.TreesDestroyed or config.OreMined then
+    local machines, trees, ore
+    if config.MachinesRemoved then machines = Statistics:combine("MachinesRemoved") end
+    if config.TreesDestroyed then trees = Statistics:combine("TreesDestroyed") end
+    if config.OreMined then ore = Statistics:combine("OreMined") end
+    local function on_event(event)
+        if not event.player_index then return end -- Check player is valid
+        local player = game.players[event.player_index]
+        if not player.valid or not player.connected then return end
+        local entity = event.entity -- Check entity is valid
+        if not entity.valid then return end
+        if entity.type == "resource" then
+            ore:increment(player)
+        elseif entity.type == "tree" then
+            trees:increment(player)
+        elseif entity.force == player.force then
+            machines:increment(player)
+        end
+    end
+    Event.add(defines.events.on_marked_for_deconstruction, on_event)
+    Event.add(defines.events.on_player_mined_entity, on_event)
+end
+
+--- Add DamageDealt if it is enabled
+if config.DamageDealt then
+    local stat = Statistics:combine("DamageDealt")
+    Event.add(defines.events.on_entity_damaged, function(event)
+        local character = event.cause -- Check character is valid
+        if not character or not character.valid or character.type ~= "character" then return end
+        local player = character.player -- Check player is valid
+        if not player.valid or not player.connected then return end
+        local entity = event.entity -- Check entity is valid
+        if not entity.valid or entity.force == player.force or entity.force.name == "neutral" then return end
+        stat:increment(player, floor(event.final_damage_amount))
+    end)
+end
+
+--- Add Kills if it is enabled
+if config.Kills then
+    local stat = Statistics:combine("Kills")
+    Event.add(defines.events.on_entity_died, function(event)
+        local character = event.cause -- Check character is valid
+        if not character or not character.valid or character.type ~= "character" then return end
+        local player = character.player -- Check player is valid
+        if not player or not player.valid or not player.connected then return end
+        local entity = event.entity -- Check entity is valid
+        if not entity.valid or entity.force == player.force or entity.force.name == "neutral" then return end
+        stat:increment(player)
+    end)
+end
+
+--- Add RocketsLaunched if it is enabled
+if config.RocketsLaunched then
+    local stat = Statistics:combine("RocketsLaunched")
+    Event.add(defines.events.on_rocket_launched, function(event)
+        local silo = event.rocket_silo -- Check silo is valid
+        if not silo or not silo.valid then return end
+        local force = silo.force -- Check force is valid
+        if not force or not force.valid then return end
+        for _, player in pairs(force.connected_players) do
+            stat:increment(player)
+        end
+    end)
+end
+
+--- Add RocketsLaunched if it is enabled
+if config.ResearchCompleted then
+    local stat = Statistics:combine("ResearchCompleted")
+    Event.add(defines.events.on_research_finished, function(event)
+        local research = event.research -- Check research  is valid
+        if event.by_script or not research or not research.valid then return end
+        local force = research.force -- Check force is valid
+        if not force or not force.valid then return end
+        for _, player in pairs(force.connected_players) do
+            stat:increment(player)
+        end
+    end)
+end
+
+--- Add all the remaining statistics from the config
+for statistic, event_name in pairs(config.counters) do
+    local stat = Statistics:combine(statistic)
+    Event.add(event_name, function(event)
+        if not event.player_index then return end
+        local player = game.players[event.player_index]
+        if not player.valid or not player.connected then return end
+        stat:increment(player)
+    end)
+end

package/module/modules/data/tag.lua

@@ -0,0 +1,82 @@
+--[[-- Commands Module - Tag
+    - Adds a command that allows players to have a custom tag after their name
+    @data Tag
+]]
+
+local Commands = require("modules/exp_commands")
+local Roles = require("modules/exp_roles")
+
+--- Stores the tag for a player
+local PlayerData = require("modules.exp_legacy.expcore.player_data") --- @dep expcore.player_data
+local PlayerTags = PlayerData.Settings:combine("Tag")
+local PlayerTagColors = PlayerData.Settings:combine("TagColor")
+PlayerTags:set_metadata{
+    permission = "exp_scenario.command.tag",
+}
+PlayerTagColors:set_metadata{
+    permission = "exp_scenario.command.tag_color",
+}
+
+local set_tag = function(player, tag, color)
+    if tag == nil or tag == "" then
+        player.tag = ""
+    elseif color then
+        player.tag = "- [color=" .. color .. "]" .. tag .. "[/color]"
+    else
+        player.tag = "- " .. tag
+    end
+end
+
+--- When your tag is updated then apply the changes
+PlayerTags:on_update(function(player_name, player_tag)
+    local player = game.players[player_name]
+    local player_tag_color = PlayerTagColors:get(player)
+
+    set_tag(player, player_tag, player_tag_color)
+end)
+
+--- When your tag color is updated then apply the changes
+PlayerTagColors:on_update(function(player_name, player_tag_color)
+    local player = game.players[player_name]
+    local player_tag = PlayerTags:get(player)
+
+    set_tag(player, player_tag, player_tag_color)
+end)
+
+--- Sets your player tag.
+Commands.new("tag", "Sets your player tag.")
+    :argument("tag", "", Commands.types.string_max_length(20))
+    :enable_auto_concatenation()
+    :register(function(player, tag)
+        --- @cast tag string
+        PlayerTags:set(player, tag)
+    end)
+
+--- Sets your player tag color.
+Commands.new("tag-color", "Sets your player tag color.")
+    :argument("color", "", Commands.types.color)
+    :enable_auto_concatenation()
+    :register(function(player, color)
+        --- @cast color Color
+        PlayerTagColors:set(player, color)
+    end)
+
+--- Clears your tag. Or another player if you are admin.
+Commands.new("tag-clear", "Clears your tag. Or another player if you are admin.")
+    :optional("player", "", Commands.types.lower_role_player)
+    :defaults{
+        player = function(player) return player end
+    }
+    :register(function(player, other_player)
+        --- @cast other_player LuaPlayer
+        if other_player == player then
+            -- No player given so removes your tag
+            PlayerTags:remove(other_player)
+        elseif Roles.player_has_permission(player, "exp_scenario.command.tag_clear.always") then
+            -- Player given and user is admin so clears that player's tag
+            PlayerTags:remove(other_player)
+        else
+            -- User is not admin and tried to clear another users tag
+            return Commands.status.unauthorised()
+        end
+    end)

package/module/modules/data/toolbar.lua

@@ -0,0 +1,31 @@
+local Gui = require("modules/exp_gui")
+local PlayerData = require("modules.exp_legacy.expcore.player_data")
+
+-- Used to store the state of the toolbar when a player leaves
+local ToolbarState = PlayerData.Settings:combine("ToolbarState")
+ToolbarState:set_metadata{
+    stringify = function()
+        return "Toolbar is saved on exit"
+    end,
+}
+
+--- Uncompress the data to be more useable
+ToolbarState:on_load(function(player_name, value)
+    -- If there is no value, do nothing
+    if value == nil then return end
+    -- Old format, we discard it [ string[], string[], string[], boolean ]
+    if type(value) ~= "string" then return end
+
+    local decompressed = helpers.json_to_table(assert(helpers.decode_string(value), "Failed String Decode"))
+    local player = assert(game.get_player(player_name))
+    Gui.toolbar.set_state(player, decompressed --[[@as Gui.ToolbarState]])
+
+    return nil -- We don't save the state, use Gui.toolbar.get_state
+end)
+
+--- Save the current state of the players toolbar menu
+ToolbarState:on_save(function(player_name, _)
+    local player = assert(game.get_player(player_name))
+    local value = Gui.toolbar.get_state(player)
+    return helpers.encode_string(helpers.table_to_json(value))
+end)

package/module/modules/graftorio/forcestats.lua

@@ -0,0 +1,196 @@
+local Event = require("modules/exp_legacy/utils/event")
+local general = require("modules.exp_legacy.modules.graftorio.general")
+local config = require("modules.exp_legacy.config.graftorio")
+
+local lib = {}
+
+lib.collect_production = function()
+    for _, force in pairs(game.forces) do
+        general.data.output[force.name].production = {}
+        for _, surface in pairs(game.surfaces) do
+            --- @class ItemStats
+            --- @field count number
+
+            --- @class ProductionStatistics
+            --- @field item_input table<string, ItemStats>
+            --- @field item_output table<string, ItemStats>
+            --- @field fluid_input table<string, ItemStats>
+            --- @field fluid_output table<string, ItemStats>
+            --- @field kill_input table<string, ItemStats>
+            --- @field kill_output table<string, ItemStats>
+            --- @field build_input table<string, ItemStats>
+            --- @field build_output table<string, ItemStats>
+            local stats = {
+                item_input = {},
+                item_output = {},
+                fluid_input = {},
+                fluid_output = {},
+                kill_input = {},
+                kill_output = {},
+                build_input = {},
+                build_output = {},
+            }
+
+            for name, count in pairs(force.get_item_production_statistics(surface).input_counts) do
+                local itemstats = stats.item_input[name] or {}
+                itemstats.count = count
+                stats.item_input[name] = itemstats
+            end
+
+            for name, count in pairs(force.get_item_production_statistics(surface).output_counts) do
+                local itemstats = stats.item_output[name] or {}
+                itemstats.count = count
+                stats.item_output[name] = itemstats
+            end
+
+            for name, count in pairs(force.get_fluid_production_statistics(surface).input_counts) do
+                local fluidstats = stats.fluid_input[name] or {}
+                fluidstats.count = count
+                stats.fluid_input[name] = fluidstats
+            end
+
+            for name, count in pairs(force.get_fluid_production_statistics(surface).output_counts) do
+                local fluidstats = stats.fluid_output[name] or {}
+                fluidstats.count = count
+                stats.fluid_output[name] = fluidstats
+            end
+
+            for name, count in pairs(force.get_kill_count_statistics(surface).input_counts) do
+                local killstats = stats.kill_input[name] or {}
+                killstats.count = count
+                stats.kill_input[name] = killstats
+            end
+
+            for name, count in pairs(force.get_kill_count_statistics(surface).output_counts) do
+                local killstats = stats.kill_output[name] or {}
+                killstats.count = count
+                stats.kill_output[name] = killstats
+            end
+
+            for name, count in pairs(force.get_entity_build_count_statistics(surface).input_counts) do
+                local buildstats = stats.build_input[name] or {}
+                buildstats.count = count
+                stats.build_input[name] = buildstats
+            end
+
+            for name, count in pairs(force.get_entity_build_count_statistics(surface).output_counts) do
+                local buildstats = stats.build_output[name] or {}
+                buildstats.count = count
+                stats.build_output[name] = buildstats
+            end
+
+            general.data.output[force.name].production[surface.name] = stats
+        end
+    end
+end
+
+lib.collect_loginet = function()
+    for _, force in pairs(game.forces) do
+        --- @class RobotStatistics
+        --- @field all_construction_robots uint
+        --- @field available_construction_robot uint
+        --- @field all_logistic_robots uint
+        --- @field available_logistic_robots uint
+        --- @field charging_robot_count uint
+        --- @field to_charge_robot_count uint
+        --- @field items table<string, uint>
+        --- @field pickups table<string, uint>
+        --- @field deliveries table<string, uint>
+        local stats = {
+            all_construction_robots = 0,
+            available_construction_robots = 0,
+
+            all_logistic_robots = 0,
+            available_logistic_robots = 0,
+
+            charging_robot_count = 0,
+            to_charge_robot_count = 0,
+
+            items = {},
+            pickups = {},
+            deliveries = {},
+        }
+        for _, networks in pairs(force.logistic_networks) do
+            for _, network in pairs(networks) do
+                stats.available_construction_robots = network.available_construction_robots
+                stats.all_construction_robots = network.all_construction_robots
+
+                stats.available_logistic_robots = network.available_logistic_robots
+                stats.all_logistic_robots = network.all_logistic_robots
+
+                stats.charging_robot_count = 0
+                stats.to_charge_robot_count = 0
+                for _, cell in pairs(network.cells) do
+                    stats.charging_robot_count = (stats.charging_robot_count) + cell.charging_robot_count
+                    stats.to_charge_robot_count = (stats.to_charge_robot_count) + cell.to_charge_robot_count
+                end
+
+                if config.modules.logistorage then
+                    for _, item in pairs(network.get_contents()) do
+                        stats.items[item.name] = (stats.items[item.name] or 0) + item.count
+                    end
+
+                    -- pickups and deliveries of items
+                    for _, point_list in pairs{ network.provider_points, network.requester_points, network.storage_points } do
+                        for _, point in pairs(point_list) do
+                            for _, item in pairs(point.targeted_items_pickup) do
+                                stats.pickups[item.name] = (stats.pickups[item.name] or 0) + item.count
+                            end
+
+                            for _, item in pairs(point.targeted_items_deliver) do
+                                stats.deliveries[item.name] = (stats.deliveries[item.name] or 0) + item.count
+                            end
+                        end
+                    end
+                end
+            end
+        end
+
+        general.data.output[force.name].robots = stats
+    end
+end
+
+--- @class Research
+--- @field name string
+--- @field level uint
+--- @field progress double
+
+Event.add(defines.events.on_research_finished, function(evt)
+    local research = evt.research
+    if not general.data.output[research.force.name] then general.data.output[research.force.name] = {} end
+    if not general.data.output[research.force.name].research then general.data.output[research.force.name].research = {} end
+
+    local force_research = general.data.output[research.force.name].research or {}
+    table.remove(force_research, 1)
+    general.data.output[research.force.name].research = force_research
+end)
+
+Event.add(defines.events.on_research_started, function(evt)
+    -- move queue up
+    local research = evt.research
+    if not general.data.output[research.force.name].research then general.data.output[research.force.name].research = {} end
+
+    local force_research = general.data.output[research.force.name].research or {}
+    table.remove(force_research, 1)
+    general.data.output[research.force.name].research = force_research
+end)
+
+Event.on_nth_tick(60, function()
+    for _, force in pairs(game.forces) do
+        if not general.data.output[force.name].research then general.data.output[force.name].research = {} end
+
+        local force_research = {}
+        -- this works even if the queue is disabled, but it will always be just 1 long in that case
+        for _, research in pairs(force.research_queue) do
+            table.insert(force_research, {
+                name = research.name,
+                level = research.level,
+                progress = force.technologies[research.name].saved_progress
+            })
+        end
+
+        general.data.output[force.name].research = force_research
+    end
+end)
+
+return lib

package/module/modules/graftorio/general.lua

@@ -0,0 +1,63 @@
+local Event = require("modules/exp_legacy/utils/event")
+local Storage = require("modules/exp_util/storage")
+
+local lib = {}
+
+lib.data = {
+    output = {},
+}
+
+Storage.register(lib.data, function(tbl)
+    lib.data = tbl
+end)
+
+--- @class Statistics
+--- @field production ProductionStatistics?
+--- @field robots RobotStatistics?
+--- @field other OtherStatistics?
+--- @field research Research[]?
+
+Event.on_init(function()
+    --- @type table<string, Statistics>
+    lib.data.output = {}
+    for _, force in pairs(game.forces) do
+        lib.data.output[force.name] = {}
+    end
+end)
+
+--- @class OtherStatistics
+--- @field tick uint
+--- @field evolution EvolutionStatistics
+
+--- @class EvolutionStatistics
+--- @field evolution_factor double
+--- @field evolution_factor_by_pollution double
+--- @field evolution_factor_by_time double
+--- @field evolution_factor_by_killing_spawners double
+
+lib.collect_other = function()
+    for _, force in pairs(game.forces) do
+        --- @type OtherStatistics
+        local other = lib.data.output[force.name].other or {}
+
+        other.evolution = {
+            evolution_factor = force.get_evolution_factor(game.surfaces[1]),
+            evolution_factor_by_pollution = force.get_evolution_factor_by_pollution(game.surfaces[1]),
+            evolution_factor_by_time = force.get_evolution_factor_by_time(game.surfaces[1]),
+            evolution_factor_by_killing_spawners = force.get_evolution_factor_by_killing_spawners(game.surfaces[1]),
+        }
+        for k, v in pairs(other) do
+            lib.data.output[force.name].other[k] = v
+        end
+    end
+end
+
+Event.add(defines.events.on_force_created, function(evt)
+    lib.data.output[evt.force.name] = {}
+end)
+
+Event.add(defines.events.on_forces_merged, function(evt)
+    lib.data.output[evt.source_name] = nil
+end)
+
+return lib

package/module/modules/graftorio/require.lua

@@ -0,0 +1,28 @@
+local Commands = require("modules/exp_commands")
+local config = require("modules.exp_legacy.config.graftorio")
+local statics = require("modules.exp_legacy.modules.graftorio.statics")
+local general = require("modules.exp_legacy.modules.graftorio.general")
+local forcestats = nil
+
+local table_to_json = helpers.table_to_json
+
+if config.modules.forcestats then
+    forcestats = require("modules.exp_legacy.modules.graftorio.forcestats")
+end
+
+Commands.new("collectdata", "Collect data for RCON usage")
+    :optional("location", "", Commands.types.string) -- Not sure what this is for, i didn't write this
+    :register(function()
+        -- this must be first as it overwrites the stats
+        -- also makes the .other table for all forces
+        statics.collect_statics()
+        if config.modules.other then
+            general.collect_other()
+        end
+        if config.modules.forcestats then
+            --- @cast forcestats -nil
+            forcestats.collect_production()
+            forcestats.collect_loginet()
+        end
+        return Commands.status.success(table_to_json(general.data.output))
+    end)

package/module/modules/graftorio/statics.lua

@@ -0,0 +1,36 @@
+local general = require("modules.exp_legacy.modules.graftorio.general")
+
+local lib = {}
+
+--- @class StaticStatistics
+--- @field tick uint
+--- @field online_players string[]
+--- @field mods table<string, string>
+--- @field seed table<string, uint>
+
+lib.collect_statics = function()
+    local stats = {}
+    stats.tick = game.tick
+
+    stats.online_players = {}
+    for _, player in pairs(game.connected_players) do
+        table.insert(stats.online_players, player.name)
+    end
+
+    stats.mods = {}
+    for name, version in pairs(script.active_mods) do
+        stats.mods[name] = version
+    end
+
+    -- reason behind this is that the map gen settings can be changed during runtime so just get them fresh
+    stats.seed = {}
+    for _, surface in pairs(game.surfaces) do
+        stats.seed[surface.name] = surface.map_gen_settings.seed
+    end
+
+    for _, force in pairs(game.forces) do
+        general.data.output[force.name].other = stats
+    end
+end
+
+return lib