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;
}
}
}
}