mirror of
https://github.com/PHIDIAS0303/ExpCluster.git
synced 2026-05-28 06:09:54 +09:00
--[[-- Gui Module - Readme
Adds a main gui that contains important information about the server.
]]
local ExpUtil = require("modules/exp_util")
local Gui = require("modules/exp_gui")
local Roles = require("modules.exp_legacy.expcore.roles")
local Commands = require("modules/exp_commands")
local PlayerData = require("modules.exp_legacy.expcore.player_data")
local External = require("modules.exp_legacy.expcore.external")
local format_number = require("util").format_number
local format_time = ExpUtil.format_time_factory_locale{ format = "long", days = true, hours = true, minutes = true }
local frame_width = 595
local title_width = 270
local scroll_height = 275
--- @class ExpGui_Readme.elements
local Elements = {}
--- @type table<number, { caption: LocalisedString, tooltip: LocalisedString, element: ExpElement }>
local tabs = {}
--- Register a readme tab
--- @param caption LocalisedString
--- @param tooltip LocalisedString
--- @param element ExpElement
local function define_tab(caption, tooltip, element)
tabs[#tabs + 1] = { caption = caption, tooltip = tooltip, element = element }
end
--- Create a title section table
--- @class ExpGui_Readme.elements.title_table: ExpElement
--- @overload fun(parent: LuaGuiElement, bar_size: number, caption: LocalisedString, column_count: number): LuaGuiElement
Elements.title_table = Gui.define("readme/title_table")
:draw(function(_, parent, bar_size, caption, column_count)
Gui.elements.title_label(parent, bar_size, caption)
return parent.add{
type = "table",
column_count = column_count,
style = "bordered_table",
}
end)
:style{
padding = 0,
cell_padding = 0,
vertical_align = "center",
horizontally_stretchable = true,
} --[[ @as any ]]
--- Scroll pane used for title tables
--- @class ExpGui_Readme.elements.title_table_scroll: ExpElement
--- @overload fun(parent: LuaGuiElement): LuaGuiElement
Elements.title_table_scroll = Gui.define("readme/title_table_scroll")
:draw{
type = "scroll-pane",
direction = "vertical",
horizontal_scroll_policy = "never",
vertical_scroll_policy = "auto",
style = "scroll_pane_under_subheader",
}
:style{
padding = { 1, 3 },
maximal_height = scroll_height,
horizontally_stretchable = true,
} --[[ @as any ]]
--- Sub content frame
--- @class ExpGui_Readme.elements.sub_content: ExpElement
--- @overload fun(parent: LuaGuiElement): LuaGuiElement
Elements.sub_content = Gui.define("readme/sub_content")
:draw{
type = "frame",
direction = "vertical",
style = "inside_deep_frame",
}
:style{
horizontally_stretchable = true,
horizontal_align = "center",
padding = { 2, 2 },
top_margin = 2,
} --[[ @as any ]]
--- @class ExpGui_Readme.elements.join_server.elements
--- @field server_id string
--- Join server button
--- @class ExpGui_Readme.elements.join_server: ExpElement
--- @field data table<LuaGuiElement, ExpGui_Readme.elements.join_server.elements>
--- @overload fun(parent: LuaGuiElement, server_id: string, wrong_version: string?): LuaGuiElement
Elements.join_server = Gui.define("readme/join_server")
:track_all_elements()
:draw(function(def, parent, server_id, wrong_version)
--- @cast def ExpGui_Readme.elements.join_server
local flow = parent.add{
type = "flow",
}
local button = flow.add{
type = "sprite-button",
sprite = "utility/circuit_network_panel",
hovered_sprite = "utility/circuit_network_panel",
style = "frame_action_button",
}
def.data[button] = {
server_id = server_id,
}
Elements.join_server.refresh(button, wrong_version)
return button
end)
:style{
size = 20,
padding = -1,
}
:on_click(function(def, player, button)
--- @cast def ExpGui_Readme.elements.join_server
local server_id = def.data[button].server_id
External.request_connection(player, server_id, true)
end) --[[ @as any ]]
--- Refresh join server button
--- @param button LuaGuiElement
--- @param wrong_version string?
function Elements.join_server.refresh(button, wrong_version)
local server_id = Elements.join_server.data[button].server_id
local status = External.get_server_status(server_id) or "Offline"
if wrong_version then
status = "Version"
end
button.tooltip = { "exp-gui_readme.servers-connect-" .. status, wrong_version }
if status == "Offline" or status == "Current" then
button.enabled = false
button.sprite = "utility/circuit_network_panel"
button.hovered_sprite = "utility/circuit_network_panel"
elseif status == "Version" then
button.enabled = false
button.sprite = "utility/shuffle"
button.hovered_sprite = "utility/shuffle"
elseif status == "Password" then
button.enabled = true
button.sprite = "utility/warning_white"
button.hovered_sprite = "utility/warning"
elseif status == "Modded" then
button.enabled = true
button.sprite = "utility/downloading_white"
button.hovered_sprite = "utility/downloading"
else
button.enabled = true
button.sprite = "utility/circuit_network_panel"
button.hovered_sprite = "utility/circuit_network_panel"
end
end
--- Refresh all online join buttons
function Elements.join_server.refresh_all()
if not External.valid() then
return
end
local current_version = External.get_current_server().version
for _, button in Elements.join_server:tracked_elements() do
local server_id = Elements.join_server.data[button].server_id
local server = External.get_servers()[server_id]
if server then
Elements.join_server.refresh(button, current_version ~= server.version and server.version or nil)
end
end
end
--- Welcome tab
define_tab(
{ "exp-gui_readme.welcome-tab" },
{ "exp-gui_readme.welcome-tooltip" },
Gui.define("readme/welcome")
:draw(function(_, parent)
local player = Gui.get_player(parent)
local server_details = {
name = "ExpGaming S0 - Local",
welcome = "Failed to load description: disconnected from external api.",
reset_time = "Not Set",
}
if External.valid() then
server_details = External.get_current_server()
end
local container = parent.add{ type = "flow", direction = "vertical" }
local top_flow = container.add{ type = "flow" }
top_flow.add{ type = "sprite", sprite = "file/modules/exp_legacy/modules/gui/logo.png" }
local center_flow = top_flow.add{ type = "flow", direction = "vertical" }
center_flow.style.horizontal_align = "center"
Gui.elements.title_label(center_flow, 62, { "exp-gui_readme.welcome-title", server_details.name })
Gui.elements.centered_label(center_flow, 380, server_details.welcome)
top_flow.add{ type = "sprite", sprite = "file/modules/exp_legacy/modules/gui/logo.png" }
Gui.elements.bar(container)
container.add{ type = "flow" }.style.height = 4
local role_names = {}
for i, role in ipairs(Roles.get_player_roles(player)) do
role_names[i] = role.name
end
Gui.elements.centered_label(
Elements.sub_content(container),
frame_width,
{
"exp-gui_readme.welcome-general",
server_details.reset_time,
format_time(game.tick),
}
)
Gui.elements.centered_label(
Elements.sub_content(container),
frame_width,
{
"exp-gui_readme.welcome-roles",
table.concat(role_names, ", "),
}
)
Gui.elements.centered_label(
Elements.sub_content(container),
frame_width,
{ "exp-gui_readme.welcome-chat" }
)
return container
end) --[[ @as any ]]
)
--- Rules tab
define_tab(
{ "exp-gui_readme.rules-tab" },
{ "exp-gui_readme.rules-tooltip" },
Gui.define("readme/rules")
:draw(function(_, parent)
local container = parent.add{ type = "flow", direction = "vertical" }
Gui.elements.title_label(container, title_width - 3, { "exp-gui_readme.rules-tab" })
Gui.elements.centered_label(container, frame_width, { "exp-gui_readme.rules-general" })
Gui.elements.bar(container)
container.add{ type = "flow" }
local rules = Gui.elements.scroll_table(container, scroll_height, 1)
rules.style = "bordered_table"
rules.style.cell_padding = 4
for i = 1, 15 do
Gui.elements.centered_label(rules, frame_width - 30, { "exp-gui_readme.rules-" .. i })
end
return container
end) --[[ @as any ]]
)
--- Commands tab
define_tab(
{ "exp-gui_readme.commands-tab" },
{ "exp-gui_readme.commands-tooltip" },
Gui.define("readme/commands")
:draw(function(_, parent)
local player = Gui.get_player(parent)
local container = parent.add{ type = "flow", direction = "vertical" }
Gui.elements.title_label(container, title_width - 20, { "exp-gui_readme.commands-tab" })
Gui.elements.centered_label(container, frame_width, { "exp-gui_readme.commands-general" })
Gui.elements.bar(container)
container.add{ type = "flow" }
local commands = Gui.elements.scroll_table(container, scroll_height, 2)
commands.style = "bordered_table"
commands.style.cell_padding = 0
for name, command in pairs(Commands.list_for_player(player)) do
Gui.elements.centered_label(commands, 120, name)
Gui.elements.centered_label(commands, 450, command.description)
end
return container
end) --[[ @as any ]]
)
--- Servers tab
define_tab(
{ "exp-gui_readme.servers-tab" },
{ "exp-gui_readme.servers-tooltip" },
Gui.define("readme/servers")
:draw(function(_, parent)
local container = parent.add{ type = "flow", direction = "vertical" }
Gui.elements.title_label(container, title_width - 10, { "exp-gui_readme.servers-tab" })
Gui.elements.centered_label(container, frame_width, { "exp-gui_readme.servers-general" })
Gui.elements.bar(container)
container.add{ type = "flow" }
local scroll_pane = Elements.title_table_scroll(container)
scroll_pane.style.maximal_height = scroll_height + 20
if External.valid() then
local current_version = External.get_current_server().version
local factorio_servers = Elements.title_table(scroll_pane, 225, { "exp-gui_readme.servers-factorio" }, 3)
for server_id, server in pairs(External.get_servers()) do
Gui.elements.centered_label(factorio_servers, 110, server.short_name)
Gui.elements.centered_label(factorio_servers, 436, server.description)
Elements.join_server(factorio_servers, server_id, current_version ~= server.version and server.version or nil)
end
else
local factorio_servers = Elements.title_table(scroll_pane, 225, { "exp-gui_readme.servers-factorio" }, 2)
for i = 1, 8 do
Gui.elements.centered_label(factorio_servers, 110, { "exp-gui_readme.servers-" .. i })
Gui.elements.centered_label(factorio_servers, 460, { "exp-gui_readme.servers-d" .. i })
end
end
local external_links = Elements.title_table(scroll_pane, 235, { "exp-gui_readme.servers-external" }, 2)
for _, key in ipairs{ "discord", "website", "patreon", "status", "github" } do
Gui.elements.centered_label(external_links, 110, key:gsub("^%l", string.upper))
Gui.elements.centered_label(external_links, 460, { "links." .. key }, { "exp-gui_readme.servers-open-in-browser" })
end
return container
end) --[[ @as any ]]
)
--- Backers tab
--- Content area for the backers tab
define_tab(
{ "exp-gui_readme.backers-tab" },
{ "exp-gui_readme.backers-tooltip" },
Gui.define("readme/backers")
:draw(function(_, parent)
local container = parent.add{ type = "flow", direction = "vertical" }
Gui.elements.title_label(container, title_width - 10, { "exp-gui_readme.backers-tab" })
Gui.elements.centered_label(container, frame_width, { "exp-gui_readme.backers-general" })
Gui.elements.bar(container)
container.add{ type = "flow" }
local groups = {
{
roles = { "Senior Administrator", "Administrator" },
title = { "exp-gui_readme.backers-management" },
width = 230,
players = {},
},
{
roles = { "Board Member", "Senior Backer" },
title = { "exp-gui_readme.backers-board" },
width = 145,
players = {},
},
{
roles = { "Sponsor", "Supporter" },
title = { "exp-gui_readme.backers-backers" },
width = 196,
players = {},
},
{
roles = { "Moderator", "Trainee" },
title = { "exp-gui_readme.backers-staff" },
width = 235,
players = {},
},
{
roles = {},
time = 3 * 3600 * 60,
title = { "exp-gui_readme.backers-active" },
width = 235,
players = {},
},
}
local done = {}
-- Fill groups from configured roles
for player_name, player_roles in pairs(Roles.config.players) do
for _, group in ipairs(groups) do
for _, role_name in ipairs(group.roles) do
if table.contains(player_roles, role_name) then
done[player_name] = true
group.players[#group.players + 1] = player_name
break
end
end
end
end
-- Fill active player group
for _, player in pairs(game.players) do
if not done[player.name] then
for _, group in ipairs(groups) do
if group.time and player.online_time > group.time then
group.players[#group.players + 1] = player.name
end
end
end
end
local scroll_pane = Elements.title_table_scroll(container)
for _, group in ipairs(groups) do
if #group.players > 0 then
local backers_table = Elements.title_table(scroll_pane, group.width, group.title, 4)
for _, player_name in ipairs(group.players) do
Gui.elements.centered_label(backers_table, 140, player_name)
end
if #group.players < 4 then
for i = 1, 4 - #group.players do
Gui.elements.centered_label(backers_table, 140)
end
end
end
end
return container
end) --[[ @as any ]]
)
--- @class (exact) ExpGui_Readme.elements.readme_data.param table
--- @field scroll_pane LuaGuiElement
--- @field player LuaPlayer
--- @field player_name string
--- @field children table
--- @field title LocalisedString
--- @field locale_prefix string
--- @field default_stringify fun(value: any): string
--- @field columns number
--- @field title_width number
--- @field column_width number
--- @field extra_rows fun(data_table: LuaGuiElement)?
--- Render a player data category
--- @param opts ExpGui_Readme.elements.readme_data.param
local function render_data_category(opts)
local data_table = Elements.title_table(opts.scroll_pane, opts.title_width, opts.title, opts.columns)
if opts.extra_rows then
opts.extra_rows(data_table)
end
for name, child in pairs(opts.children) do
local metadata = child.metadata
if not metadata.permission or Roles.player_allowed(opts.player, metadata.permission) then
local value = child:get(opts.player_name)
if value ~= nil or metadata.show_always then
if metadata.stringify_short then
value = metadata.stringify_short(value)
elseif metadata.stringify then
value = metadata.stringify(value)
else
value = opts.default_stringify(value)
end
local tooltip = metadata.tooltip or { opts.locale_prefix .. name .. "-tooltip" }
Gui.elements.centered_label(
data_table, 150,
metadata.name or { opts.locale_prefix .. name },
tooltip
)
Gui.elements.centered_label(
data_table, opts.column_width,
{ "exp-gui_readme.data-format", value, metadata.unit or "" },
metadata.value_tooltip or { "?", { opts.locale_prefix .. name .. "-value-tooltip" }, tooltip }
)
end
end
end
end
--- Content area for the player data tab
define_tab(
{ "exp-gui_readme.data-tab" },
{ "exp-gui_readme.data-tooltip" },
Gui.define("readme/data")
:draw(function(_, parent)
local container = parent.add{ type = "flow", direction = "vertical" }
local player = Gui.get_player(parent)
local player_name = player.name
local enum = PlayerData.PreferenceEnum
local preference = PlayerData.DataSavingPreference:get(player_name)
local preference_meta = PlayerData.DataSavingPreference.metadata
preference = enum[preference]
Gui.elements.title_label(container, title_width, { "exp-gui_readme.data-tab" })
Gui.elements.centered_label(container, frame_width, { "exp-gui_readme.data-general" })
Gui.elements.bar(container)
container.add{ type = "flow" }
local scroll_pane = Elements.title_table_scroll(container)
render_data_category{
scroll_pane = scroll_pane,
player = player,
player_name = player_name,
children = PlayerData.Required.children,
title = { "exp-gui_readme.data-required" },
locale_prefix = "exp-required.",
columns = 2,
title_width = 250,
column_width = 420,
default_stringify = tostring,
extra_rows = function(required)
Gui.elements.centered_label(required, 150, preference_meta.name, preference_meta.tooltip)
Gui.elements.centered_label(required, 420, { "expcore-data.preference-" .. enum[preference] }, preference_meta.value_tooltip)
end,
}
if preference <= enum.Settings then
render_data_category{
scroll_pane = scroll_pane,
player = player,
player_name = player_name,
children = PlayerData.Settings.children,
title = { "exp-gui_readme.data-settings" },
locale_prefix = "exp-settings.",
columns = 2,
title_width = 255,
column_width = 420,
default_stringify = function(value)
return tostring(value or "None set")
end,
}
end
if preference <= enum.Statistics then
render_data_category{
scroll_pane = scroll_pane,
player = player,
player_name = player_name,
children = PlayerData.Statistics.children,
title = { "exp-gui_readme.data-statistics" },
locale_prefix = "exp-statistics.",
columns = 4,
title_width = 250,
column_width = 130,
default_stringify = function(value)
return format_number(value or 0, false)
end,
}
end
local skip = {
DataSavingPreference = true,
Settings = true,
Statistics = true,
Required = true,
}
local count = 0
for _ in pairs(PlayerData.All.children) do
count = count + 1
end
if preference <= enum.All and count > 4 then
local misc = {}
for name, child in pairs(PlayerData.All.children) do
if not skip[name] then
misc[name] = child
end
end
render_data_category{
scroll_pane = scroll_pane,
player = player,
player_name = player_name,
children = misc,
title = { "exp-gui_readme.data-misc" },
locale_prefix = "",
columns = 2,
title_width = 232,
column_width = 420,
default_stringify = tostring,
}
end
return container
end) --[[ @as any ]]
)
--- @class ExpGui_Readme.elements.container.elements
--- @field pane LuaGuiElement
--- Main readme container
--- @class ExpGui_Readme.elements.container: ExpElement
--- @field data table<LuaGuiElement, ExpGui_Readme.elements.container.elements>
Elements.container = Gui.define("readme/container")
:track_all_elements()
:draw(function(def, parent)
--- @cast def ExpGui_Readme.elements.container
local container = parent.add{ name = def.name, type = "frame", style = "invisible_frame" }
local left_alignment = Gui.elements.aligned_flow(container, { vertical_align = "bottom" })
left_alignment.style.padding = { 32, 0, 0, 0 }
local left_side = left_alignment.add{ type = "frame", style = "character_gui_left_side" }
left_side.style.vertically_stretchable = true
left_side.style.padding = 0
left_side.style.width = 5
local pane = container.add{
name = "pane",
type = "tabbed-pane",
style = "frame_tabbed_pane",
}
for _, tab in ipairs(tabs) do
local gui_tab = pane.add{
type = "tab",
style = "frame_tab",
caption = tab.caption,
tooltip = tab.tooltip,
}
pane.add_tab(gui_tab, tab.element(pane))
end
def.data[container] = {
pane = pane,
}
return container
end)
:on_opened(function(def, player)
Gui.toolbar.set_button_toggled_state(Elements.toggle_button, player, true)
end)
:on_closed(function(def, player, element)
Gui.toolbar.set_button_toggled_state(Elements.toggle_button, player, false)
Gui.destroy_if_valid(element)
end)
--- Toggle button
Elements.toggle_button = Gui.toolbar.create_button{
name = "readme_toggle",
auto_toggle = true,
sprite = "virtual-signal/signal-info",
tooltip = { "exp-gui_readme.main-tooltip" },
visible = function(player)
return Roles.player_allowed(player, "gui/readme")
end,
}
:on_click(function(_, player)
local center = player.gui.center
local readme = center[Elements.container.name]
if readme then
player.opened = nil
else
player.opened = Elements.container(center)
end
end)
--- Open readme for new players
--- @param event EventData.on_player_created
local function open_readme(event)
local player = assert(game.get_player(event.player_index))
local element = Elements.container(player.gui.center)
element.pane.selected_tab_index = 1
player.opened = element
end
--- Clear stale readme
--- @param event EventData.on_player_joined_game | EventData.on_player_respawned
local function clear_readme(event)
local player = game.players[event.player_index]
if not player.opened then
Gui.destroy_if_valid(player.gui.center[Elements.container.name])
end
end
local e = defines.events
return {
elements = Elements,
events = {
[e.on_player_created] = open_readme,
[e.on_player_joined_game] = clear_readme,
[e.on_player_respawned] = clear_readme,
},
on_nth_tick = {
[60 * 60] = Elements.join_server.refresh_all,
}
}