afa4200107
Add QualityPreset enum + QualitySettings readonly record struct with From(preset) table and WithEnvOverrides() env-var override layer. Four presets (Low/Medium/High/Ultra) drive NearRadius, FarRadius, MsaaSamples, AnisotropicLevel, AlphaToCoverage, MaxCompletionsPerFrame. Env vars (ACDREAM_NEAR_RADIUS, ACDREAM_FAR_RADIUS, ACDREAM_MSAA_SAMPLES, ACDREAM_ANISOTROPIC, ACDREAM_A2C, ACDREAM_MAX_COMPLETIONS_PER_FRAME) override individual preset fields for dev spot-testing. DisplaySettings gains a Quality: QualityPreset field (default High); SettingsStore persists/loads it under display."quality" as an enum name string with Enum.TryParse fallback. 12 new QualityPresetTests cover the preset table (radii, msaa, aniso, a2c, completions) and all six env-var override paths. 415 UI.Abstractions tests passing. Wiring into GameWindow / WbDrawDispatcher / TerrainAtlas follows in commit 2 of this task. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
419 lines
18 KiB
C#
419 lines
18 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Nodes;
|
|
using AcDream.UI.Abstractions.Settings;
|
|
|
|
namespace AcDream.UI.Abstractions.Panels.Settings;
|
|
|
|
/// <summary>
|
|
/// JSON-backed persistence for non-keybind settings (Display today; future
|
|
/// tabs Audio / Gameplay / Chat / Character will be added to the same
|
|
/// file). Path: <c>%LOCALAPPDATA%\acdream\settings.json</c>. Coexists
|
|
/// with <c>keybinds.json</c>, which retains its own
|
|
/// <see cref="Input.KeyBindings.LoadOrDefault"/> path.
|
|
///
|
|
/// <para>
|
|
/// Schema (current version 1):
|
|
/// <code>
|
|
/// {
|
|
/// "version": 1,
|
|
/// "display": { "resolution": "1920x1080", "fullscreen": false, ... }
|
|
/// }
|
|
/// </code>
|
|
/// Unknown top-level keys are preserved on save so future tab additions
|
|
/// from a newer client don't get clobbered by an older client writing
|
|
/// out only the sections it knows about.
|
|
/// </para>
|
|
/// </summary>
|
|
public sealed class SettingsStore
|
|
{
|
|
private const int CurrentSchemaVersion = 1;
|
|
private readonly string _path;
|
|
|
|
public SettingsStore(string path)
|
|
{
|
|
_path = path ?? throw new ArgumentNullException(nameof(path));
|
|
}
|
|
|
|
/// <summary>Default path: <c>%LOCALAPPDATA%\acdream\settings.json</c>.</summary>
|
|
public static string DefaultPath() => Path.Combine(
|
|
Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
|
|
"acdream",
|
|
"settings.json");
|
|
|
|
/// <summary>
|
|
/// Load Display settings. Missing file → <see cref="DisplaySettings.Default"/>.
|
|
/// Missing individual keys fall back to the corresponding default
|
|
/// field, so a partial file (e.g. only <c>resolution</c> is set) is
|
|
/// non-fatal.
|
|
/// </summary>
|
|
public DisplaySettings LoadDisplay()
|
|
{
|
|
if (!File.Exists(_path)) return DisplaySettings.Default;
|
|
try
|
|
{
|
|
using var stream = File.OpenRead(_path);
|
|
var doc = JsonDocument.Parse(stream);
|
|
var root = doc.RootElement;
|
|
if (!root.TryGetProperty("display", out var disp)
|
|
|| disp.ValueKind != JsonValueKind.Object)
|
|
return DisplaySettings.Default;
|
|
|
|
var d = DisplaySettings.Default;
|
|
return new DisplaySettings(
|
|
Resolution: ReadString (disp, "resolution", d.Resolution),
|
|
Fullscreen: ReadBool (disp, "fullscreen", d.Fullscreen),
|
|
VSync: ReadBool (disp, "vsync", d.VSync),
|
|
FieldOfView: ReadFloat (disp, "fieldOfView", d.FieldOfView),
|
|
Gamma: ReadFloat (disp, "gamma", d.Gamma),
|
|
ShowFps: ReadBool (disp, "showFps", d.ShowFps),
|
|
Quality: ReadQuality (disp, "quality", d.Quality));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"settings: failed to load {_path}: {ex.Message} — using defaults");
|
|
return DisplaySettings.Default;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Save Display settings, preserving any other top-level keys the file
|
|
/// already contains (e.g. an <c>audio</c> section written by a newer
|
|
/// client). Unknown keys are round-tripped via raw JSON text so older
|
|
/// builds don't silently drop them.
|
|
/// </summary>
|
|
public void SaveDisplay(DisplaySettings display)
|
|
=> SaveSection("display", BuildDisplayObject(display));
|
|
|
|
/// <summary>
|
|
/// Load Audio settings. Same fall-back behaviour as
|
|
/// <see cref="LoadDisplay"/>: missing file → defaults, missing fields
|
|
/// → per-field defaults, corrupt JSON → defaults.
|
|
/// </summary>
|
|
public AudioSettings LoadAudio()
|
|
{
|
|
if (!File.Exists(_path)) return AudioSettings.Default;
|
|
try
|
|
{
|
|
using var stream = File.OpenRead(_path);
|
|
var doc = JsonDocument.Parse(stream);
|
|
var root = doc.RootElement;
|
|
if (!root.TryGetProperty("audio", out var audio)
|
|
|| audio.ValueKind != JsonValueKind.Object)
|
|
return AudioSettings.Default;
|
|
|
|
var d = AudioSettings.Default;
|
|
return new AudioSettings(
|
|
Master: ReadFloat(audio, "master", d.Master),
|
|
Music: ReadFloat(audio, "music", d.Music),
|
|
Sfx: ReadFloat(audio, "sfx", d.Sfx),
|
|
Ambient: ReadFloat(audio, "ambient", d.Ambient));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"settings: failed to load {_path}: {ex.Message} — using defaults");
|
|
return AudioSettings.Default;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Save Audio settings, preserving every other top-level key
|
|
/// (display, future gameplay/chat/character). Same round-trip
|
|
/// guarantee as <see cref="SaveDisplay"/>.
|
|
/// </summary>
|
|
public void SaveAudio(AudioSettings audio)
|
|
=> SaveSection("audio", BuildAudioObject(audio));
|
|
|
|
/// <summary>
|
|
/// Load Gameplay settings (subset of retail CharacterOption flags).
|
|
/// Same fall-back behaviour as <see cref="LoadDisplay"/>.
|
|
/// </summary>
|
|
public GameplaySettings LoadGameplay()
|
|
{
|
|
if (!File.Exists(_path)) return GameplaySettings.Default;
|
|
try
|
|
{
|
|
using var stream = File.OpenRead(_path);
|
|
var doc = JsonDocument.Parse(stream);
|
|
var root = doc.RootElement;
|
|
if (!root.TryGetProperty("gameplay", out var gp)
|
|
|| gp.ValueKind != JsonValueKind.Object)
|
|
return GameplaySettings.Default;
|
|
|
|
var d = GameplaySettings.Default;
|
|
return new GameplaySettings(
|
|
AutoTarget: ReadBool(gp, "autoTarget", d.AutoTarget),
|
|
AutoRepeatAttack: ReadBool(gp, "autoRepeatAttack", d.AutoRepeatAttack),
|
|
ToggleRun: ReadBool(gp, "toggleRun", d.ToggleRun),
|
|
AdvancedCombatUI: ReadBool(gp, "advancedCombatUI", d.AdvancedCombatUI),
|
|
ShowTooltips: ReadBool(gp, "showTooltips", d.ShowTooltips),
|
|
VividTargetingIndicator: ReadBool(gp, "vividTargetingIndicator", d.VividTargetingIndicator),
|
|
SideBySideVitals: ReadBool(gp, "sideBySideVitals", d.SideBySideVitals),
|
|
CoordinatesOnRadar: ReadBool(gp, "coordinatesOnRadar", d.CoordinatesOnRadar),
|
|
SpellDuration: ReadBool(gp, "spellDuration", d.SpellDuration),
|
|
AllowGive: ReadBool(gp, "allowGive", d.AllowGive),
|
|
ShowHelm: ReadBool(gp, "showHelm", d.ShowHelm),
|
|
ShowCloak: ReadBool(gp, "showCloak", d.ShowCloak),
|
|
LockUI: ReadBool(gp, "lockUI", d.LockUI),
|
|
UseMouseTurning: ReadBool(gp, "useMouseTurning", d.UseMouseTurning));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"settings: failed to load {_path}: {ex.Message} — using defaults");
|
|
return GameplaySettings.Default;
|
|
}
|
|
}
|
|
|
|
/// <summary>Save Gameplay settings, preserving all other top-level keys.</summary>
|
|
public void SaveGameplay(GameplaySettings gameplay)
|
|
=> SaveSection("gameplay", BuildGameplayObject(gameplay));
|
|
|
|
/// <summary>Load Chat settings. Same fall-back behaviour as <see cref="LoadDisplay"/>.</summary>
|
|
public ChatSettings LoadChat()
|
|
{
|
|
if (!File.Exists(_path)) return ChatSettings.Default;
|
|
try
|
|
{
|
|
using var stream = File.OpenRead(_path);
|
|
var doc = JsonDocument.Parse(stream);
|
|
var root = doc.RootElement;
|
|
if (!root.TryGetProperty("chat", out var chat)
|
|
|| chat.ValueKind != JsonValueKind.Object)
|
|
return ChatSettings.Default;
|
|
|
|
var d = ChatSettings.Default;
|
|
return new ChatSettings(
|
|
HearGeneralChat: ReadBool (chat, "hearGeneralChat", d.HearGeneralChat),
|
|
HearTradeChat: ReadBool (chat, "hearTradeChat", d.HearTradeChat),
|
|
HearLFGChat: ReadBool (chat, "hearLFGChat", d.HearLFGChat),
|
|
HearRoleplayChat: ReadBool (chat, "hearRoleplayChat", d.HearRoleplayChat),
|
|
HearSocietyChat: ReadBool (chat, "hearSocietyChat", d.HearSocietyChat),
|
|
AppearOffline: ReadBool (chat, "appearOffline", d.AppearOffline),
|
|
ShowTimestamps: ReadBool (chat, "showTimestamps", d.ShowTimestamps),
|
|
FilterProfanity: ReadBool (chat, "filterProfanity", d.FilterProfanity),
|
|
FontSize: ReadFloat(chat, "fontSize", d.FontSize));
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"settings: failed to load {_path}: {ex.Message} — using defaults");
|
|
return ChatSettings.Default;
|
|
}
|
|
}
|
|
|
|
/// <summary>Save Chat settings, preserving all other top-level keys.</summary>
|
|
public void SaveChat(ChatSettings chat)
|
|
=> SaveSection("chat", BuildChatObject(chat));
|
|
|
|
/// <summary>
|
|
/// Load per-character settings keyed by <paramref name="toonKey"/>.
|
|
/// Missing file or missing toon entry → <see cref="CharacterSettings.Default"/>.
|
|
/// </summary>
|
|
public CharacterSettings LoadCharacter(string toonKey)
|
|
{
|
|
if (toonKey is null) throw new ArgumentNullException(nameof(toonKey));
|
|
if (!File.Exists(_path)) return CharacterSettings.Default;
|
|
try
|
|
{
|
|
var root = JsonNode.Parse(File.ReadAllText(_path)) as JsonObject;
|
|
var toon = root?["character"]?[toonKey] as JsonObject;
|
|
if (toon is null) return CharacterSettings.Default;
|
|
|
|
var d = CharacterSettings.Default;
|
|
return new CharacterSettings(
|
|
DefaultChatChannel: toon["defaultChatChannel"]?.GetValue<string>() ?? d.DefaultChatChannel,
|
|
AutoAttack: toon["autoAttack"]?.GetValue<bool>() ?? d.AutoAttack,
|
|
ConfirmSalvage: toon["confirmSalvage"]?.GetValue<bool>() ?? d.ConfirmSalvage,
|
|
ShowPickupMessages: toon["showPickupMessages"]?.GetValue<bool>() ?? d.ShowPickupMessages);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine($"settings: failed to load {_path}: {ex.Message} — using defaults");
|
|
return CharacterSettings.Default;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Save per-character settings under <paramref name="toonKey"/>.
|
|
/// Preserves every other toon's settings + every other top-level
|
|
/// section. Uses <see cref="JsonNode"/> rather than the raw-text
|
|
/// preservation pattern of <see cref="SaveSection"/> because the
|
|
/// per-toon write needs to mutate a nested map, not just replace a
|
|
/// top-level key.
|
|
/// </summary>
|
|
public void SaveCharacter(string toonKey, CharacterSettings settings)
|
|
{
|
|
if (toonKey is null) throw new ArgumentNullException(nameof(toonKey));
|
|
if (settings is null) throw new ArgumentNullException(nameof(settings));
|
|
|
|
var dir = Path.GetDirectoryName(_path);
|
|
if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir);
|
|
|
|
// Read existing file as a mutable JsonObject (or start fresh).
|
|
JsonObject root;
|
|
if (File.Exists(_path))
|
|
{
|
|
try
|
|
{
|
|
root = JsonNode.Parse(File.ReadAllText(_path)) as JsonObject ?? new JsonObject();
|
|
}
|
|
catch
|
|
{
|
|
root = new JsonObject();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
root = new JsonObject();
|
|
}
|
|
|
|
// Build the toon's payload.
|
|
var toonObj = new JsonObject
|
|
{
|
|
["autoAttack"] = settings.AutoAttack,
|
|
["confirmSalvage"] = settings.ConfirmSalvage,
|
|
["defaultChatChannel"] = settings.DefaultChatChannel,
|
|
["showPickupMessages"] = settings.ShowPickupMessages,
|
|
};
|
|
|
|
// Slot it under character[toonKey], creating the character map if
|
|
// necessary. Other toons in the map are preserved.
|
|
if (root["character"] is not JsonObject characterMap)
|
|
{
|
|
characterMap = new JsonObject();
|
|
root["character"] = characterMap;
|
|
}
|
|
characterMap[toonKey] = toonObj;
|
|
root["version"] = CurrentSchemaVersion;
|
|
|
|
File.WriteAllText(_path, root.ToJsonString(new JsonSerializerOptions { WriteIndented = true }));
|
|
}
|
|
|
|
private static SortedDictionary<string, object> BuildChatObject(ChatSettings c)
|
|
=> new(StringComparer.Ordinal)
|
|
{
|
|
["appearOffline"] = c.AppearOffline,
|
|
["filterProfanity"] = c.FilterProfanity,
|
|
["fontSize"] = c.FontSize,
|
|
["hearGeneralChat"] = c.HearGeneralChat,
|
|
["hearLFGChat"] = c.HearLFGChat,
|
|
["hearRoleplayChat"] = c.HearRoleplayChat,
|
|
["hearSocietyChat"] = c.HearSocietyChat,
|
|
["hearTradeChat"] = c.HearTradeChat,
|
|
["showTimestamps"] = c.ShowTimestamps,
|
|
};
|
|
|
|
private static SortedDictionary<string, object> BuildGameplayObject(GameplaySettings g)
|
|
=> new(StringComparer.Ordinal)
|
|
{
|
|
["advancedCombatUI"] = g.AdvancedCombatUI,
|
|
["allowGive"] = g.AllowGive,
|
|
["autoRepeatAttack"] = g.AutoRepeatAttack,
|
|
["autoTarget"] = g.AutoTarget,
|
|
["coordinatesOnRadar"] = g.CoordinatesOnRadar,
|
|
["lockUI"] = g.LockUI,
|
|
["showCloak"] = g.ShowCloak,
|
|
["showHelm"] = g.ShowHelm,
|
|
["showTooltips"] = g.ShowTooltips,
|
|
["sideBySideVitals"] = g.SideBySideVitals,
|
|
["spellDuration"] = g.SpellDuration,
|
|
["toggleRun"] = g.ToggleRun,
|
|
["useMouseTurning"] = g.UseMouseTurning,
|
|
["vividTargetingIndicator"] = g.VividTargetingIndicator,
|
|
};
|
|
|
|
private static SortedDictionary<string, object> BuildDisplayObject(DisplaySettings d)
|
|
=> new(StringComparer.Ordinal)
|
|
{
|
|
["fieldOfView"] = d.FieldOfView,
|
|
["fullscreen"] = d.Fullscreen,
|
|
["gamma"] = d.Gamma,
|
|
["quality"] = d.Quality.ToString(),
|
|
["resolution"] = d.Resolution,
|
|
["showFps"] = d.ShowFps,
|
|
["vsync"] = d.VSync,
|
|
};
|
|
|
|
private static SortedDictionary<string, object> BuildAudioObject(AudioSettings a)
|
|
=> new(StringComparer.Ordinal)
|
|
{
|
|
["ambient"] = a.Ambient,
|
|
["master"] = a.Master,
|
|
["music"] = a.Music,
|
|
["sfx"] = a.Sfx,
|
|
};
|
|
|
|
/// <summary>
|
|
/// Generic atomic-section save: writes the named section and preserves
|
|
/// all other top-level keys from the existing file, replacing only the
|
|
/// version + the targeted section. Avoids duplication between the
|
|
/// per-section Save methods.
|
|
/// </summary>
|
|
private void SaveSection(string sectionName, SortedDictionary<string, object> sectionPayload)
|
|
{
|
|
var dir = Path.GetDirectoryName(_path);
|
|
if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir);
|
|
|
|
// Preserve any non-target top-level keys from the existing file.
|
|
var preservedKeys = new SortedDictionary<string, string>(StringComparer.Ordinal);
|
|
if (File.Exists(_path))
|
|
{
|
|
try
|
|
{
|
|
using var stream = File.OpenRead(_path);
|
|
var doc = JsonDocument.Parse(stream);
|
|
foreach (var prop in doc.RootElement.EnumerateObject())
|
|
{
|
|
if (prop.Name == sectionName || prop.Name == "version") continue;
|
|
preservedKeys[prop.Name] = prop.Value.GetRawText();
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
// Corrupt file → fully overwrite; previous content is lost
|
|
// but the user's session continues with the new save.
|
|
preservedKeys.Clear();
|
|
}
|
|
}
|
|
|
|
var sb = new System.Text.StringBuilder();
|
|
sb.Append('{').AppendLine();
|
|
// Preserved keys come first (sorted by name) then the section, then
|
|
// version last. Preserves alphabetical-style top-level ordering.
|
|
foreach (var kv in preservedKeys)
|
|
{
|
|
sb.Append(" \"").Append(kv.Key).Append("\": ")
|
|
.Append(kv.Value).Append(',').AppendLine();
|
|
}
|
|
sb.Append(" \"").Append(sectionName).Append("\": ")
|
|
.Append(JsonSerializer.Serialize(sectionPayload, new JsonSerializerOptions { WriteIndented = true })
|
|
.Replace("\n", "\n "))
|
|
.Append(',').AppendLine();
|
|
sb.Append(" \"version\": ").Append(CurrentSchemaVersion).AppendLine();
|
|
sb.Append('}').AppendLine();
|
|
|
|
File.WriteAllText(_path, sb.ToString());
|
|
}
|
|
|
|
private static string ReadString(JsonElement obj, string name, string fallback)
|
|
=> obj.TryGetProperty(name, out var el) && el.ValueKind == JsonValueKind.String
|
|
? (el.GetString() ?? fallback) : fallback;
|
|
|
|
private static bool ReadBool(JsonElement obj, string name, bool fallback)
|
|
=> obj.TryGetProperty(name, out var el)
|
|
&& (el.ValueKind == JsonValueKind.True || el.ValueKind == JsonValueKind.False)
|
|
? el.GetBoolean() : fallback;
|
|
|
|
private static float ReadFloat(JsonElement obj, string name, float fallback)
|
|
=> obj.TryGetProperty(name, out var el) && el.ValueKind == JsonValueKind.Number
|
|
? el.GetSingle() : fallback;
|
|
|
|
private static QualityPreset ReadQuality(JsonElement obj, string name, QualityPreset fallback)
|
|
{
|
|
if (!obj.TryGetProperty(name, out var el) || el.ValueKind != JsonValueKind.String)
|
|
return fallback;
|
|
var s = el.GetString();
|
|
return Enum.TryParse<QualityPreset>(s, ignoreCase: true, out var v) ? v : fallback;
|
|
}
|
|
}
|