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 { /// /// ES3 のシリアライズ要素が持つ「型」の種別。 /// ES3 は { "__type": "System.Int32", "value": 42 } 形式で値を格納するため、 /// この列挙子で GUI 側へ型情報を伝えます。 /// public enum Es3ValueKind { /// 不明・未判定。 Unknown, /// 真偽値。 Boolean, /// 整数(Int32 / Int64 / UInt32 等)。 Integer, /// 浮動小数(Single / Double / Decimal)。 Float, /// 文字列。 String, /// 列挙体。 Enum, /// 配列。 Array, /// 辞書(キーと値の組)。 Dictionary, /// 入れ子オブジェクト。 Object } /// /// ES3 ファイル内の 1 項目を表す型付きノード。 /// JSON ツリー上の位置()を保持するため、編集後の書き戻しが安全に行えます。 /// public sealed class Es3Node { /// キー名(辞書・オブジェクトの子の場合)。 public string Key { get; set; } = string.Empty; /// 親をたどる JSON パス(例: $.player.stats.hp)。 public string Path { get; set; } = "$"; /// ES3 が示す型名(例: System.Int32、System.Collections.Generic.List`1)。 public string TypeName { get; set; } = string.Empty; /// 判定した値種別。 public Es3ValueKind Kind { get; set; } = Es3ValueKind.Unknown; /// 現在の値(文字列化した表示・編集用の値)。 public string DisplayValue { get; set; } = string.Empty; /// 元の JSON 値(書き戻し時の型再現に使用)。 public JsonNode? OriginalNode { get; set; } /// 配列・辞書・オブジェクトの場合の子要素。 public List Children { get; } = []; /// 子要素を持つか。 public bool HasChildren => this.Children.Count > 0; /// エディタで直接値を編集できる型か。 public bool IsEditable => this.Kind is Es3ValueKind.Boolean or Es3ValueKind.Integer or Es3ValueKind.Float or Es3ValueKind.String or Es3ValueKind.Enum; } /// /// ES3 (Easy Save 3) のセーブデータ本体(復号後の JSON)を解析し、 /// キー名・型・値を読み取るとともに、編集結果を安全に書き戻すパーサ/ライタ。 /// /// ES3 の内部形式は次の 2 通りが混在します: /// { "key": { "__type": "System.Int32", "value": 100 } } /// { "key": { "__type": "System.Collections.Generic.Dictionary`2[...]", "value": { ... } } } /// 本クラスは両形式を展開し、編集後は元の型情報を保持したまま再構築します。 /// public sealed class Es3SaveDocument { /// ES3 が型情報を格納するプロパティ名。 public const string TypePropertyName = "__type"; /// ES3 が値を格納するプロパティ名。 public const string ValuePropertyName = "value"; /// 解析対象のルート JSON オブジェクト(編集はこのインスタンスを直接書き換えます)。 private JsonNode? _root; /// 復号直後の JSON 文字列(差分検出・バックアップ用)。 public string OriginalJson { get; private set; } = string.Empty; /// 解析に成功したか。 public bool IsLoaded => this._root != null; /// 解析時の警告(解釈できなかった要素など)。 public List Warnings { get; } = []; /// ルート直下の項目一覧。 public List RootNodes { get; } = []; /// /// ES3 の平文 JSON 文字列を解析してドキュメントを構築します。 /// /// 復号済みの平文 JSON /// 解析されたドキュメント 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; } /// /// 解析ツリーを走査してルート直下の項目一覧を構築します。 /// /// JSON ルート /// ルートパス /// キー名 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()})。"); } /// /// JSON ノードから型付きの を生成します。 /// /// キー名 /// JSON パス /// 対象ノード /// 生成されたノード。解釈不能な場合は null 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(); 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() ? "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; } } /// /// JSON オブジェクトが ES3 の型付き要素か、単なる入れ子オブジェクトかを判定して展開します。 /// /// 構築対象のノード /// JSON パス /// 対象の JSON オブジェクト 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.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} 項目)"; } /// /// 配列を走査して子要素を追加します。 /// /// 構築対象のノード /// JSON パス /// 対象の JSON 配列 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.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} 件)"; } /// /// 数値ノードの型情報と表示値を設定します。 /// /// 構築対象のノード /// 数値ノード 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; } /// /// ES3 の型名から値種別を推定します。 /// /// ES3 の型名 /// 推定した値種別 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; } /// /// 辞書形式(キーと値の組)かどうかを推定します。 /// /// 対象オブジェクト /// 型名 /// 辞書と判断できる場合 true 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); } /// /// JSON 値の種別を簡易判定します。 /// /// 対象ノード /// 判定した値種別 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 }; } /// /// スカラー値を表示用文字列へ整形します。 /// /// 対象ノード /// 値種別 /// 表示用文字列 private static string FormatScalar(JsonNode? node, Es3ValueKind kind) { if (node == null) { return "null"; } try { return kind switch { Es3ValueKind.Boolean => node.GetValue() ? "true" : "false", Es3ValueKind.String => node.GetValue(), Es3ValueKind.Enum => node.GetValueKind() == JsonValueKind.Number ? node.ToJsonString() : node.GetValue(), _ => node.ToJsonString() }; } catch { return node.ToJsonString(); } } /// /// 指定パスのノードへ編集値を適用します。 /// /// JSON パス() /// 新しい値(表示文字列) /// 失敗理由 /// 適用に成功した場合 true 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; } } /// /// 編集後の JSON を文字列として取得します。 /// /// 整形済み JSON 文字列 public string ToJson() { if (this._root == null) { return this.OriginalJson; } return this._root.ToJsonString(new JsonSerializerOptions { WriteIndented = false }); } /// /// 元の JSON から変更があったかを判定します。 /// /// 変更がある場合 true public bool HasChanges() { if (this._root == null) { return false; } return !string.Equals(this.ToJson(), this.OriginalJson, StringComparison.Ordinal); } /// /// パスから親ノードと最終キーを解決します。 /// /// JSON パス /// 親ノード /// 最終キー(配列の場合はインデックス文字列) /// 失敗理由 /// 解決に成功した場合 true 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; } /// /// パス文字列をセグメントへ分割します。 /// /// JSON パス /// セグメント一覧(先頭は "$") private static List SplitPath(string path) { var segments = new List(); 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; } /// /// 指定キーで子要素へ降下します(ES3 の型付き要素は value を透過します)。 /// /// 現在のノード /// キー /// 見つかった子ノード /// 降下先ノード。見つからない場合は null 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; } /// /// 指定パスに対応するノードを探索します。 /// /// JSON パス /// 見つかったノード。見つからない場合は null private Es3Node? FindNode(string path) { return FindNodeRecursive(this.RootNodes, path); } /// /// ノードツリーを再帰的に探索します。 /// /// 探索対象 /// JSON パス /// 見つかったノード private static Es3Node? FindNodeRecursive(List 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; } /// /// 編集値から実際の JSON ノードを構築します。 /// /// 編集された値文字列 /// 型種別 /// ES3 の型名 /// 失敗理由 /// 構築された JSON ノード。失敗時は null 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; } } } }