機能追加: Bakin・NW.jsエンジンおよびセーブ編集対応、ES3パスワード解決機能とRPGツクールMZ修正サービスの追加

This commit is contained in:
armonica committed 2026-11-20 19:55:34 +09:00
1 parent f50976a6c0
commit 152abae1f8
33 files changed
+11356 -175

No files matched your search

+891
View File
@@ -0,0 +1,891 @@
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;
}
}
}
}