seeding-planets/common/game_info/game_info.gd

extends Node

const SAVE_NAME = "game"

const SAVE_STORY_GAME_LOCATION = "user://stw_%s_save.tres" % SAVE_NAME
const SAVE_INFINTE_GAME_LOCATION = "user://stw_%s_infinite_save.tres" % SAVE_NAME
const SAVE_SETTINGS_LOCATION = "user://stw_settings.tres"

signal game_loaded

var game_mode_choosen := GameData.Mode.STORY

var game_data : GameData :
    get():
        if game_mode_choosen == GameData.Mode.STORY:
            return story_game_data
        elif game_mode_choosen == GameData.Mode.INFINITE:
            return infinite_game_data
        return null

var story_game_data : GameData
var infinite_game_data : GameData

var settings_data : SettingsData

var current_dialog_path : String

func load_story_game_data() -> GameData:
    story_game_data = null
    if ResourceLoader.exists(SAVE_STORY_GAME_LOCATION) and ResourceLoader.load(SAVE_STORY_GAME_LOCATION):
        story_game_data = ResourceLoader.load(SAVE_STORY_GAME_LOCATION).duplicate_deep()
        game_loaded.emit()

    return story_game_data

func load_infinite_game_data() -> GameData:
    infinite_game_data = null
    if ResourceLoader.exists(SAVE_INFINTE_GAME_LOCATION) and ResourceLoader.load(SAVE_INFINTE_GAME_LOCATION):
        infinite_game_data = ResourceLoader.load(SAVE_INFINTE_GAME_LOCATION).duplicate_deep()

    return infinite_game_data

func start_game_data():
    if game_mode_choosen == GameData.Mode.STORY:
        story_game_data = GameData.new(GameData.Mode.STORY)
        story_game_data.start_run()
    else:
        infinite_game_data = GameData.new(GameData.Mode.INFINITE)
        infinite_game_data.start_run()

    save_game_data()

func save_game_data():
    if game_mode_choosen == GameData.Mode.STORY:
        if story_game_data:
            ResourceSaver.save(story_game_data, SAVE_STORY_GAME_LOCATION)
    elif game_mode_choosen == GameData.Mode.INFINITE:
        if infinite_game_data:
            ResourceSaver.save(infinite_game_data, SAVE_INFINTE_GAME_LOCATION)

func load_settings_data() -> SettingsData:
    if ResourceLoader.exists(SAVE_SETTINGS_LOCATION):
        settings_data = ResourceLoader.load(SAVE_SETTINGS_LOCATION).duplicate_deep()
    else :
        settings_data = SettingsData.new()
        save_settings()

    return settings_data

func save_settings():
    if settings_data:
        ResourceSaver.save(settings_data, SAVE_SETTINGS_LOCATION)

func _init():
    load_story_game_data()
    load_infinite_game_data()
    load_settings_data()
    update_language_settings()
    update_video_settings()
    update_sound_settings(settings_data)
    settings_data.language_changed.connect(_on_settings_language_changed)
    settings_data.video_changed.connect(_on_settings_video_changed)
    settings_data.sound_changed.connect(_on_settings_sound_changed)

func _ready():
    Dialogic.timeline_started.connect(_on_timeline_started)
    Dialogic.timeline_ended.connect(_on_timeline_ended)
    if settings_data.window_mode == DisplayServer.WINDOW_MODE_WINDOWED:
        var window:= get_tree().root.get_window()
        window.size = settings_data.window_size
        window.position = settings_data.window_pos

func _on_settings_video_changed(s : SettingsData):
    update_video_settings(s)

func _on_settings_language_changed(s : SettingsData):
    update_language_settings(s)

func _on_settings_sound_changed(s : SettingsData):
    update_sound_settings(s)

func _on_timeline_started():
    current_dialog_path = Dialogic.current_timeline.resource_path

func _on_timeline_ended():
    if not current_dialog_path in game_data.dialogs_done:
        game_data.dialogs_done.append(current_dialog_path)
        save_game_data()

func update_sound_settings(s: SettingsData):
    AudioServer.set_bus_volume_db(SettingsData.MASTER_BUS_ID, linear_to_db(s.master_volume))
    AudioServer.set_bus_volume_db(SettingsData.MUSIC_BUS_ID, linear_to_db(s.music_volume))
    AudioServer.set_bus_volume_db(SettingsData.SFX_BUS_ID, linear_to_db(s.sfx_volume))
    AudioServer.set_bus_volume_db(SettingsData.AMBIANCE_BUS_ID, linear_to_db(s.ambiance_volume))

func update_language_settings(s : SettingsData = settings_data):
    TranslationServer.set_locale(s.language)

func update_video_settings(s : SettingsData = settings_data):
    DisplayServer.window_set_mode(s.window_mode)
    if not is_node_ready():
        await ready
    get_tree().root.content_scale_factor = s.ui_size
    

func update_inputs(s : SettingsData = settings_data):
    for i in range(len(s.input_remapped)):
        InputMap.action_erase_events(s.action_remapped[i])
        InputMap.action_add_event(s.action_remapped[i], s.input_remapped[i])
    
func has_unlocked_infinite_mode():
    return true

func get_action_key_name(action_name: String) -> String:
    var events: Array[InputEvent] = InputMap.action_get_events(action_name)

    var saved_remapped_input = null
    var existing_remapped_id: int = GameInfo.settings_data.action_remapped.find(action_name)
    if existing_remapped_id != -1:
        saved_remapped_input = GameInfo.settings_data.input_remapped[existing_remapped_id]
    
    var event: InputEvent = null
    if saved_remapped_input:
        event = saved_remapped_input
    else:
        event = null if events.size() == 0 else events[0]
    
    var input_name: String = "UNASSIGNED" if event == null else event.as_text()
    if event is InputEventKey:
        var keycode = DisplayServer.keyboard_get_keycode_from_physical(event.physical_keycode)
        input_name = OS.get_keycode_string(keycode)
    
    return input_name