save_manager.gd

Go to the documentation of this file.

 
 
var save_path := ""
var base_save_path := ""
var current_profile := ""
var migrations := {}
var pending_state:Dictionary = {}
var pending_save:bool = false
var pending_save_timer:float = 0.0
 
 
func _init(path:String):
    save_path = path
    base_save_path = path
 
 
 
func set_path(path:String) -> void:
    save_path = path
    base_save_path = path
 
 
 
func use_profile(profile_id:String) -> void:
    current_profile = profile_id
    save_path = get_profile_path(profile_id)
 
 
 
func get_profile_path(profile_id:String) -> String:
    if profile_id == "":
        return base_save_path
    var extension_index = base_save_path.rfind(".")
    if extension_index < 0:
        return "%s_%s" % [base_save_path, profile_id]
    return "%s_%s%s" % [
        base_save_path.substr(0, extension_index),
        profile_id,
        base_save_path.substr(extension_index)
    ]
 
 
func load_state() -> Dictionary:
    var save_file = ConfigFile.new()
    var error = save_file.load(save_path)
    if error != OK:
        return {}
 
    var state = {}
    for section in save_file.get_sections():
        state[section] = {}
        for key in save_file.get_section_keys(section):
            state[section][key] = save_file.get_value(section, key)
    return migrate_state(state)
 
 
func save_state(state:Dictionary) -> void:
    pending_save = false
    pending_save_timer = 0.0
    pending_state.clear()
    var save_file = ConfigFile.new()
    if not state.has("meta"):
        state["meta"] = {}
    state["meta"]["save_version"] = int(state["meta"].get("save_version", get_latest_migration_version()))
    if current_profile != "":
        state["meta"]["profile"] = current_profile
    for section in state.keys():
        var section_values = state[section]
        if not section_values is Dictionary:
            continue
        for key in section_values.keys():
            save_file.set_value(str(section), str(key), section_values[key])
    save_file.save(save_path)
 
 
 
func queue_save_state(state:Dictionary, delay:float = 2.0) -> void:
    pending_state = state.duplicate(true)
    pending_save = true
    pending_save_timer = max(0.0, delay)
 
 
 
func step_pending_save(delta:float) -> bool:
    if not pending_save:
        return false
    pending_save_timer = max(0.0, pending_save_timer - delta)
    if pending_save_timer > 0.0:
        return false
    flush_pending_save()
    return true
 
 
 
func flush_pending_save() -> bool:
    if not pending_save:
        return false
    save_state(pending_state.duplicate(true))
    return true
 
 
 
func has_pending_save() -> bool:
    return pending_save
 
 
 
func save_section(section:String, values:Dictionary) -> void:
    var state = load_state()
    state[section] = values
    save_state(state)
 
 
 
func load_section(section:String, default_value:Dictionary = {}) -> Dictionary:
    return load_state().get(section, default_value)
 
 
 
func collect_manager_state(managers:Dictionary) -> Dictionary:
    var state := {}
    for section in managers.keys():
        var manager = managers[section]
        if manager != null and manager.has_method("get_state"):
            state[str(section)] = manager.get_state()
    return state
 
 
 
func apply_manager_state(managers:Dictionary, state:Dictionary) -> void:
    for section in managers.keys():
        var manager = managers[section]
        if manager != null and manager.has_method("apply_state"):
            manager.apply_state(state.get(str(section), {}))
 
 
 
func delete_save() -> void:
    if FileAccess.file_exists(save_path):
        DirAccess.remove_absolute(ProjectSettings.globalize_path(save_path))
 
 
 
func has_save() -> bool:
    return FileAccess.file_exists(save_path)
 
 
 
func register_migration(version:int, migration:Callable) -> void:
    migrations[version] = migration
 
 
 
func get_latest_migration_version() -> int:
    var latest := 0
    for version in migrations.keys():
        latest = max(latest, int(version))
    return latest
 
 
 
func migrate_state(state:Dictionary) -> Dictionary:
    if state.is_empty():
        return state
    var migrated = state.duplicate(true)
    if not migrated.has("meta"):
        migrated["meta"] = {}
    var current_version = int(migrated["meta"].get("save_version", 0))
    var versions = migrations.keys()
    versions.sort()
    for version in versions:
        var target_version = int(version)
        if target_version <= current_version:
            continue
        var migration = migrations[version]
        if migration.is_valid():
            migrated = migration.call(migrated)
        migrated["meta"]["save_version"] = target_version
    return migrated
 
 
 
func get_profile_summary(profile_id:String) -> Dictionary:
    var previous_path = save_path
    var previous_profile = current_profile
    use_profile(profile_id)
    var state = load_state()
    save_path = previous_path
    current_profile = previous_profile
    return state.get("meta", {}) if not state.is_empty() else {}
 
 
func get_value(state:Dictionary, section:String, key:String, default_value = null):
    if not state.has(section):
        return default_value
    return state[section].get(key, default_value)