737 lines
24 KiB
GDScript
737 lines
24 KiB
GDScript
class_name SaveSlotsPage
|
|
extends Control
|
|
|
|
const PAGE_SAVES: StringName = &"saves"
|
|
const PAGE_NEW: StringName = &"new"
|
|
const WorldLayoutType = preload("res://world/world_layout.gd")
|
|
const SaveManagerType = preload("res://save/player_save_manager.gd")
|
|
const NewGameSetupPageType = preload("res://ui/new_game_setup_page.gd")
|
|
const DialogControllerNavigationType = preload(
|
|
"res://ui/file_dialog_controller_navigation.gd"
|
|
)
|
|
|
|
signal back_requested
|
|
signal play_requested(slot_id: String)
|
|
signal create_requested(
|
|
display_name: String,
|
|
world_layout: StringName,
|
|
world_seed: int,
|
|
duplicate_source_slot_id: String,
|
|
)
|
|
|
|
enum SeedMode {
|
|
RANDOM,
|
|
CUSTOM,
|
|
}
|
|
|
|
@onready var _main_panel: PanelContainer = %MainPanel
|
|
@onready var _content_panel: PanelContainer = %ContentPanel
|
|
@onready var _saves_tab: OrganizerTab = %SavesTab
|
|
@onready var _new_slot_tab: OrganizerTab = %NewSlotTab
|
|
@onready var _saves_page: Control = %SavesPage
|
|
@onready var _new_slot_page: Control = %NewSlotPage
|
|
@onready var _slot_list: VBoxContainer = %SlotList
|
|
@onready var _empty_slots_label: Label = %EmptySlotsLabel
|
|
@onready var _slot_name_edit: LineEdit = %SelectedSlotName
|
|
@onready var _slot_summary: RichTextLabel = %SlotSummary
|
|
@onready var _play_button: Button = %PlaySlotButton
|
|
@onready var _rename_button: Button = %RenameSlotButton
|
|
@onready var _duplicate_button: Button = %DuplicateSlotButton
|
|
@onready var _export_button: Button = %ExportSlotButton
|
|
@onready var _delete_button: Button = %DeleteSlotButton
|
|
@onready var _import_button: Button = %ImportSlotButton
|
|
@onready var _new_slot_heading: Label = %NewSlotHeading
|
|
@onready var _new_slot_name: LineEdit = %NewSlotName
|
|
@onready var _generated_button: Button = %GeneratedButton
|
|
@onready var _starter_button: Button = %StarterButton
|
|
@onready var _world_description: Label = %WorldDescription
|
|
@onready var _seed_section: VBoxContainer = %SeedSection
|
|
@onready var _random_seed_button: Button = %RandomSeedButton
|
|
@onready var _custom_seed_button: Button = %CustomSeedButton
|
|
@onready var _seed_edit: LineEdit = %SeedEdit
|
|
@onready var _seed_help: Label = %SeedHelp
|
|
@onready var _create_button: Button = %CreateSlotButton
|
|
@onready var _status: Label = %Status
|
|
@onready var _back_button: Button = %BackButton
|
|
|
|
var _catalog: PlayerSaveSlotCatalog
|
|
var _data_root: PlayerDataRoot
|
|
var _interface_fonts: InterfaceFontController
|
|
var _active_page_id: StringName = PAGE_SAVES
|
|
var _selected_slot_id := ""
|
|
var _duplicate_source_slot_id := ""
|
|
var _world_layout: StringName = WorldLayoutType.GENERATED
|
|
var _seed_mode: SeedMode = SeedMode.RANDOM
|
|
var _random_seed: int = SaveManagerType.DEFAULT_WORLD_SEED
|
|
var _slot_buttons: Array[Button] = []
|
|
var _import_dialog: FileDialog
|
|
var _export_dialog: FileDialog
|
|
var _delete_dialog: ConfirmationDialog
|
|
var _busy: bool = false
|
|
|
|
|
|
func _ready() -> void:
|
|
_configure_style()
|
|
_saves_tab.pressed.connect(_select_page.bind(PAGE_SAVES, true))
|
|
_new_slot_tab.pressed.connect(_open_fresh_slot_page)
|
|
_play_button.pressed.connect(_request_play)
|
|
_rename_button.pressed.connect(_rename_selected_slot)
|
|
_duplicate_button.pressed.connect(_prepare_duplicate)
|
|
_export_button.pressed.connect(_choose_export_path)
|
|
_delete_button.pressed.connect(_confirm_delete_selected_slot)
|
|
_import_button.pressed.connect(_choose_import_path)
|
|
_generated_button.pressed.connect(
|
|
_set_world_layout.bind(WorldLayoutType.GENERATED)
|
|
)
|
|
_starter_button.pressed.connect(
|
|
_set_world_layout.bind(WorldLayoutType.STARTER_ISLAND)
|
|
)
|
|
_random_seed_button.pressed.connect(_choose_random_seed)
|
|
_custom_seed_button.pressed.connect(_choose_custom_seed)
|
|
_new_slot_name.text_changed.connect(_on_new_slot_name_changed)
|
|
_seed_edit.text_changed.connect(_on_seed_text_changed)
|
|
_seed_edit.text_submitted.connect(_on_seed_submitted)
|
|
_new_slot_name.text_submitted.connect(_on_new_slot_name_submitted)
|
|
_create_button.pressed.connect(_request_create)
|
|
_back_button.pressed.connect(request_back)
|
|
visibility_changed.connect(_on_visibility_changed)
|
|
hide()
|
|
|
|
|
|
func _configure_style() -> void:
|
|
UtilityPageStyle.apply_page(self)
|
|
_main_panel.add_theme_stylebox_override(
|
|
"panel",
|
|
UtilityPageStyle.rounded_style(
|
|
UtilityPageStyle.OCEAN_PANEL_MID,
|
|
28,
|
|
),
|
|
)
|
|
_content_panel.add_theme_stylebox_override(
|
|
"panel",
|
|
UtilityPageStyle.rounded_style(
|
|
UtilityPageStyle.OCEAN_FIELD,
|
|
20,
|
|
),
|
|
)
|
|
for node: Node in find_children("*", "Label", true, false):
|
|
var label := node as Label
|
|
label.add_theme_color_override(
|
|
"font_color",
|
|
UtilityPageStyle.OCEAN_TEXT_PRIMARY,
|
|
)
|
|
for node: Node in find_children("*", "Button", true, false):
|
|
if node is OrganizerTab:
|
|
continue
|
|
UtilityPageStyle.apply_ocean_button(node as BaseButton)
|
|
_play_button.add_theme_stylebox_override(
|
|
"normal",
|
|
UtilityPageStyle.ocean_button_style(
|
|
UtilityPageStyle.GREEN,
|
|
),
|
|
)
|
|
_delete_button.add_theme_stylebox_override(
|
|
"normal",
|
|
UtilityPageStyle.ocean_button_style(
|
|
UtilityPageStyle.OCEAN_DANGER,
|
|
),
|
|
)
|
|
_back_button.add_theme_stylebox_override(
|
|
"normal",
|
|
UtilityPageStyle.ocean_button_style(
|
|
UtilityPageStyle.OCEAN_PANEL_DEEP,
|
|
),
|
|
)
|
|
_status.add_theme_color_override(
|
|
"font_color",
|
|
UtilityPageStyle.OCEAN_TEXT_SECONDARY,
|
|
)
|
|
|
|
|
|
func setup(
|
|
catalog: PlayerSaveSlotCatalog,
|
|
data_root: PlayerDataRoot,
|
|
interface_fonts: InterfaceFontController,
|
|
) -> void:
|
|
_catalog = catalog
|
|
_data_root = data_root
|
|
_interface_fonts = interface_fonts
|
|
if not _catalog.slots_changed.is_connected(_on_slots_changed):
|
|
_catalog.slots_changed.connect(_on_slots_changed)
|
|
|
|
|
|
func open_page() -> void:
|
|
_busy = false
|
|
_status.text = ""
|
|
_duplicate_source_slot_id = ""
|
|
_refresh_slots()
|
|
if _catalog != null and _catalog.has_slots():
|
|
_select_page(PAGE_SAVES, false)
|
|
else:
|
|
_prepare_fresh_slot()
|
|
_select_page(PAGE_NEW, false)
|
|
show()
|
|
_main_panel.modulate.a = 1.0
|
|
_main_panel.scale = Vector2.ONE
|
|
UtilityPageStyle.animate_in(self)
|
|
call_deferred("_focus_open_page")
|
|
|
|
|
|
func close_page() -> void:
|
|
_release_owned_focus()
|
|
hide()
|
|
|
|
|
|
func request_back() -> void:
|
|
if _import_dialog != null and _import_dialog.visible:
|
|
_import_dialog.hide()
|
|
return
|
|
if _export_dialog != null and _export_dialog.visible:
|
|
_export_dialog.hide()
|
|
return
|
|
if _delete_dialog != null and _delete_dialog.visible:
|
|
_delete_dialog.hide()
|
|
return
|
|
if _busy:
|
|
return
|
|
if _active_page_id == PAGE_NEW and _catalog != null and _catalog.has_slots():
|
|
_duplicate_source_slot_id = ""
|
|
_select_page(PAGE_SAVES, true)
|
|
return
|
|
back_requested.emit()
|
|
|
|
|
|
func set_status(message: String) -> void:
|
|
_busy = false
|
|
_status.text = message
|
|
_refresh_action_state()
|
|
|
|
|
|
func finish_request_if_pending(message: String) -> void:
|
|
if _busy:
|
|
set_status(message)
|
|
|
|
|
|
func refresh_page() -> void:
|
|
if visible:
|
|
_refresh_slots()
|
|
|
|
|
|
func get_active_page_id() -> StringName:
|
|
return _active_page_id if visible else StringName()
|
|
|
|
|
|
func _select_page(page_id: StringName, focus_tab: bool) -> void:
|
|
if page_id not in [PAGE_SAVES, PAGE_NEW]:
|
|
return
|
|
_active_page_id = page_id
|
|
_saves_page.visible = page_id == PAGE_SAVES
|
|
_new_slot_page.visible = page_id == PAGE_NEW
|
|
_saves_tab.set_selected(page_id == PAGE_SAVES, is_inside_tree())
|
|
_new_slot_tab.set_selected(page_id == PAGE_NEW, is_inside_tree())
|
|
_configure_controller_focus()
|
|
if focus_tab:
|
|
(_saves_tab if page_id == PAGE_SAVES else _new_slot_tab).grab_focus()
|
|
|
|
|
|
func _open_fresh_slot_page() -> void:
|
|
_prepare_fresh_slot()
|
|
_select_page(PAGE_NEW, true)
|
|
|
|
|
|
func _prepare_fresh_slot() -> void:
|
|
_duplicate_source_slot_id = ""
|
|
_new_slot_heading.text = "new progression"
|
|
_new_slot_name.text = _suggested_slot_name()
|
|
_world_layout = WorldLayoutType.GENERATED
|
|
_seed_mode = SeedMode.RANDOM
|
|
_roll_random_seed()
|
|
_refresh_new_slot_presentation()
|
|
|
|
|
|
func _prepare_duplicate() -> void:
|
|
var slot: Dictionary = _selected_slot()
|
|
if slot.is_empty() or not bool(slot.get("has_save", false)):
|
|
return
|
|
_duplicate_source_slot_id = _selected_slot_id
|
|
_new_slot_heading.text = "duplicate progression"
|
|
_new_slot_name.text = PlayerSaveSlotCatalog.normalized_name(
|
|
"copy of %s" % str(slot.get("display_name", "save"))
|
|
)
|
|
_world_layout = WorldLayoutType.GENERATED
|
|
_seed_mode = SeedMode.RANDOM
|
|
_roll_random_seed()
|
|
_refresh_new_slot_presentation()
|
|
_select_page(PAGE_NEW, true)
|
|
|
|
|
|
func _refresh_slots() -> void:
|
|
for button: Button in _slot_buttons:
|
|
_slot_list.remove_child(button)
|
|
button.queue_free()
|
|
_slot_buttons.clear()
|
|
if _catalog == null:
|
|
_selected_slot_id = ""
|
|
_empty_slots_label.show()
|
|
_refresh_selected_slot()
|
|
return
|
|
var slots: Array[Dictionary] = _catalog.list_slots()
|
|
var known_selection: bool = false
|
|
for slot: Dictionary in slots:
|
|
var slot_id: String = str(slot.get("slot_id", ""))
|
|
var button := Button.new()
|
|
button.name = "Slot_%s" % slot_id.left(8)
|
|
button.custom_minimum_size = Vector2(0.0, 56.0)
|
|
button.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
button.focus_mode = Control.FOCUS_ALL
|
|
button.toggle_mode = true
|
|
button.text = str(slot.get("display_name", "save")) + (
|
|
" · active" if bool(slot.get("active", false)) else ""
|
|
)
|
|
button.alignment = HORIZONTAL_ALIGNMENT_LEFT
|
|
UtilityPageStyle.apply_ocean_button(button)
|
|
button.pressed.connect(_select_slot.bind(slot_id, false))
|
|
button.focus_entered.connect(_select_slot.bind(slot_id, true))
|
|
_slot_list.add_child(button)
|
|
_slot_buttons.append(button)
|
|
known_selection = known_selection or slot_id == _selected_slot_id
|
|
_empty_slots_label.visible = slots.is_empty()
|
|
if not known_selection:
|
|
_selected_slot_id = _catalog.get_active_slot_id()
|
|
if _selected_slot_id.is_empty() and not slots.is_empty():
|
|
_selected_slot_id = str(slots.front().get("slot_id", ""))
|
|
_refresh_selected_slot()
|
|
_configure_controller_focus()
|
|
|
|
|
|
func _select_slot(slot_id: String, _from_focus: bool) -> void:
|
|
if _catalog == null or _catalog.get_slot(slot_id).is_empty():
|
|
return
|
|
_selected_slot_id = slot_id
|
|
_refresh_selected_slot()
|
|
|
|
|
|
func _refresh_selected_slot() -> void:
|
|
var slot: Dictionary = _selected_slot()
|
|
for button: Button in _slot_buttons:
|
|
button.set_pressed_no_signal(
|
|
button.name == "Slot_%s" % _selected_slot_id.left(8)
|
|
)
|
|
if slot.is_empty():
|
|
_slot_name_edit.text = ""
|
|
_slot_name_edit.editable = false
|
|
_slot_summary.text = "[center]create or import a save slot to begin.[/center]"
|
|
else:
|
|
_slot_name_edit.editable = true
|
|
_slot_name_edit.text = str(slot.get("display_name", "save"))
|
|
_slot_summary.text = _format_slot_summary(slot)
|
|
_refresh_action_state()
|
|
|
|
|
|
func _format_slot_summary(slot: Dictionary) -> String:
|
|
if not bool(slot.get("has_save", false)):
|
|
return "[center]%s[/center]" % str(
|
|
slot.get("status_message", "this slot has no progression yet.")
|
|
)
|
|
var last_played: String = _format_timestamp(
|
|
int(slot.get("last_played_at_unix", 0))
|
|
)
|
|
return (
|
|
"[font_size=24]level %d[/font_size]\n\n"
|
|
+ "%d catches · %d discovered\n"
|
|
+ "%d fishcoins\n\n"
|
|
+ "%s · seed %d\n"
|
|
+ "last played %s"
|
|
) % [
|
|
int(slot.get("player_level", 1)),
|
|
int(slot.get("catch_count", 0)),
|
|
int(slot.get("discovered_species_count", 0)),
|
|
int(slot.get("wallet_balance", 0)),
|
|
WorldLayoutType.display_name(slot.get("world_layout", "")),
|
|
int(slot.get("world_seed", 0)),
|
|
last_played,
|
|
]
|
|
|
|
|
|
func _refresh_action_state() -> void:
|
|
var slot: Dictionary = _selected_slot()
|
|
var has_slot: bool = not slot.is_empty()
|
|
var has_save: bool = has_slot and bool(slot.get("has_save", false))
|
|
_play_button.disabled = _busy or not has_save
|
|
_rename_button.disabled = _busy or not has_slot
|
|
_duplicate_button.disabled = _busy or not has_save
|
|
_export_button.disabled = _busy or not has_save
|
|
_delete_button.disabled = _busy or not has_slot
|
|
_import_button.disabled = _busy or _catalog == null
|
|
_create_button.disabled = _busy or not _new_slot_request_is_valid()
|
|
|
|
|
|
func _request_play() -> void:
|
|
if _play_button.disabled or _selected_slot_id.is_empty():
|
|
return
|
|
_busy = true
|
|
_status.text = "loading save slot..."
|
|
_refresh_action_state()
|
|
play_requested.emit(_selected_slot_id)
|
|
|
|
|
|
func _rename_selected_slot() -> void:
|
|
if _catalog == null or _rename_button.disabled:
|
|
return
|
|
if not _catalog.rename_slot(_selected_slot_id, _slot_name_edit.text):
|
|
_status.text = "the save slot could not be renamed."
|
|
return
|
|
_status.text = "save slot renamed."
|
|
|
|
|
|
func _confirm_delete_selected_slot() -> void:
|
|
var slot: Dictionary = _selected_slot()
|
|
if slot.is_empty() or _delete_button.disabled:
|
|
return
|
|
if _delete_dialog == null:
|
|
_delete_dialog = ConfirmationDialog.new()
|
|
_delete_dialog.title = "delete save slot?"
|
|
_delete_dialog.ok_button_text = "delete"
|
|
_delete_dialog.confirmed.connect(_delete_selected_slot)
|
|
if _interface_fonts != null:
|
|
_interface_fonts.apply_utility_theme(_delete_dialog)
|
|
add_child(_delete_dialog)
|
|
_delete_dialog.dialog_text = (
|
|
"delete \"%s\"? this cannot be undone from the game."
|
|
% str(slot.get("display_name", "save"))
|
|
)
|
|
_delete_dialog.popup_centered(Vector2i(560, 260))
|
|
_configure_delete_dialog.call_deferred()
|
|
|
|
|
|
func _configure_delete_dialog() -> void:
|
|
if (
|
|
_delete_dialog != null
|
|
and is_instance_valid(_delete_dialog)
|
|
and _delete_dialog.visible
|
|
):
|
|
DialogControllerNavigationType.configure_scope(
|
|
_delete_dialog,
|
|
_delete_dialog.get_cancel_button(),
|
|
)
|
|
|
|
|
|
func _delete_selected_slot() -> void:
|
|
if _catalog == null or _selected_slot_id.is_empty():
|
|
return
|
|
if not _catalog.delete_slot(_selected_slot_id):
|
|
_status.text = "the save slot could not be deleted."
|
|
return
|
|
_selected_slot_id = _catalog.get_active_slot_id()
|
|
_status.text = "save slot deleted."
|
|
_refresh_slots()
|
|
if not _catalog.has_slots():
|
|
_prepare_fresh_slot()
|
|
_select_page(PAGE_NEW, true)
|
|
|
|
|
|
func _choose_import_path() -> void:
|
|
if _catalog == null or _data_root == null:
|
|
return
|
|
if _import_dialog == null:
|
|
_import_dialog = FileDialog.new()
|
|
_import_dialog.file_mode = FileDialog.FILE_MODE_OPEN_FILE
|
|
_import_dialog.access = FileDialog.ACCESS_FILESYSTEM
|
|
_import_dialog.use_native_dialog = false
|
|
_import_dialog.filters = PackedStringArray([
|
|
"*.nfsave ; straywild progression archive",
|
|
])
|
|
_import_dialog.file_selected.connect(_import_file_selected)
|
|
if _interface_fonts != null:
|
|
_interface_fonts.apply_utility_theme(_import_dialog)
|
|
add_child(_import_dialog)
|
|
_import_dialog.current_dir = _data_root.progression_backup_directory()
|
|
if _interface_fonts != null:
|
|
_interface_fonts.popup_file_dialog(_import_dialog)
|
|
else:
|
|
_import_dialog.popup_centered_ratio(0.85)
|
|
|
|
|
|
func _import_file_selected(path: String) -> void:
|
|
var suggested_name: String = path.get_file().get_basename().replace("_", " ")
|
|
suggested_name = suggested_name.replace("-", " ")
|
|
var result: Dictionary = _catalog.import_slot(path, suggested_name)
|
|
_status.text = str(result.get("message", "progression import failed."))
|
|
if bool(result.get("ok", false)):
|
|
_selected_slot_id = str(result.get("slot_id", ""))
|
|
_refresh_slots()
|
|
_select_page(PAGE_SAVES, false)
|
|
|
|
|
|
func _choose_export_path() -> void:
|
|
var slot: Dictionary = _selected_slot()
|
|
if slot.is_empty() or _data_root == null:
|
|
return
|
|
var timestamp: String = Time.get_datetime_string_from_system().replace(":", "-")
|
|
var filename: String = "%s-%s%s" % [
|
|
_safe_filename(str(slot.get("display_name", "save"))),
|
|
timestamp,
|
|
PlayerSaveManager.ARCHIVE_EXTENSION,
|
|
]
|
|
if _export_dialog == null:
|
|
_export_dialog = FileDialog.new()
|
|
_export_dialog.file_mode = FileDialog.FILE_MODE_SAVE_FILE
|
|
_export_dialog.access = FileDialog.ACCESS_FILESYSTEM
|
|
_export_dialog.use_native_dialog = false
|
|
_export_dialog.filters = PackedStringArray([
|
|
"*.nfsave ; straywild progression archive",
|
|
])
|
|
_export_dialog.file_selected.connect(_export_file_selected)
|
|
if _interface_fonts != null:
|
|
_interface_fonts.apply_utility_theme(_export_dialog)
|
|
add_child(_export_dialog)
|
|
_export_dialog.current_dir = _data_root.progression_backup_directory()
|
|
_export_dialog.current_file = filename
|
|
if _interface_fonts != null:
|
|
_interface_fonts.popup_file_dialog(_export_dialog)
|
|
else:
|
|
_export_dialog.popup_centered_ratio(0.85)
|
|
|
|
|
|
func _export_file_selected(path: String) -> void:
|
|
var destination: String = (
|
|
path
|
|
if path.ends_with(PlayerSaveManager.ARCHIVE_EXTENSION)
|
|
else path + PlayerSaveManager.ARCHIVE_EXTENSION
|
|
)
|
|
var result: Dictionary = _catalog.export_slot(
|
|
_selected_slot_id,
|
|
destination,
|
|
)
|
|
_status.text = str(result.get("message", "progression export failed."))
|
|
|
|
|
|
func _request_create() -> void:
|
|
if _create_button.disabled:
|
|
return
|
|
var seed: int = _selected_world_seed()
|
|
if _world_layout == WorldLayoutType.GENERATED and seed == 0:
|
|
_status.text = "enter text or a whole number from 1 to %d." % SaveManagerType.MAX_WORLD_SEED
|
|
_seed_edit.grab_focus()
|
|
_seed_edit.select_all()
|
|
return
|
|
if seed == 0:
|
|
seed = SaveManagerType.roll_world_seed()
|
|
_busy = true
|
|
_status.text = "creating save slot..."
|
|
_refresh_action_state()
|
|
create_requested.emit(
|
|
PlayerSaveSlotCatalog.normalized_name(_new_slot_name.text),
|
|
_world_layout,
|
|
seed,
|
|
_duplicate_source_slot_id,
|
|
)
|
|
|
|
|
|
func _set_world_layout(layout: StringName) -> void:
|
|
if not WorldLayoutType.is_valid(layout):
|
|
return
|
|
_world_layout = layout
|
|
_status.text = ""
|
|
_refresh_new_slot_presentation()
|
|
|
|
|
|
func _choose_random_seed() -> void:
|
|
_seed_mode = SeedMode.RANDOM
|
|
_roll_random_seed()
|
|
_status.text = ""
|
|
_refresh_new_slot_presentation()
|
|
|
|
|
|
func _choose_custom_seed() -> void:
|
|
_seed_mode = SeedMode.CUSTOM
|
|
if NewGameSetupPageType.parse_seed_text(_seed_edit.text) == _random_seed:
|
|
_seed_edit.text = ""
|
|
_status.text = ""
|
|
_refresh_new_slot_presentation()
|
|
_seed_edit.grab_focus.call_deferred()
|
|
_seed_edit.select_all.call_deferred()
|
|
|
|
|
|
func _roll_random_seed() -> void:
|
|
_random_seed = SaveManagerType.roll_world_seed()
|
|
_seed_edit.text = str(_random_seed)
|
|
|
|
|
|
func _selected_world_seed() -> int:
|
|
return (
|
|
_random_seed
|
|
if _seed_mode == SeedMode.RANDOM
|
|
else NewGameSetupPageType.parse_seed_text(_seed_edit.text)
|
|
)
|
|
|
|
|
|
func _on_seed_text_changed(_text: String) -> void:
|
|
if _seed_mode == SeedMode.CUSTOM:
|
|
_status.text = ""
|
|
_refresh_action_state()
|
|
|
|
|
|
func _on_new_slot_name_changed(_text: String) -> void:
|
|
_refresh_action_state()
|
|
|
|
|
|
func _on_seed_submitted(_text: String) -> void:
|
|
_request_create()
|
|
|
|
|
|
func _on_new_slot_name_submitted(_text: String) -> void:
|
|
if _world_layout == WorldLayoutType.STARTER_ISLAND:
|
|
_request_create()
|
|
|
|
|
|
func _refresh_new_slot_presentation() -> void:
|
|
var generated: bool = _world_layout == WorldLayoutType.GENERATED
|
|
_generated_button.set_pressed_no_signal(generated)
|
|
_starter_button.set_pressed_no_signal(not generated)
|
|
_world_description.text = (
|
|
"build a new island from terrain chunks.\n"
|
|
+ "the same seed always builds the same world."
|
|
if generated
|
|
else "play on the starter island."
|
|
)
|
|
_seed_section.visible = generated
|
|
_random_seed_button.set_pressed_no_signal(_seed_mode == SeedMode.RANDOM)
|
|
_custom_seed_button.set_pressed_no_signal(_seed_mode == SeedMode.CUSTOM)
|
|
_seed_edit.editable = _seed_mode == SeedMode.CUSTOM
|
|
_seed_edit.focus_mode = (
|
|
Control.FOCUS_ALL if _seed_mode == SeedMode.CUSTOM else Control.FOCUS_NONE
|
|
)
|
|
_seed_help.text = (
|
|
"press random seed again to roll another world."
|
|
if _seed_mode == SeedMode.RANDOM
|
|
else "enter text or a number from 1 to %d."
|
|
% SaveManagerType.MAX_WORLD_SEED
|
|
)
|
|
_create_button.text = (
|
|
"duplicate and play"
|
|
if not _duplicate_source_slot_id.is_empty()
|
|
else "create and play"
|
|
)
|
|
_refresh_action_state()
|
|
_configure_controller_focus()
|
|
|
|
|
|
func _new_slot_request_is_valid() -> bool:
|
|
return (
|
|
not PlayerSaveSlotCatalog.normalized_name(_new_slot_name.text).is_empty()
|
|
and (
|
|
_world_layout != WorldLayoutType.GENERATED
|
|
or _seed_mode == SeedMode.RANDOM
|
|
or NewGameSetupPageType.parse_seed_text(_seed_edit.text) > 0
|
|
)
|
|
)
|
|
|
|
|
|
func _configure_controller_focus() -> void:
|
|
if not is_node_ready():
|
|
return
|
|
_saves_tab.focus_neighbor_right = _saves_tab.get_path_to(_new_slot_tab)
|
|
_new_slot_tab.focus_neighbor_left = _new_slot_tab.get_path_to(_saves_tab)
|
|
if _active_page_id == PAGE_SAVES:
|
|
var first: Control = _slot_buttons.front() if not _slot_buttons.is_empty() else _import_button
|
|
var last: Control = _slot_buttons.back() if not _slot_buttons.is_empty() else _import_button
|
|
_saves_tab.focus_neighbor_bottom = _saves_tab.get_path_to(first)
|
|
_new_slot_tab.focus_neighbor_bottom = _new_slot_tab.get_path_to(first)
|
|
for index: int in _slot_buttons.size():
|
|
var button: Button = _slot_buttons[index]
|
|
var top: Control = _saves_tab if index == 0 else _slot_buttons[index - 1]
|
|
var bottom: Control = _import_button if index == _slot_buttons.size() - 1 else _slot_buttons[index + 1]
|
|
_set_neighbors(button, button, _slot_name_edit, top, bottom)
|
|
_set_neighbors(_import_button, _import_button, _slot_name_edit, last, _back_button)
|
|
_set_neighbors(_slot_name_edit, first, _slot_name_edit, _saves_tab, _play_button)
|
|
_set_neighbors(_play_button, _import_button, _play_button, _slot_name_edit, _rename_button)
|
|
_set_neighbors(_rename_button, _import_button, _duplicate_button, _play_button, _export_button)
|
|
_set_neighbors(_duplicate_button, _rename_button, _duplicate_button, _play_button, _delete_button)
|
|
_set_neighbors(_export_button, _import_button, _delete_button, _rename_button, _back_button)
|
|
_set_neighbors(_delete_button, _export_button, _delete_button, _duplicate_button, _back_button)
|
|
_set_neighbors(_back_button, _back_button, _back_button, _import_button, _back_button)
|
|
return
|
|
_saves_tab.focus_neighbor_bottom = _saves_tab.get_path_to(_new_slot_name)
|
|
_new_slot_tab.focus_neighbor_bottom = _new_slot_tab.get_path_to(_new_slot_name)
|
|
var generated: bool = _world_layout == WorldLayoutType.GENERATED
|
|
var custom: bool = generated and _seed_mode == SeedMode.CUSTOM
|
|
_set_neighbors(_new_slot_name, _new_slot_name, _new_slot_name, _new_slot_tab, _generated_button)
|
|
_set_neighbors(_generated_button, _generated_button, _starter_button, _new_slot_name, _random_seed_button if generated else _create_button)
|
|
_set_neighbors(_starter_button, _generated_button, _starter_button, _new_slot_name, _custom_seed_button if generated else _back_button)
|
|
_set_neighbors(_random_seed_button, _random_seed_button, _custom_seed_button, _generated_button, _seed_edit if custom else _create_button)
|
|
_set_neighbors(_custom_seed_button, _random_seed_button, _custom_seed_button, _starter_button, _seed_edit if custom else _back_button)
|
|
_set_neighbors(_seed_edit, _seed_edit, _seed_edit, _custom_seed_button, _create_button)
|
|
var action_top: Control = _seed_edit if custom else _random_seed_button if generated else _generated_button
|
|
_set_neighbors(_create_button, _create_button, _back_button, action_top, _create_button)
|
|
_set_neighbors(_back_button, _create_button, _back_button, action_top, _back_button)
|
|
|
|
|
|
func _set_neighbors(
|
|
control: Control,
|
|
left: Control,
|
|
right: Control,
|
|
top: Control,
|
|
bottom: Control,
|
|
) -> void:
|
|
control.focus_neighbor_left = control.get_path_to(left)
|
|
control.focus_neighbor_right = control.get_path_to(right)
|
|
control.focus_neighbor_top = control.get_path_to(top)
|
|
control.focus_neighbor_bottom = control.get_path_to(bottom)
|
|
|
|
|
|
func _focus_open_page() -> void:
|
|
if not visible:
|
|
return
|
|
(_saves_tab if _active_page_id == PAGE_SAVES else _new_slot_tab).grab_focus()
|
|
|
|
|
|
func _selected_slot() -> Dictionary:
|
|
return _catalog.get_slot(_selected_slot_id) if _catalog != null else {}
|
|
|
|
|
|
func _suggested_slot_name() -> String:
|
|
var used: Dictionary[String, bool] = {}
|
|
if _catalog != null:
|
|
for slot: Dictionary in _catalog.list_slots():
|
|
used[str(slot.get("display_name", "")).to_lower()] = true
|
|
var number: int = 1
|
|
while used.has("save %d" % number):
|
|
number += 1
|
|
return "save %d" % number
|
|
|
|
|
|
func _format_timestamp(unix_time: int) -> String:
|
|
if unix_time <= 0:
|
|
return "never"
|
|
var value: Dictionary = Time.get_datetime_dict_from_unix_time(unix_time)
|
|
return "%04d-%02d-%02d" % [
|
|
int(value.get("year", 0)),
|
|
int(value.get("month", 0)),
|
|
int(value.get("day", 0)),
|
|
]
|
|
|
|
|
|
func _safe_filename(value: String) -> String:
|
|
var result: String = value.strip_edges().to_lower().replace(" ", "-")
|
|
for character: String in ["/", "\\", ":", "*", "?", "\"", "<", ">", "|"]:
|
|
result = result.replace(character, "")
|
|
return "straywild-save" if result.is_empty() else result
|
|
|
|
|
|
func _on_slots_changed() -> void:
|
|
if visible:
|
|
_refresh_slots()
|
|
|
|
|
|
func _on_visibility_changed() -> void:
|
|
if not visible:
|
|
_release_owned_focus()
|
|
|
|
|
|
func _release_owned_focus() -> void:
|
|
if not is_inside_tree():
|
|
return
|
|
var focus_owner: Control = get_viewport().gui_get_focus_owner()
|
|
if focus_owner != null and is_ancestor_of(focus_owner):
|
|
focus_owner.release_focus()
|