settings_manager.gd

Go to the documentation of this file.

extends Node
 
 
 
const SETTINGS_PATH := "user://settings.cfg"
const SETTINGS_SCHEMA_VERSION := 5
const LEGACY_DEFAULT_MUSIC_VOLUME := 0.7
const PREVIOUS_DEFAULT_MUSIC_VOLUME := 0.4
const CURRENT_DEFAULT_MUSIC_VOLUME := 0.2
const THEME_CATALOG_PATH := "res://data/themes/default.json"
const CUSTOM_THEME_CATALOG_PATH := "user://custom_themes.json"
const LOW_POWER_PRESET_PATH := "res://data/system/low_power_presets.json"
const WINDOW_SIZE_OPTIONS := {
    "Phone 390 x 844": Vector2i(390, 844),
    "Small 480 x 800": Vector2i(480, 800),
    "Square 800 x 800": Vector2i(800, 800),
    "Desktop 1280 x 720": Vector2i(1280, 720)
}
const TEXT_SIZE_OPTIONS := {
    "Small": "small",
    "Medium": "medium",
    "Large": "large"
}
const DEFAULT_THEME_OPTIONS := {
    "Dark": "dark",
    "High Contrast": "high_contrast"
}
const TEXT_SIZE_PRESETS := {
    "small": {"body": 15, "caption": 13, "button": 16, "title": 25, "list": 15},
    "medium": {"body": 17, "caption": 15, "button": 18, "title": 31, "list": 17},
    "large": {"body": 21, "caption": 18, "button": 22, "title": 37, "list": 21}
}
 
signal settings_changed(settings:Dictionary)
 
var settings := {
    "window_size": Vector2i(800, 800),
    "fullscreen": false,
    "master_volume": 0.85,
    "music_volume": CURRENT_DEFAULT_MUSIC_VOLUME,
    "sfx_volume": 0.85,
    "master_muted": false,
    "music_muted": false,
    "sfx_muted": false,
    "theme": "dark",
    "text_size": "medium",
    "low_power_mode": false,
    "input_remaps": {},
    "input_mode": "touch"
}
const INPUT_MODE_OPTIONS := {
    "Auto": "auto",
    "Touch / Analog": "touch",
    "Keyboard / WASD": "keyboard",
    "Controller": "controller"
}
var theme_options := DEFAULT_THEME_OPTIONS.duplicate(true)
var theme_typography := {}
var low_power_profiles := {}
var font_cache := {}
 
 
func _ready() -> void:
    load_theme_options()
    load_low_power_profiles()
    load_settings()
    apply_window_settings()
 
 
 
func load_settings() -> void:
    var file = ConfigFile.new()
    if file.load(SETTINGS_PATH) != OK:
        return
    settings["window_size"] = file.get_value("display", "window_size", settings["window_size"])
    settings["fullscreen"] = bool(file.get_value("display", "fullscreen", settings["fullscreen"]))
    settings["theme"] = str(file.get_value("display", "theme", settings["theme"]))
    if not theme_options.values().has(settings["theme"]):
        settings["theme"] = "dark"
    settings["text_size"] = str(file.get_value("display", "text_size", settings["text_size"]))
    settings["low_power_mode"] = bool(file.get_value("display", "low_power_mode", settings["low_power_mode"]))
    settings["master_volume"] = float(file.get_value("audio", "master_volume", settings["master_volume"]))
    settings["music_volume"] = float(file.get_value("audio", "music_volume", settings["music_volume"]))
    settings["sfx_volume"] = float(file.get_value("audio", "sfx_volume", settings["sfx_volume"]))
    settings["master_muted"] = bool(file.get_value("audio", "master_muted", settings["master_muted"]))
    settings["music_muted"] = bool(file.get_value("audio", "music_muted", settings["music_muted"]))
    settings["sfx_muted"] = bool(file.get_value("audio", "sfx_muted", settings["sfx_muted"]))
    settings["input_remaps"] = file.get_value("input", "remaps", settings["input_remaps"])
    settings["input_mode"] = str(file.get_value("input", "mode", settings["input_mode"]))
    if not INPUT_MODE_OPTIONS.values().has(settings["input_mode"]):
        settings["input_mode"] = "touch"
    if _migrate_loaded_settings(file):
        save_settings()
 
 
 
func save_settings() -> void:
    var file = ConfigFile.new()
    file.set_value("meta", "settings_version", SETTINGS_SCHEMA_VERSION)
    file.set_value("display", "window_size", settings["window_size"])
    file.set_value("display", "fullscreen", settings["fullscreen"])
    file.set_value("display", "theme", settings["theme"])
    file.set_value("display", "text_size", settings["text_size"])
    file.set_value("display", "low_power_mode", settings["low_power_mode"])
    file.set_value("audio", "master_volume", settings["master_volume"])
    file.set_value("audio", "music_volume", settings["music_volume"])
    file.set_value("audio", "sfx_volume", settings["sfx_volume"])
    file.set_value("audio", "master_muted", settings["master_muted"])
    file.set_value("audio", "music_muted", settings["music_muted"])
    file.set_value("audio", "sfx_muted", settings["sfx_muted"])
    file.set_value("input", "remaps", settings["input_remaps"])
    file.set_value("input", "mode", settings["input_mode"])
    file.save(SETTINGS_PATH)
 
 
 
func _migrate_loaded_settings(file:ConfigFile) -> bool:
    var loaded_version:int = int(file.get_value("meta", "settings_version", 1))
    if loaded_version >= SETTINGS_SCHEMA_VERSION:
        return false
    var changed := true
    var has_music_volume:bool = file.has_section_key("audio", "music_volume")
    if loaded_version < 2 and has_music_volume:
        var loaded_music_volume:float = float(file.get_value("audio", "music_volume", LEGACY_DEFAULT_MUSIC_VOLUME))
        if absf(loaded_music_volume - LEGACY_DEFAULT_MUSIC_VOLUME) <= 0.001:
            settings["music_volume"] = CURRENT_DEFAULT_MUSIC_VOLUME
    if loaded_version < 3 and has_music_volume:
        var loaded_music_volume:float = float(file.get_value("audio", "music_volume", PREVIOUS_DEFAULT_MUSIC_VOLUME))
        if absf(loaded_music_volume - PREVIOUS_DEFAULT_MUSIC_VOLUME) <= 0.001:
            settings["music_volume"] = CURRENT_DEFAULT_MUSIC_VOLUME
    if loaded_version < 5 and str(settings.get("input_mode", "auto")) == "auto":
        settings["input_mode"] = "touch"
    return changed
 
 
 
func get_settings() -> Dictionary:
    return settings.duplicate(true)
 
 
 
func get_window_size_options() -> Dictionary:
    return WINDOW_SIZE_OPTIONS.duplicate(true)
 
 
 
func get_text_size_options() -> Dictionary:
    return TEXT_SIZE_OPTIONS.duplicate(true)
 
 
 
func get_input_mode_options() -> Dictionary:
    return INPUT_MODE_OPTIONS.duplicate(true)
 
 
 
func get_theme_options() -> Dictionary:
    if theme_options.is_empty():
        load_theme_options()
    return theme_options.duplicate(true)
 
 
 
func load_low_power_profiles(file_path:String = LOW_POWER_PRESET_PATH) -> void:
    var loaded_profiles := {}
    var file = FileAccess.open(file_path, FileAccess.READ)
    if file != null:
        var data = JSON.parse_string(file.get_as_text())
        if data is Dictionary and data.get("profiles", {}) is Dictionary:
            for profile_id in data.get("profiles", {}).keys():
                var profile = data.get("profiles", {}).get(profile_id)
                if profile is Dictionary:
                    loaded_profiles[str(profile_id)] = profile.duplicate(true)
    if loaded_profiles.is_empty():
        loaded_profiles["default"] = _default_low_power_profile()
    low_power_profiles = loaded_profiles
 
 
 
func get_low_power_profile(profile_id:String = "default") -> Dictionary:
    if low_power_profiles.is_empty():
        load_low_power_profiles()
    var profile:Dictionary = low_power_profiles.get(profile_id, low_power_profiles.get("default", _default_low_power_profile())) as Dictionary
    return profile.duplicate(true)
 
 
 
func load_theme_options(file_path:String = THEME_CATALOG_PATH) -> void:
    var loaded := {}
    var typography_defaults := _default_typography()
    var loaded_typography := {}
    for catalog_path in _theme_catalog_paths(file_path):
        var file = FileAccess.open(catalog_path, FileAccess.READ)
        if file == null:
            continue
        var data = JSON.parse_string(file.get_as_text())
        if data is Dictionary:
            if data.get("typography", {}) is Dictionary:
                typography_defaults = _merge_dict(typography_defaults, data.get("typography", {}))
            var themes = data.get("themes", {})
            if themes is Dictionary:
                for theme_id in themes.keys():
                    var definition = themes[theme_id]
                    var label := str(theme_id).capitalize()
                    if definition is Dictionary:
                        label = str(definition.get("name", label))
                        var theme_typography_definition = definition.get("typography", {})
                        if theme_typography_definition is Dictionary:
                            loaded_typography[str(theme_id)] = _merge_dict(typography_defaults, theme_typography_definition)
                    loaded[label] = str(theme_id)
    if loaded.is_empty():
        loaded = DEFAULT_THEME_OPTIONS.duplicate(true)
    theme_options = loaded
    for theme_id in theme_options.values():
        if not loaded_typography.has(theme_id):
            loaded_typography[theme_id] = typography_defaults.duplicate(true)
    theme_typography = loaded_typography
 
 
func _theme_catalog_paths(primary_path:String) -> Array:
    var paths := [primary_path]
    if primary_path == THEME_CATALOG_PATH and FileAccess.file_exists(CUSTOM_THEME_CATALOG_PATH):
        paths.append(CUSTOM_THEME_CATALOG_PATH)
    return paths
 
 
 
func get_text_size_preset(size_id:String = "") -> Dictionary:
    var resolved_id = str(settings["text_size"]) if size_id == "" else size_id
    var theme_id := str(settings.get("theme", "dark"))
    return get_theme_text_size_preset(theme_id, resolved_id)
 
 
 
func get_theme_text_size_preset(theme_id:String = "", size_id:String = "") -> Dictionary:
    if theme_typography.is_empty():
        load_theme_options()
    var resolved_theme := str(settings.get("theme", "dark")) if theme_id == "" else theme_id
    var resolved_size := str(settings.get("text_size", "medium")) if size_id == "" else size_id
    var typography = theme_typography.get(resolved_theme, _default_typography())
    var base_sizes:Dictionary = typography.get("base_sizes", TEXT_SIZE_PRESETS["medium"])
    var scale_presets:Dictionary = typography.get("scale_presets", {"small": 0.88, "medium": 1.0, "large": 1.22})
    var scale := float(scale_presets.get(resolved_size, 1.0))
    var preset := {}
    for key in TEXT_SIZE_PRESETS["medium"].keys():
        preset[key] = max(1, int(round(float(base_sizes.get(key, TEXT_SIZE_PRESETS["medium"][key])) * scale)))
    preset["button_height_multiplier"] = float(typography.get("button_height_multiplier", 2.4))
    preset["font_paths"] = typography.get("font_paths", {})
    return preset
 
 
 
func set_window_size(value:Vector2i) -> void:
    settings["window_size"] = value
    apply_window_settings()
    _commit()
 
 
func set_window_size_by_label(label:String) -> void:
    if not WINDOW_SIZE_OPTIONS.has(label):
        return
    set_window_size(WINDOW_SIZE_OPTIONS[label])
 
 
 
func set_fullscreen(value:bool) -> void:
    settings["fullscreen"] = value
    apply_window_settings()
    _commit()
 
 
 
func set_text_size(value:String) -> void:
    if not TEXT_SIZE_PRESETS.has(value):
        return
    settings["text_size"] = value
    _commit()
 
 
func set_text_size_by_label(label:String) -> void:
    if not TEXT_SIZE_OPTIONS.has(label):
        return
    set_text_size(TEXT_SIZE_OPTIONS[label])
 
 
 
func set_theme(value:String) -> void:
    if not get_theme_options().values().has(value):
        return
    settings["theme"] = value
    _commit()
 
 
func set_theme_by_label(label:String) -> void:
    var options = get_theme_options()
    if not options.has(label):
        return
    set_theme(options[label])
 
 
 
func set_low_power_mode(value:bool) -> void:
    settings["low_power_mode"] = value
    _commit()
 
 
 
func is_low_power_mode() -> bool:
    return bool(settings.get("low_power_mode", false))
 
 
 
func set_audio_value(key:String, value) -> void:
    if not settings.has(key):
        return
    settings[key] = value
    _commit()
 
 
 
func set_input_remaps(value:Dictionary) -> void:
    settings["input_remaps"] = value.duplicate(true)
    _commit()
 
 
 
func get_input_remaps() -> Dictionary:
    return settings.get("input_remaps", {}).duplicate(true)
 
 
 
func apply_text_size(root:Node) -> void:
    if root == null:
        return
    var preset = get_text_size_preset()
    _apply_text_size_recursive(root, preset)
 
 
func apply_window_settings() -> void:
    if bool(settings["fullscreen"]):
        DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_FULLSCREEN)
    else:
        DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
        DisplayServer.window_set_size(settings["window_size"])
 
 
func _commit() -> void:
    save_settings()
    settings_changed.emit(get_settings())
 
 
 
func set_input_mode(value:String) -> void:
    var normalized := value if INPUT_MODE_OPTIONS.values().has(value) else "touch"
    if str(settings.get("input_mode", "touch")) == normalized:
        return
    settings["input_mode"] = normalized
    save_settings()
    settings_changed.emit(get_settings())
 
 
func _apply_text_size_recursive(node:Node, preset:Dictionary) -> void:
    if node == null:
        return
    if node is Label:
        var node_name = str(node.name).to_lower()
        var size_key = "body"
        if node_name.contains("title"):
            size_key = "title"
        elif node_name.contains("description") or node_name.contains("info") or node_name.contains("subtitle") or node_name.contains("status") or node_name.contains("details") or node_name.contains("preview"):
            size_key = "caption"
        var font_role:String = size_key
        var font_size := int(preset[size_key])
        if node.has_meta("max_font_size"):
            font_size = min(font_size, int(node.get_meta("max_font_size")))
        if node.has_meta("text_size_role"):
            var role := str(node.get_meta("text_size_role"))
            if preset.has(role):
                font_role = role
                font_size = int(preset[role])
                if node.has_meta("max_font_size"):
                    font_size = min(font_size, int(node.get_meta("max_font_size")))
        node.add_theme_font_size_override("font_size", font_size)
        _apply_font_override(node, preset, font_role)
    if node is Button or node is OptionButton or node is CheckButton:
        var button_font_size := int(preset["button"])
        if node.has_meta("max_font_size"):
            button_font_size = min(button_font_size, int(node.get_meta("max_font_size")))
        node.add_theme_font_size_override("font_size", button_font_size)
        _apply_font_override(node, preset, "button")
        if node is Button:
            node.custom_minimum_size.y = max(float(node.custom_minimum_size.y), float(button_font_size) * float(preset.get("button_height_multiplier", 2.4)))
    if node is AcceptDialog:
        node.add_theme_font_size_override("font_size", int(preset["body"]))
        if node.get_ok_button() != null:
            node.get_ok_button().add_theme_font_size_override("font_size", int(preset["button"]))
            node.get_ok_button().custom_minimum_size.y = max(float(node.get_ok_button().custom_minimum_size.y), float(preset["button"]) * 2.4)
        if node.get_cancel_button() != null:
            node.get_cancel_button().add_theme_font_size_override("font_size", int(preset["button"]))
            node.get_cancel_button().custom_minimum_size.y = max(float(node.get_cancel_button().custom_minimum_size.y), float(preset["button"]) * 2.4)
    if node is ItemList:
        node.add_theme_font_size_override("font_size", int(preset["list"]))
    if node is RichTextLabel:
        node.add_theme_font_size_override("normal_font_size", int(preset["body"]))
    for child in node.get_children():
        _apply_text_size_recursive(child, preset)
 
 
func _apply_font_override(node:Control, preset:Dictionary, role:String) -> void:
    var font_paths = preset.get("font_paths", {})
    if not font_paths is Dictionary:
        return
    var path := str(font_paths.get(role, font_paths.get("default", "")))
    if path == "":
        return
    if not ResourceLoader.exists(path):
        return
    var font = font_cache.get(path)
    if font == null:
        font = load(path)
        font_cache[path] = font
    if font != null:
        node.add_theme_font_override("font", font)
 
 
func _default_typography() -> Dictionary:
    return {
        "font_paths": {"default": "", "title": "", "button": "", "mono": ""},
        "base_sizes": TEXT_SIZE_PRESETS["medium"].duplicate(true),
        "scale_presets": {"small": 0.88, "medium": 1.0, "large": 1.22},
        "button_height_multiplier": 2.4
    }
 
 
func _default_low_power_profile() -> Dictionary:
    return {
        "audio": {"queue_next_music_track": false},
        "arcade": {
            "max_field_powerups": 1,
            "powerup_spawn_pace_multiplier": 0.55,
            "minimum_powerup_spawn_pace": 0.25,
            "powerup_lifetime": 8.0,
            "held_powerup_icon_size": 22,
            "show_active_effect_text": false
        },
        "visuals": {
            "prefer_static_effects": true,
            "background_animation_rate": 0.0,
            "decorative_effect_limit": 0
        },
        "cache": {
            "warm_optional_screens": false,
            "preserve_source_images": true
        }
    }
 
 
func _merge_dict(base:Dictionary, override:Dictionary) -> Dictionary:
    var merged := base.duplicate(true)
    for key in override.keys():
        if merged.get(key) is Dictionary and override[key] is Dictionary:
            merged[key] = _merge_dict(merged[key], override[key])
        else:
            merged[key] = override[key]
    return merged