Files
GameLauncher/Services/Codecs/Es3/Es3SaveDocument.cs
T

892 lines
32 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
namespace GameLauncher.Services.Codecs.Es3
{
/// <summary>
/// ES3 のシリアライズ要素が持つ「型」の種別。
/// ES3 は <c>{ "__type": "System.Int32", "value": 42 }</c> 形式で値を格納するため、
/// この列挙子で GUI 側へ型情報を伝えます。
/// </summary>
public enum Es3ValueKind
{
/// <summary>不明・未判定。</summary>
Unknown,
/// <summary>真偽値。</summary>
Boolean,
/// <summary>整数(Int32 / Int64 / UInt32 等)。</summary>
Integer,
/// <summary>浮動小数(Single / Double / Decimal)。</summary>
Float,
/// <summary>文字列。</summary>
String,
/// <summary>列挙体。</summary>
Enum,
/// <summary>配列。</summary>
Array,
/// <summary>辞書(キーと値の組)。</summary>
Dictionary,
/// <summary>入れ子オブジェクト。</summary>
Object
}
/// <summary>
/// ES3 ファイル内の 1 項目を表す型付きノード。
/// JSON ツリー上の位置(<see cref="Path"/>)を保持するため、編集後の書き戻しが安全に行えます。
/// </summary>
public sealed class Es3Node
{
/// <summary>キー名(辞書・オブジェクトの子の場合)。</summary>
public string Key { get; set; } = string.Empty;
/// <summary>親をたどる JSON パス(例: <c>$.player.stats.hp</c>)。</summary>
public string Path { get; set; } = "$";
/// <summary>ES3 が示す型名(例: <c>System.Int32</c>、<c>System.Collections.Generic.List`1</c>)。</summary>
public string TypeName { get; set; } = string.Empty;
/// <summary>判定した値種別。</summary>
public Es3ValueKind Kind { get; set; } = Es3ValueKind.Unknown;
/// <summary>現在の値(文字列化した表示・編集用の値)。</summary>
public string DisplayValue { get; set; } = string.Empty;
/// <summary>元の JSON 値(書き戻し時の型再現に使用)。</summary>
public JsonNode? OriginalNode { get; set; }
/// <summary>配列・辞書・オブジェクトの場合の子要素。</summary>
public List<Es3Node> Children { get; } = [];
/// <summary>子要素を持つか。</summary>
public bool HasChildren => this.Children.Count > 0;
/// <summary>エディタで直接値を編集できる型か。</summary>
public bool IsEditable => this.Kind is Es3ValueKind.Boolean
or Es3ValueKind.Integer
or Es3ValueKind.Float
or Es3ValueKind.String
or Es3ValueKind.Enum;
}
/// <summary>
/// ES3 (Easy Save 3) のセーブデータ本体(復号後の JSON)を解析し、
/// キー名・型・値を読み取るとともに、編集結果を安全に書き戻すパーサ/ライタ。
///
/// ES3 の内部形式は次の 2 通りが混在します:
/// <c>{ "key": { "__type": "System.Int32", "value": 100 } }</c>
/// <c>{ "key": { "__type": "System.Collections.Generic.Dictionary`2[...]", "value": { ... } } }</c>
/// 本クラスは両形式を展開し、編集後は元の型情報を保持したまま再構築します。
/// </summary>
public sealed class Es3SaveDocument
{
/// <summary>ES3 が型情報を格納するプロパティ名。</summary>
public const string TypePropertyName = "__type";
/// <summary>ES3 が値を格納するプロパティ名。</summary>
public const string ValuePropertyName = "value";
/// <summary>解析対象のルート JSON オブジェクト(編集はこのインスタンスを直接書き換えます)。</summary>
private JsonNode? _root;
/// <summary>復号直後の JSON 文字列(差分検出・バックアップ用)。</summary>
public string OriginalJson { get; private set; } = string.Empty;
/// <summary>解析に成功したか。</summary>
public bool IsLoaded => this._root != null;
/// <summary>解析時の警告(解釈できなかった要素など)。</summary>
public List<string> Warnings { get; } = [];
/// <summary>ルート直下の項目一覧。</summary>
public List<Es3Node> RootNodes { get; } = [];
/// <summary>
/// ES3 の平文 JSON 文字列を解析してドキュメントを構築します。
/// </summary>
/// <param name="json">復号済みの平文 JSON</param>
/// <returns>解析されたドキュメント</returns>
public static Es3SaveDocument Parse(string json)
{
var document = new Es3SaveDocument { OriginalJson = json ?? string.Empty };
if (string.IsNullOrWhiteSpace(json))
{
document.Warnings.Add("平文 JSON が空です。");
return document;
}
JsonNode? root;
try
{
root = JsonNode.Parse(json, documentOptions: new JsonDocumentOptions
{
AllowTrailingCommas = true,
CommentHandling = JsonCommentHandling.Skip,
MaxDepth = 256
});
}
catch (JsonException ex)
{
document.Warnings.Add($"JSON 解析に失敗しました: {ex.Message}");
return document;
}
if (root == null)
{
document.Warnings.Add("JSON のルートが null です。");
return document;
}
document._root = root;
document.BuildTree(root, "$", string.Empty);
return document;
}
/// <summary>
/// 解析ツリーを走査してルート直下の項目一覧を構築します。
/// </summary>
/// <param name="root">JSON ルート</param>
/// <param name="path">ルートパス</param>
/// <param name="key">キー名</param>
private void BuildTree(JsonNode root, string path, string key)
{
if (root is JsonObject rootObject)
{
foreach (var kvp in rootObject)
{
var childPath = $"{path}.{kvp.Key}";
var node = this.CreateNode(kvp.Key, childPath, kvp.Value);
if (node != null)
{
this.RootNodes.Add(node);
}
}
return;
}
if (root is JsonArray rootArray)
{
for (int i = 0; i < rootArray.Count; i++)
{
var childPath = $"{path}[{i}]";
var node = this.CreateNode($"[{i}]", childPath, rootArray[i]);
if (node != null)
{
this.RootNodes.Add(node);
}
}
return;
}
this.Warnings.Add($"ルート要素を解釈できませんでした({root.GetValueKind()})。");
}
/// <summary>
/// JSON ノードから型付きの <see cref="Es3Node"/> を生成します。
/// </summary>
/// <param name="key">キー名</param>
/// <param name="path">JSON パス</param>
/// <param name="node">対象ノード</param>
/// <returns>生成されたノード。解釈不能な場合は null</returns>
private Es3Node? CreateNode(string key, string path, JsonNode? node)
{
var result = new Es3Node
{
Key = key,
Path = path,
OriginalNode = node
};
if (node == null)
{
result.Kind = Es3ValueKind.Unknown;
result.DisplayValue = "null";
return result;
}
switch (node.GetValueKind())
{
case JsonValueKind.Object:
this.PopulateObject(result, path, node.AsObject());
return result;
case JsonValueKind.Array:
result.Kind = Es3ValueKind.Array;
result.TypeName = "System.Array";
PopulateArray(result, path, node.AsArray());
return result;
case JsonValueKind.String:
result.Kind = Es3ValueKind.String;
result.TypeName = "System.String";
result.DisplayValue = node.GetValue<string>();
return result;
case JsonValueKind.Number:
PopulateNumber(result, node);
return result;
case JsonValueKind.True:
case JsonValueKind.False:
result.Kind = Es3ValueKind.Boolean;
result.TypeName = "System.Boolean";
result.DisplayValue = node.GetValue<bool>() ? "true" : "false";
return result;
case JsonValueKind.Null:
result.Kind = Es3ValueKind.Unknown;
result.DisplayValue = "null";
return result;
default:
result.Kind = Es3ValueKind.Unknown;
result.DisplayValue = node.ToJsonString();
return result;
}
}
/// <summary>
/// JSON オブジェクトが ES3 の型付き要素か、単なる入れ子オブジェクトかを判定して展開します。
/// </summary>
/// <param name="target">構築対象のノード</param>
/// <param name="path">JSON パス</param>
/// <param name="jsonObject">対象の JSON オブジェクト</param>
private void PopulateObject(Es3Node target, string path, JsonObject jsonObject)
{
// ES3 の型付き要素(__type と value を持つ)か判定
bool isTyped = jsonObject.ContainsKey(TypePropertyName);
if (isTyped)
{
target.TypeName = jsonObject[TypePropertyName]?.GetValue<string>() ?? string.Empty;
var inner = jsonObject[ValuePropertyName];
if (inner == null)
{
target.Kind = MapTypeNameToKind(target.TypeName);
target.DisplayValue = "null";
return;
}
var innerKind = inner.GetValueKind();
if (innerKind == JsonValueKind.Object)
{
// 辞書・入れ子オブジェクト
var innerObject = inner.AsObject();
target.Kind = LooksLikeDictionary(innerObject, target.TypeName)
? Es3ValueKind.Dictionary
: Es3ValueKind.Object;
foreach (var kvp in innerObject)
{
var childPath = $"{path}.{kvp.Key}";
var child = this.CreateNode(kvp.Key, childPath, kvp.Value);
if (child != null)
{
target.Children.Add(child);
}
}
target.DisplayValue = $"({target.Children.Count} 項目)";
return;
}
if (innerKind == JsonValueKind.Array)
{
target.Kind = Es3ValueKind.Array;
PopulateArray(target, path, inner.AsArray());
return;
}
// プリミティブ値
target.Kind = MapTypeNameToKind(target.TypeName);
target.DisplayValue = FormatScalar(inner, target.Kind);
return;
}
// 型情報なしの入れ子オブジェクト
target.Kind = Es3ValueKind.Object;
target.TypeName = "System.Object";
foreach (var kvp in jsonObject)
{
var childPath = $"{path}.{kvp.Key}";
var child = this.CreateNode(kvp.Key, childPath, kvp.Value);
if (child != null)
{
target.Children.Add(child);
}
}
target.DisplayValue = $"({target.Children.Count} 項目)";
}
/// <summary>
/// 配列を走査して子要素を追加します。
/// </summary>
/// <param name="target">構築対象のノード</param>
/// <param name="path">JSON パス</param>
/// <param name="array">対象の JSON 配列</param>
private static void PopulateArray(Es3Node target, string path, JsonArray array)
{
for (int i = 0; i < array.Count; i++)
{
var childPath = $"{path}[{i}]";
var elementNode = array[i];
var child = new Es3Node
{
Key = $"[{i}]",
Path = childPath,
OriginalNode = elementNode
};
if (elementNode == null)
{
child.Kind = Es3ValueKind.Unknown;
child.DisplayValue = "null";
}
else if (elementNode.GetValueKind() == JsonValueKind.Object &&
elementNode.AsObject().ContainsKey(TypePropertyName))
{
// 配列要素が型付き要素の場合は再帰的に展開する
var innerObject = elementNode.AsObject();
child.TypeName = innerObject[TypePropertyName]?.GetValue<string>() ?? string.Empty;
var inner = innerObject[ValuePropertyName];
if (inner != null && inner.GetValueKind() == JsonValueKind.Object)
{
child.Kind = Es3ValueKind.Object;
foreach (var kvp in inner.AsObject())
{
var grandChild = new Es3Node
{
Key = kvp.Key,
Path = $"{childPath}.{kvp.Key}",
OriginalNode = kvp.Value,
Kind = MapValueKind(kvp.Value),
DisplayValue = FormatScalar(kvp.Value, MapValueKind(kvp.Value))
};
child.Children.Add(grandChild);
}
child.DisplayValue = $"({child.Children.Count} 項目)";
}
else
{
child.Kind = MapTypeNameToKind(child.TypeName);
child.DisplayValue = inner == null ? "null" : FormatScalar(inner, child.Kind);
}
}
else
{
child.Kind = MapValueKind(elementNode);
child.DisplayValue = FormatScalar(elementNode, child.Kind);
}
target.Children.Add(child);
}
target.DisplayValue = $"({target.Children.Count} 件)";
}
/// <summary>
/// 数値ノードの型情報と表示値を設定します。
/// </summary>
/// <param name="target">構築対象のノード</param>
/// <param name="node">数値ノード</param>
private void PopulateNumber(Es3Node target, JsonNode node)
{
var raw = node.ToJsonString();
if (raw.Contains('.') || raw.Contains('e', StringComparison.OrdinalIgnoreCase) &&
!raw.Contains("0x", StringComparison.OrdinalIgnoreCase))
{
target.Kind = Es3ValueKind.Float;
target.TypeName = "System.Single";
}
else
{
target.Kind = Es3ValueKind.Integer;
target.TypeName = "System.Int32";
}
target.DisplayValue = raw;
}
/// <summary>
/// ES3 の型名から値種別を推定します。
/// </summary>
/// <param name="typeName">ES3 の型名</param>
/// <returns>推定した値種別</returns>
public static Es3ValueKind MapTypeNameToKind(string typeName)
{
if (string.IsNullOrEmpty(typeName))
{
return Es3ValueKind.Unknown;
}
var normalized = typeName.Replace(" ", string.Empty);
if (normalized.Contains("System.Boolean", StringComparison.Ordinal))
{
return Es3ValueKind.Boolean;
}
if (normalized.Contains("System.Single", StringComparison.Ordinal) ||
normalized.Contains("System.Double", StringComparison.Ordinal) ||
normalized.Contains("System.Decimal", StringComparison.Ordinal))
{
return Es3ValueKind.Float;
}
if (normalized.Contains("System.Int", StringComparison.Ordinal) ||
normalized.Contains("System.UInt", StringComparison.Ordinal) ||
normalized.Contains("System.Byte", StringComparison.Ordinal) ||
normalized.Contains("System.Int64", StringComparison.Ordinal) ||
normalized.Contains("System.Int16", StringComparison.Ordinal))
{
return Es3ValueKind.Integer;
}
if (normalized.Contains("System.String", StringComparison.Ordinal) ||
normalized.Contains("System.Char", StringComparison.Ordinal))
{
return Es3ValueKind.String;
}
if (normalized.Contains("Dictionary", StringComparison.Ordinal))
{
return Es3ValueKind.Dictionary;
}
if (normalized.Contains("[]", StringComparison.Ordinal) ||
normalized.Contains("List`1", StringComparison.Ordinal) ||
normalized.Contains("HashSet", StringComparison.Ordinal))
{
return Es3ValueKind.Array;
}
if (normalized.Contains("System.Enum", StringComparison.Ordinal))
{
return Es3ValueKind.Enum;
}
return Es3ValueKind.Object;
}
/// <summary>
/// 辞書形式(キーと値の組)かどうかを推定します。
/// </summary>
/// <param name="jsonObject">対象オブジェクト</param>
/// <param name="typeName">型名</param>
/// <returns>辞書と判断できる場合 true</returns>
private static bool LooksLikeDictionary(JsonObject jsonObject, string typeName)
{
if (!string.IsNullOrEmpty(typeName) &&
typeName.Contains("Dictionary", StringComparison.Ordinal))
{
return true;
}
// ES3 の辞書は {"key": "...", "value": ...} の対を持つ
return jsonObject.ContainsKey("key") && jsonObject.ContainsKey(ValuePropertyName);
}
/// <summary>
/// JSON 値の種別を簡易判定します。
/// </summary>
/// <param name="node">対象ノード</param>
/// <returns>判定した値種別</returns>
private static Es3ValueKind MapValueKind(JsonNode? node)
{
if (node == null)
{
return Es3ValueKind.Unknown;
}
return node.GetValueKind() switch
{
JsonValueKind.Object => Es3ValueKind.Object,
JsonValueKind.Array => Es3ValueKind.Array,
JsonValueKind.String => Es3ValueKind.String,
JsonValueKind.Number => node.ToJsonString().Contains('.')
? Es3ValueKind.Float
: Es3ValueKind.Integer,
JsonValueKind.True or JsonValueKind.False => Es3ValueKind.Boolean,
_ => Es3ValueKind.Unknown
};
}
/// <summary>
/// スカラー値を表示用文字列へ整形します。
/// </summary>
/// <param name="node">対象ノード</param>
/// <param name="kind">値種別</param>
/// <returns>表示用文字列</returns>
private static string FormatScalar(JsonNode? node, Es3ValueKind kind)
{
if (node == null)
{
return "null";
}
try
{
return kind switch
{
Es3ValueKind.Boolean => node.GetValue<bool>() ? "true" : "false",
Es3ValueKind.String => node.GetValue<string>(),
Es3ValueKind.Enum => node.GetValueKind() == JsonValueKind.Number
? node.ToJsonString()
: node.GetValue<string>(),
_ => node.ToJsonString()
};
}
catch
{
return node.ToJsonString();
}
}
/// <summary>
/// 指定パスのノードへ編集値を適用します。
/// </summary>
/// <param name="path">JSON パス(<see cref="Es3Node.Path"/>)</param>
/// <param name="newValue">新しい値(表示文字列)</param>
/// <param name="error">失敗理由</param>
/// <returns>適用に成功した場合 true</returns>
public bool TrySetValue(string path, string newValue, out string error)
{
error = string.Empty;
if (this._root == null)
{
error = "ドキュメントが読み込まれていません。";
return false;
}
if (!this.TryResolveParent(path, out var parent, out var key, out error))
{
return false;
}
// 既存ノードから型情報を取得
var existing = this.FindNode(path);
var kind = existing?.Kind ?? Es3ValueKind.String;
var typeName = existing?.TypeName ?? "System.String";
if (existing != null && !existing.IsEditable)
{
error = $"型 {typeName} は直接編集できません。";
return false;
}
JsonNode? parsed = this.BuildValueNode(newValue, kind, typeName, out error);
if (parsed == null)
{
return false;
}
try
{
// ES3 の型付き要素として書き戻す
if (parent is JsonObject parentObject && parentObject.ContainsKey(TypePropertyName))
{
parentObject[ValuePropertyName] = parsed;
}
else if (parent is JsonObject plainObject)
{
plainObject[key] = parsed;
}
else if (parent is JsonArray array && int.TryParse(key, out int index) &&
index >= 0 && index < array.Count)
{
array[index] = parsed;
}
else
{
error = "書き戻し先の親要素を特定できませんでした。";
return false;
}
return true;
}
catch (Exception ex)
{
error = $"書き戻しに失敗しました: {ex.Message}";
return false;
}
}
/// <summary>
/// 編集後の JSON を文字列として取得します。
/// </summary>
/// <returns>整形済み JSON 文字列</returns>
public string ToJson()
{
if (this._root == null)
{
return this.OriginalJson;
}
return this._root.ToJsonString(new JsonSerializerOptions { WriteIndented = false });
}
/// <summary>
/// 元の JSON から変更があったかを判定します。
/// </summary>
/// <returns>変更がある場合 true</returns>
public bool HasChanges()
{
if (this._root == null)
{
return false;
}
return !string.Equals(this.ToJson(), this.OriginalJson, StringComparison.Ordinal);
}
/// <summary>
/// パスから親ノードと最終キーを解決します。
/// </summary>
/// <param name="path">JSON パス</param>
/// <param name="parent">親ノード</param>
/// <param name="key">最終キー(配列の場合はインデックス文字列)</param>
/// <param name="error">失敗理由</param>
/// <returns>解決に成功した場合 true</returns>
private bool TryResolveParent(string path, out JsonNode? parent, out string key, out string error)
{
parent = null;
key = string.Empty;
error = string.Empty;
if (path == "$")
{
error = "ルート要素は編集できません。";
return false;
}
var segments = SplitPath(path);
if (segments.Count < 2)
{
error = $"パスの解析に失敗しました: {path}";
return false;
}
JsonNode? current = this._root;
for (int i = 1; i < segments.Count - 1; i++)
{
if (current == null)
{
break;
}
current = Descend(current, segments[i], out _);
}
if (current == null)
{
error = $"パス {path} を解決できませんでした。";
return false;
}
key = segments[^1];
parent = current;
return true;
}
/// <summary>
/// パス文字列をセグメントへ分割します。
/// </summary>
/// <param name="path">JSON パス</param>
/// <returns>セグメント一覧(先頭は "$")</returns>
private static List<string> SplitPath(string path)
{
var segments = new List<string>();
var buffer = new StringBuilder();
foreach (var ch in path)
{
if (ch == '.' || ch == '[' || ch == ']')
{
if (buffer.Length > 0)
{
segments.Add(buffer.ToString());
buffer.Clear();
}
continue;
}
buffer.Append(ch);
}
if (buffer.Length > 0)
{
segments.Add(buffer.ToString());
}
return segments;
}
/// <summary>
/// 指定キーで子要素へ降下します(ES3 の型付き要素は value を透過します)。
/// </summary>
/// <param name="current">現在のノード</param>
/// <param name="key">キー</param>
/// <param name="found">見つかった子ノード</param>
/// <returns>降下先ノード。見つからない場合は null</returns>
private static JsonNode? Descend(JsonNode current, string key, out JsonNode? found)
{
found = null;
if (current is JsonObject obj)
{
// ES3 の型付き要素は value の中身を透過的に扱う
if (obj.ContainsKey(TypePropertyName) && obj[ValuePropertyName] is JsonNode inner)
{
return Descend(inner, key, out found);
}
if (obj.TryGetPropertyValue(key, out var child))
{
found = child;
return child;
}
return null;
}
if (current is JsonArray array && int.TryParse(key, out int index) &&
index >= 0 && index < array.Count)
{
found = array[index];
return array[index];
}
return null;
}
/// <summary>
/// 指定パスに対応するノードを探索します。
/// </summary>
/// <param name="path">JSON パス</param>
/// <returns>見つかったノード。見つからない場合は null</returns>
private Es3Node? FindNode(string path)
{
return FindNodeRecursive(this.RootNodes, path);
}
/// <summary>
/// ノードツリーを再帰的に探索します。
/// </summary>
/// <param name="nodes">探索対象</param>
/// <param name="path">JSON パス</param>
/// <returns>見つかったノード</returns>
private static Es3Node? FindNodeRecursive(List<Es3Node> nodes, string path)
{
foreach (var node in nodes)
{
if (node.Path == path)
{
return node;
}
var found = FindNodeRecursive(node.Children, path);
if (found != null)
{
return found;
}
}
return null;
}
/// <summary>
/// 編集値から実際の JSON ノードを構築します。
/// </summary>
/// <param name="newValue">編集された値文字列</param>
/// <param name="kind">型種別</param>
/// <param name="typeName">ES3 の型名</param>
/// <param name="error">失敗理由</param>
/// <returns>構築された JSON ノード。失敗時は null</returns>
private JsonNode? BuildValueNode(string newValue, Es3ValueKind kind, string typeName, out string error)
{
error = string.Empty;
switch (kind)
{
case Es3ValueKind.Boolean:
if (bool.TryParse(newValue, out var boolValue))
{
return JsonValue.Create(boolValue);
}
if (newValue.Trim() == "1")
{
return JsonValue.Create(true);
}
if (newValue.Trim() == "0")
{
return JsonValue.Create(false);
}
error = $"真偽値として解釈できません: {newValue}";
return null;
case Es3ValueKind.Integer:
if (long.TryParse(newValue.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var longValue))
{
return JsonValue.Create(longValue);
}
error = $"整数として解釈できません: {newValue}";
return null;
case Es3ValueKind.Float:
if (double.TryParse(newValue.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out var doubleValue))
{
return JsonValue.Create(doubleValue);
}
error = $"小数として解釈できません: {newValue}";
return null;
case Es3ValueKind.Enum:
// 列挙体は元が数値なら数値、文字列なら文字列として保持する
if (long.TryParse(newValue.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var enumNumeric))
{
return JsonValue.Create(enumNumeric);
}
return JsonValue.Create(newValue);
case Es3ValueKind.String:
return JsonValue.Create(newValue);
default:
error = $"型 {typeName} は直接編集できません。";
return null;
}
}
}
}