1
0
mirror of https://github.com/Refactorio/RedMew.git synced 2024-12-14 10:13:13 +02:00
RedMew/features/restart_command.lua
2022-03-14 15:24:08 +00:00

418 lines
13 KiB
Lua

local Gui = require 'utils.gui'
local Global = require 'utils.global'
local Server = require 'features.server'
local Command = require 'utils.command'
local Ranks = require 'resources.ranks'
local Token = require 'utils.token'
local Task = require 'utils.task'
local Popup = require 'features.gui.popup'
require 'utils.string'
local Public = {}
local game_types = {scenario = 'scenario', save = 'save'}
Public.game_types = game_types
local memory = {mod_pack_text = '', restarting = nil}
local start_game_data = {type = game_types.scenario, name = '', mod_pack = nil}
Global.register({start_game_data = start_game_data, memory = memory}, function(tbl)
start_game_data = tbl.start_game_data
memory = tbl.memory
end)
local function default_can_restart_func(player)
return player.valid and player.admin
end
local registered = false
local server_can_restart_func = default_can_restart_func
local server_restart_callback = nil
local server_player = {name = '<server>', print = print, admin = true}
local function double_print(str)
game.print(str)
print(str)
end
local restart_callback_token
restart_callback_token = Token.register(function(data)
if not memory.restarting then
return
end
local state = data.state
if state == 0 then
if server_restart_callback then
server_restart_callback()
end
Server.start_game(start_game_data)
double_print('restarting')
memory.restarting = nil
return
elseif state == 1 then
Popup.all('\nServer restarting!\nInitiated by ' .. data.player_name .. '\n' .. 'Next map: '
.. start_game_data.name)
end
double_print(state)
data.state = state - 1
Task.set_timeout_in_ticks(60, restart_callback_token, data)
end)
local function get_start_data(player)
local message = {'Start Game Data:', '\nType: ', start_game_data.type, '\nName: ', start_game_data.name}
local mod_pack = start_game_data.mod_pack
if mod_pack then
message[#message + 1] = '\nMod Pack: '
message[#message + 1] = mod_pack
end
local text = table.concat(message)
player.print(text)
end
local function sanitize_set_start_data_str(str)
str = str:trim()
local first_char = str:sub(1, 1)
if first_char == "'" or first_char == '"' or first_char == '{' then
return str
end
return '"' .. str .. '"'
end
local function set_start_data(player, str)
str = sanitize_set_start_data_str(str)
local func, err = loadstring('return ' .. str)
if not func then
player.print(err)
return false
end
local suc, value = pcall(func)
if not suc then
if value then
local i = value:find('\n')
if i then
player.print(value:sub(1, i))
return false
end
i = value:find('%s')
if i then
player.print(value:sub(i + 1))
end
end
return false
end
Public.set_start_game_data(value)
player.print('Start Game Data set')
get_start_data(player)
return true
end
local function restart(args, player)
player = player or server_player
if memory.restarting then
player.print('Restart already in progress')
return
end
if not server_can_restart_func(player) then
return
end
local str = args.str:trim()
if str ~= '' and player.admin then
if not set_start_data(player, str) then
return
end
end
memory.restarting = true
double_print('#################-Attention-#################')
double_print('Server restart initiated by ' .. player.name)
double_print('Next map: ' .. start_game_data.name)
double_print('###########################################')
for _, p in pairs(game.players) do
if p.admin then
p.print('Abort restart with /abort')
end
end
print('Abort restart with /abort')
Task.set_timeout_in_ticks(60, restart_callback_token, {state = 10, player_name = player.name})
end
local function abort(_, player)
player = player or server_player
if memory.restarting then
memory.restarting = nil
double_print('Restart aborted by ' .. player.name)
else
player.print('Cannot abort a restart that is not in progress.')
end
end
function Public.register(can_restart_func, restart_callback)
if registered then
error('Register can only be called once', 2)
end
if _LIFECYCLE == 8 then
error('Calling Token.register after on_init() or on_load() has run is a desync risk.', 2)
end
registered = true
server_can_restart_func = can_restart_func or default_can_restart_func
server_restart_callback = restart_callback
end
local main_frame_name = Gui.uid_name()
local close_button_name = Gui.uid_name()
local scenario_radio_button_name = Gui.uid_name()
local save_radio_button_name = Gui.uid_name()
local name_textfield_name = Gui.uid_name()
local set_mod_pack_checkbox_name = Gui.uid_name()
local mod_pack_name_textfield_name = Gui.uid_name()
Public._main_frame_name = main_frame_name
Public._close_button_name = close_button_name
Public._scenario_radio_button_name = scenario_radio_button_name
Public._save_radio_button_name = save_radio_button_name
Public._name_textfield_name = name_textfield_name
Public._set_mod_pack_checkbox_name = set_mod_pack_checkbox_name
Public._mod_pack_name_textfield_name = mod_pack_name_textfield_name
local function value_of_type_or_deafult(value, value_type, default)
if type(value) == value_type then
return value
end
return default
end
--- Gets the data used to start the next game when restart is used.
-- @returns data<table> {type<string:'scenario'|'save'>, name<string>, mod_pack<string?>}
function Public.get_start_game_data()
return {type = start_game_data.type, name = start_game_data.name, mod_pack = start_game_data.mod_pack}
end
--- Sets the data used to start the next game when restart is used.
-- @params data<table|string> {type<string?:'scenario'|'save'='scenario'>, name<string>, mod_pack<string?>}
-- If mod_pack is nil that means to use the current mod pack, set to empty string ('') to use no mod pack.
-- When data is a string: type is scenario, name is data and mod_pack is nil.
-- Note: name and mod_pack are case sensitive.
function Public.set_start_game_data(data)
local data_type = type(data)
if data_type == 'string' then
data = {type = game_types.scenario, name = data}
elseif data_type ~= 'table' then
error('data must be a table or string', 2)
end
local game_type = value_of_type_or_deafult(data.type, 'string', game_types.scenario)
local name = value_of_type_or_deafult(data.name, 'string', '')
local mod_pack = value_of_type_or_deafult(data.mod_pack, 'string', nil)
game_type = game_type:lower()
if game_type ~= game_types.save then
game_type = game_types.scenario
end
start_game_data.type = game_type
start_game_data.name = name
start_game_data.mod_pack = mod_pack
if mod_pack then
memory.mod_pack_text = mod_pack
else
memory.mod_pack_text = ''
end
end
local function draw_main_frame(player)
if player == server_player then
player.print('/config-restart with no arguments cannot be used from the server.')
return
end
local center = player.gui.center
local main_frame = center[main_frame_name]
if main_frame and main_frame.valid then
Gui.destroy(main_frame)
end
main_frame = center.add {
type = 'frame',
name = main_frame_name,
caption = 'Configure Restart',
direction = 'vertical'
}
local is_scenario = start_game_data.type == game_types.scenario
local radio_button_flow = main_frame.add {type = 'flow', direction = 'horizontal'}
radio_button_flow.add {type = 'label', caption = 'Type:'}
local scenario_radio_button = radio_button_flow.add {
type = 'radiobutton',
name = scenario_radio_button_name,
caption = 'scenario',
state = is_scenario
}
local save_radio_button = radio_button_flow.add {
type = 'radiobutton',
name = save_radio_button_name,
caption = 'save',
state = not is_scenario
}
local radio_data = {scenario_radio_button = scenario_radio_button, save_radio_button = save_radio_button}
Gui.set_data(scenario_radio_button, radio_data)
Gui.set_data(save_radio_button, radio_data)
local name_flow = main_frame.add {type = 'flow', direction = 'horizontal'}
name_flow.add {type = 'label', caption = 'Name:'}
local name_textfield = name_flow.add {type = 'textfield', name = name_textfield_name, text = start_game_data.name}
name_textfield.style.horizontally_stretchable = true
name_textfield.style.maximal_width = 600
local is_set_mod_pack = start_game_data.mod_pack ~= nil
local set_mod_pack_checkbox = main_frame.add {
type = 'checkbox',
name = set_mod_pack_checkbox_name,
caption = 'Set mod pack (uncheck to not change current)',
state = is_set_mod_pack
}
local mod_pack_name_flow = main_frame.add {type = 'flow', direction = 'horizontal'}
mod_pack_name_flow.add {type = 'label', caption = 'Mod Pack (empty to set none):'}
local mod_pack_name_textfield = mod_pack_name_flow.add {
type = 'textfield',
name = mod_pack_name_textfield_name,
text = memory.mod_pack_text
}
mod_pack_name_textfield.enabled = is_set_mod_pack
Gui.set_data(set_mod_pack_checkbox, mod_pack_name_textfield)
local bottom_flow = main_frame.add {type = 'flow', direction = 'horizontal'}
bottom_flow.add {
type = 'button',
name = close_button_name,
caption = {'common.close_button'},
style = 'back_button'
}
end
Gui.on_click(close_button_name, function(event)
local main_frame = event.player.gui.center[main_frame_name]
if main_frame and main_frame.valid then
Gui.destroy(main_frame)
end
end)
local function set_game_type(radio_data, game_type)
radio_data.scenario_radio_button.state = game_type == game_types.scenario
radio_data.save_radio_button.state = game_type == game_types.save
start_game_data.type = game_type
end
Gui.on_checked_state_changed(scenario_radio_button_name, function(event)
local radio_data = Gui.get_data(event.element)
set_game_type(radio_data, game_types.scenario)
end)
Gui.on_checked_state_changed(save_radio_button_name, function(event)
local radio_data = Gui.get_data(event.element)
set_game_type(radio_data, game_types.save)
end)
Gui.on_text_changed(name_textfield_name, function(event)
start_game_data.name = event.element.text
end)
Gui.on_checked_state_changed(set_mod_pack_checkbox_name, function(event)
local set_mod_pack_checkbox = event.element
local mod_pack_name_textfield = Gui.get_data(set_mod_pack_checkbox)
if set_mod_pack_checkbox.state then
mod_pack_name_textfield.enabled = true
start_game_data.mod_pack = memory.mod_pack_text
else
mod_pack_name_textfield.enabled = false
start_game_data.mod_pack = nil
end
end)
Gui.on_text_changed(mod_pack_name_textfield_name, function(event)
local text = event.element.text
start_game_data.mod_pack = text
memory.mod_pack_text = text
end)
local function config_restart(args, player)
local str = args.str
player = player or server_player
if str == '' then
draw_main_frame(player)
elseif str == 'get' then
get_start_data(player)
elseif str:sub(1, 3) == 'set' then
str = str:sub(4) -- remove 'set' from start of str.
set_start_data(player, str)
else
player.print('Invalid arguments')
end
end
Public._config_restart = config_restart
Command.add('config-restart', {
description = [[
configure the restart command
use /config-restart to open a gui,
use /config-restart get to prints the values,
use /config-restart set scenario_name<string> | {type<string?>, name<string>, mod_pack<string?>} to set the values
e.g. /config-restart set 'develop'
or /config-restart set {type = 'save', name = 'file.zip'}
or /config-restart set {type = 'scenario', name = 'develop', mod_pack = 'mod'}
]],
arguments = {'str'},
default_values = {str = ''},
capture_excess_arguments = true,
required_rank = Ranks.admin,
allowed_by_server = true,
allowed_by_player = true
}, config_restart)
Command.add('abort',
{description = {'command_description.abort'}, required_rank = Ranks.admin, allowed_by_server = true}, abort)
Command.add('restart', {
description = {'command_description.restart'},
arguments = {'str'},
capture_excess_arguments = true,
default_values = {str = ''},
required_rank = Ranks.guest,
allowed_by_server = true
}, restart)
return Public