1658 lines
67 KiB
C#
1658 lines
67 KiB
C#
// Engines/Bakin/BakinSaveService.cs — RPG Developer Bakin (YUKRDATA .sgs) セーブデータ解析・編集・バックアップ管理サービス
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.ComponentModel;
|
||
using System.Globalization;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Runtime.CompilerServices;
|
||
using System.Text;
|
||
using GameLauncher.Helpers;
|
||
|
||
namespace GameLauncher.Engines.Bakin
|
||
{
|
||
/// <summary>
|
||
/// Bakin セーブデータファイル(Save_00.sgs 等)の概要情報モデル。
|
||
/// </summary>
|
||
public sealed class BakinSaveFileInfo
|
||
{
|
||
#region □プロパティ(Public)
|
||
|
||
/// <summary>セーブデータのフルパス</summary>
|
||
public string FilePath { get; set; } = string.Empty;
|
||
|
||
/// <summary>ファイル名(例: Save_00.sgs)</summary>
|
||
public string FileName { get; set; } = string.Empty;
|
||
|
||
/// <summary>クロスセーブ(Save_xx.sgs)かどうか</summary>
|
||
public bool IsCrossSave { get; set; }
|
||
|
||
/// <summary>最終更新日時</summary>
|
||
public DateTime LastModified { get; set; }
|
||
|
||
/// <summary>ファイルサイズ(バイト)</summary>
|
||
public long FileSize { get; set; }
|
||
|
||
/// <summary>コンボボックス表示用の要約テキスト</summary>
|
||
public string SummaryText { get; set; } = string.Empty;
|
||
|
||
#endregion
|
||
}
|
||
|
||
/// <summary>
|
||
/// GUI の DataGrid 上で 1 行として表示・編集されるセーブデータ項目モデル。
|
||
/// </summary>
|
||
public sealed class BakinSaveEntry : INotifyPropertyChanged
|
||
{
|
||
#region □変数(Private)
|
||
|
||
private string _valueText = string.Empty;
|
||
|
||
#endregion
|
||
|
||
#region □プロパティ(Public)
|
||
|
||
/// <summary>カテゴリ名(例: 💰 基本・システム / ⚔️ パーティステータス / 🎒 所持アイテム / 🔢 ゲーム変数 等)</summary>
|
||
public string Category { get; set; } = string.Empty;
|
||
|
||
/// <summary>画面表示用の項目名</summary>
|
||
public string DisplayKey { get; set; } = string.Empty;
|
||
|
||
/// <summary>データ型表記(Int32 / Double / String / Boolean / Single)</summary>
|
||
public string ValueType { get; set; } = string.Empty;
|
||
|
||
/// <summary>読み込み時の元の値テキスト</summary>
|
||
public string OriginalValueText { get; set; } = string.Empty;
|
||
|
||
/// <summary>編集後の値テキスト</summary>
|
||
public string ValueText
|
||
{
|
||
get => this._valueText;
|
||
set
|
||
{
|
||
if (this._valueText != value)
|
||
{
|
||
this._valueText = value ?? string.Empty;
|
||
this.OnPropertyChanged();
|
||
this.OnPropertyChanged(nameof(this.IsModified));
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>内部識別キー(書き戻し用)</summary>
|
||
public string InternalKey { get; set; } = string.Empty;
|
||
|
||
/// <summary>初期値から変更されているかどうか</summary>
|
||
public bool IsModified => !string.Equals(this.OriginalValueText, this._valueText, StringComparison.Ordinal);
|
||
|
||
/// <summary>値を適用するコールバック</summary>
|
||
internal Action<string>? ApplyAction { get; set; }
|
||
|
||
/// <summary>クロスセーブ側(Save_xx.sgs)の項目かどうか</summary>
|
||
internal bool BelongsToCompanionCrossSave { get; set; }
|
||
|
||
#endregion
|
||
|
||
#region □イベント
|
||
|
||
/// <inheritdoc/>
|
||
public event PropertyChangedEventHandler? PropertyChanged;
|
||
|
||
#endregion
|
||
|
||
#region □メソッド(Public)
|
||
|
||
/// <summary>
|
||
/// 初期値をセットします。
|
||
/// </summary>
|
||
/// <param name="initialValue">初期値文字列</param>
|
||
public void SetInitialValue(string initialValue)
|
||
{
|
||
this.OriginalValueText = initialValue ?? string.Empty;
|
||
this._valueText = this.OriginalValueText;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 保存完了時に現在の値を初期値として確定します。
|
||
/// </summary>
|
||
public void CommitValue()
|
||
{
|
||
this.OriginalValueText = this._valueText;
|
||
this.OnPropertyChanged(nameof(this.OriginalValueText));
|
||
this.OnPropertyChanged(nameof(this.IsModified));
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region □メソッド(Private)
|
||
|
||
private void OnPropertyChanged([CallerMemberName] string? propertyName = null)
|
||
{
|
||
this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
|
||
}
|
||
|
||
#endregion
|
||
}
|
||
|
||
/// <summary>
|
||
/// 読み込まれた 1 つの Bakin セーブセッション(対象 .sgs と、付随する Save_xx.sgs)を保持するコンテナ。
|
||
/// </summary>
|
||
public sealed class BakinSaveDocument
|
||
{
|
||
#region □プロパティ(Public)
|
||
|
||
/// <summary>対象ファイルのパス</summary>
|
||
public string FilePath { get; set; } = string.Empty;
|
||
|
||
/// <summary>クロスセーブ単体ファイル(Save_xx.sgs)を直接開いているかどうか</summary>
|
||
public bool IsCrossSaveFile { get; set; }
|
||
|
||
/// <summary>データバージョン(通常 3)</summary>
|
||
public int DataVersion { get; set; } = 3;
|
||
|
||
/// <summary>GUI編集用の全エントリ一覧</summary>
|
||
public List<BakinSaveEntry> Entries { get; } = new();
|
||
|
||
/// <summary>同時読み込みされた Save_xx.sgs のパス(通常セーブを開いた場合のみ)</summary>
|
||
public string? CompanionCrossSavePath { get; set; }
|
||
|
||
#endregion
|
||
|
||
#region □変数(Friend)
|
||
|
||
internal List<byte[]> RawChunks { get; } = new();
|
||
internal BakinPartyChunk? PartyChunk { get; set; }
|
||
internal BakinSystemDataChunk? SystemChunk { get; set; }
|
||
internal BakinCrossSaveChunk? CrossSaveChunk { get; set; }
|
||
|
||
internal int CompanionCrossSaveVersion { get; set; } = 3;
|
||
internal List<byte[]> CompanionCrossSaveRawChunks { get; } = new();
|
||
internal BakinCrossSaveChunk? CompanionCrossSaveChunk { get; set; }
|
||
|
||
#endregion
|
||
}
|
||
|
||
/// <summary>
|
||
/// Party チャンク (Chunk[0]) の内部構造保持クラス。
|
||
/// </summary>
|
||
internal sealed class BakinPartyChunk
|
||
{
|
||
public List<BakinHeroSubChunk> Members { get; } = new();
|
||
public List<BakinHeroSubChunk> Reserves { get; } = new();
|
||
public List<BakinItemStack> Items { get; } = new();
|
||
public int Money { get; set; }
|
||
public List<BakinItemStack> ItemDict { get; } = new();
|
||
public List<byte[]> ModifiedInfos { get; } = new();
|
||
public List<BakinCustomHeroName> CustomHeroNames { get; } = new();
|
||
public int InventoryMax { get; set; } = 999;
|
||
public byte[] TrailingBytes { get; set; } = Array.Empty<byte>();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Hero サブチャンク(先頭60バイトの基本ステータス+後続バイト列)保持クラス。
|
||
/// </summary>
|
||
internal sealed class BakinHeroSubChunk
|
||
{
|
||
public byte[] RawBytes { get; set; } = Array.Empty<byte>();
|
||
public Guid RomGuid { get; set; }
|
||
public int Level { get; set; }
|
||
public int MaxHitpoint { get; set; }
|
||
public int MaxMagicpoint { get; set; }
|
||
public int Hitpoint { get; set; }
|
||
public int Magicpoint { get; set; }
|
||
public int Power { get; set; }
|
||
public int Vitality { get; set; }
|
||
public int Magic { get; set; }
|
||
public int Speed { get; set; }
|
||
public int Exp { get; set; }
|
||
public bool HasValidHeader => this.RawBytes.Length >= 60;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 所持アイテムまたはアイテム辞書エントリ。
|
||
/// </summary>
|
||
internal sealed class BakinItemStack
|
||
{
|
||
public Guid ItemGuid { get; set; }
|
||
public int Num { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// カスタムヒーロー名エントリ。
|
||
/// </summary>
|
||
internal sealed class BakinCustomHeroName
|
||
{
|
||
public Guid HeroGuid { get; set; }
|
||
public string Name { get; set; } = string.Empty;
|
||
}
|
||
|
||
/// <summary>
|
||
/// SystemData チャンク (Chunk[1]) の内部構造保持クラス。
|
||
/// </summary>
|
||
internal sealed class BakinSystemDataChunk
|
||
{
|
||
public List<BakinVariableEntry> Variables { get; } = new();
|
||
public bool MenuAvailable { get; set; }
|
||
public bool EncountAvailable { get; set; }
|
||
public int BgmVolume { get; set; }
|
||
public int SeVolume { get; set; }
|
||
public int MessageSpeed { get; set; }
|
||
public int CursorPosition { get; set; }
|
||
public int ControlType { get; set; }
|
||
public float PlayTime { get; set; }
|
||
public bool SaveAvailable { get; set; }
|
||
public bool DashAvailable { get; set; }
|
||
public int MoveSpeed { get; set; }
|
||
public List<BakinLocalVariableEntry> LocalVariables { get; } = new();
|
||
public bool JumpAvailable { get; set; }
|
||
public byte[] BattleCameraFlags { get; set; } = Array.Empty<byte>();
|
||
public byte[] ChangedLayoutsBytes { get; set; } = Array.Empty<byte>();
|
||
public List<BakinLocalVariableEntry> DynamicLocalVariables { get; } = new();
|
||
public List<BakinVariableArrayEntry> VariableArrays { get; } = new();
|
||
public byte[] TrailingBytes { get; set; } = Array.Empty<byte>();
|
||
}
|
||
|
||
/// <summary>
|
||
/// CrossSaveVariable チャンク (Save_xx.sgs の Chunk[0]) の内部構造保持クラス。
|
||
/// </summary>
|
||
internal sealed class BakinCrossSaveChunk
|
||
{
|
||
public List<BakinVariableEntry> Variables { get; } = new();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 通常変数またはクロスセーブ変数エントリ。
|
||
/// </summary>
|
||
internal sealed class BakinVariableEntry
|
||
{
|
||
public string Name { get; set; } = string.Empty;
|
||
public byte Type { get; set; } // 0 = Double, 1 = String
|
||
public double DoubleValue { get; set; }
|
||
public string StringValue { get; set; } = string.Empty;
|
||
}
|
||
|
||
/// <summary>
|
||
/// ローカル変数エントリ。
|
||
/// </summary>
|
||
internal sealed class BakinLocalVariableEntry
|
||
{
|
||
public Guid EventGuid { get; set; }
|
||
public string Name { get; set; } = string.Empty;
|
||
public byte Type { get; set; } // 0 = Double, 1 = String
|
||
public double DoubleValue { get; set; }
|
||
public string StringValue { get; set; } = string.Empty;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配列変数エントリ。
|
||
/// </summary>
|
||
internal sealed class BakinVariableArrayEntry
|
||
{
|
||
public string ArrayName { get; set; } = string.Empty;
|
||
public List<BakinVariableArrayElement> Elements { get; } = new();
|
||
}
|
||
|
||
/// <summary>
|
||
/// 配列変数の1要素。
|
||
/// </summary>
|
||
internal sealed class BakinVariableArrayElement
|
||
{
|
||
public int Index { get; set; }
|
||
public byte Type { get; set; } // 0 = Double, 1 = String
|
||
public double DoubleValue { get; set; }
|
||
public string StringValue { get; set; } = string.Empty;
|
||
}
|
||
|
||
/// <summary>
|
||
/// RPG Developer Bakin のセーブデータ (`YUKRDATA` `.sgs` 形式) の検出・読込・保存・バックアップ・復元を提供するサービスクラス。
|
||
/// </summary>
|
||
public static class BakinSaveService
|
||
{
|
||
#region □定数(Private)
|
||
|
||
private const string YukrSignature = "YUKRDATA";
|
||
|
||
public const string CategoryBasic = "💰 基本・システム設定";
|
||
public const string CategoryParty = "⚔️ パーティ・キャラクター";
|
||
public const string CategoryItems = "🎒 所持アイテム";
|
||
public const string CategoryVariables = "🔢 ゲーム変数 (Variables)";
|
||
public const string CategoryCrossSave = "🌐 クロスセーブ・回想解放 (Save_xx)";
|
||
public const string CategoryArrays = "📚 配列変数 (VariableArrays)";
|
||
public const string CategoryLocalVars = "📍 ローカル変数 (LocalVariables)";
|
||
|
||
#endregion
|
||
|
||
#region □メソッド(Public)
|
||
|
||
/// <summary>
|
||
/// 指定されたゲームフォルダに Bakin セーブデータ (`.sgs`) が 1 件以上存在するかを判定します。
|
||
/// </summary>
|
||
/// <param name="rootDir">ゲームルートディレクトリ</param>
|
||
/// <returns>セーブデータが存在すれば true</returns>
|
||
public static bool HasAnySaveData(string rootDir)
|
||
{
|
||
try
|
||
{
|
||
var saveDir = BakinDetector.ResolveSaveDirectory(rootDir);
|
||
if (string.IsNullOrEmpty(saveDir) || !Directory.Exists(saveDir))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return Directory.EnumerateFiles(saveDir, "*.sgs", SearchOption.TopDirectoryOnly).Any();
|
||
}
|
||
catch
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 指定されたゲームフォルダ内の全 `.sgs` セーブファイルを検索し、概要情報付きリストを返します。
|
||
/// </summary>
|
||
/// <param name="rootDir">ゲームルートディレクトリ</param>
|
||
/// <returns>セーブファイル情報リスト</returns>
|
||
public static List<BakinSaveFileInfo> FindSaveFiles(string rootDir)
|
||
{
|
||
var result = new List<BakinSaveFileInfo>();
|
||
try
|
||
{
|
||
var saveDir = BakinDetector.ResolveSaveDirectory(rootDir);
|
||
if (string.IsNullOrEmpty(saveDir) || !Directory.Exists(saveDir))
|
||
{
|
||
return result;
|
||
}
|
||
|
||
var files = Directory.GetFiles(saveDir, "*.sgs", SearchOption.TopDirectoryOnly)
|
||
.OrderBy(f =>
|
||
{
|
||
var name = Path.GetFileName(f);
|
||
if (string.Equals(name, "Save_xx.sgs", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
return "zzzz_Save_xx.sgs";
|
||
}
|
||
return name;
|
||
}, StringComparer.OrdinalIgnoreCase)
|
||
.ToList();
|
||
|
||
foreach (var file in files)
|
||
{
|
||
var fi = new FileInfo(file);
|
||
bool isCross = string.Equals(fi.Name, "Save_xx.sgs", StringComparison.OrdinalIgnoreCase);
|
||
string summary = BakinSaveService.BuildQuickSummary(file, fi, isCross);
|
||
|
||
result.Add(new BakinSaveFileInfo
|
||
{
|
||
FilePath = file,
|
||
FileName = fi.Name,
|
||
IsCrossSave = isCross,
|
||
LastModified = fi.LastWriteTime,
|
||
FileSize = fi.Length,
|
||
SummaryText = summary
|
||
});
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// 無視
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 指定された `.sgs` セーブファイルを読み込み、GUI 編集用の <see cref="BakinSaveDocument"/> を構築します。
|
||
/// 通常セーブを開いた場合、同フォルダに `Save_xx.sgs` が存在すればクロスセーブ変数も同時に読み込みます。
|
||
/// </summary>
|
||
/// <param name="filePath">対象 `.sgs` ファイルのフルパス</param>
|
||
/// <returns>読み込まれたセーブドキュメント</returns>
|
||
public static BakinSaveDocument LoadSaveData(string filePath)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(filePath) || !File.Exists(filePath))
|
||
{
|
||
throw new FileNotFoundException("指定されたセーブデータファイルが見つかりません。", filePath);
|
||
}
|
||
|
||
var rawBytes = File.ReadAllBytes(filePath);
|
||
var (version, chunks) = BakinSaveService.ReadYukrChunks(rawBytes);
|
||
|
||
var doc = new BakinSaveDocument
|
||
{
|
||
FilePath = filePath,
|
||
DataVersion = version
|
||
};
|
||
doc.RawChunks.AddRange(chunks);
|
||
|
||
bool isCrossFile = string.Equals(Path.GetFileName(filePath), "Save_xx.sgs", StringComparison.OrdinalIgnoreCase);
|
||
if (!isCrossFile && chunks.Count > 0)
|
||
{
|
||
// ファイル名が Save_xx.sgs でなくても Chunk[0] が CrossSave 構造なら自動判別
|
||
if (!BakinSaveService.TryParsePartyChunk(chunks[0], out _) &&
|
||
BakinSaveService.TryParseCrossSaveChunk(chunks[0], out _))
|
||
{
|
||
isCrossFile = true;
|
||
}
|
||
}
|
||
|
||
doc.IsCrossSaveFile = isCrossFile;
|
||
|
||
if (isCrossFile)
|
||
{
|
||
if (chunks.Count > 0 && BakinSaveService.TryParseCrossSaveChunk(chunks[0], out var crossChunk) && crossChunk != null)
|
||
{
|
||
doc.CrossSaveChunk = crossChunk;
|
||
BakinSaveService.PopulateCrossSaveEntries(doc, crossChunk, isCompanion: false);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (chunks.Count > 0 && BakinSaveService.TryParsePartyChunk(chunks[0], out var partyChunk) && partyChunk != null)
|
||
{
|
||
doc.PartyChunk = partyChunk;
|
||
}
|
||
|
||
if (chunks.Count > 1 && BakinSaveService.TryParseSystemDataChunk(chunks[1], out var sysChunk) && sysChunk != null)
|
||
{
|
||
doc.SystemChunk = sysChunk;
|
||
}
|
||
|
||
BakinSaveService.PopulateStandardSaveEntries(doc);
|
||
|
||
// 同フォルダに Save_xx.sgs(クロスセーブ)があれば同時に読み込んで回想・解放フラグも編集可能にする
|
||
var dir = Path.GetDirectoryName(filePath);
|
||
if (!string.IsNullOrEmpty(dir))
|
||
{
|
||
var crossPath = Path.Combine(dir, "Save_xx.sgs");
|
||
if (File.Exists(crossPath))
|
||
{
|
||
try
|
||
{
|
||
var crossBytes = File.ReadAllBytes(crossPath);
|
||
var (cVer, cChunks) = BakinSaveService.ReadYukrChunks(crossBytes);
|
||
if (cChunks.Count > 0 && BakinSaveService.TryParseCrossSaveChunk(cChunks[0], out var compCross) && compCross != null)
|
||
{
|
||
doc.CompanionCrossSavePath = crossPath;
|
||
doc.CompanionCrossSaveVersion = cVer;
|
||
doc.CompanionCrossSaveRawChunks.AddRange(cChunks);
|
||
doc.CompanionCrossSaveChunk = compCross;
|
||
BakinSaveService.PopulateCrossSaveEntries(doc, compCross, isCompanion: true);
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// 付随 Save_xx.sgs の読み込み失敗時は本体のみ続行
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return doc;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 編集された <see cref="BakinSaveDocument"/> を元の `.sgs` ファイル(および変更があれば `Save_xx.sgs`)へ保存します。
|
||
/// 保存前に必ず `Backups` フォルダへ自動バックアップを作成します。
|
||
/// </summary>
|
||
/// <param name="doc">保存対象のセーブドキュメント</param>
|
||
/// <param name="folderName">ゲームフォルダ名(バックアップ先識別用)</param>
|
||
/// <param name="rootDirectory">ゲームルートディレクトリ</param>
|
||
/// <returns>作成されたバックアップファイルパス</returns>
|
||
public static string SaveSaveData(BakinSaveDocument doc, string folderName, string rootDirectory)
|
||
{
|
||
if (doc == null)
|
||
{
|
||
throw new ArgumentNullException(nameof(doc));
|
||
}
|
||
|
||
// 1. 変更されたエントリの値を内部チャンクモデルへ反映
|
||
foreach (var entry in doc.Entries)
|
||
{
|
||
if (entry.IsModified)
|
||
{
|
||
entry.ApplyAction?.Invoke(entry.ValueText);
|
||
}
|
||
}
|
||
|
||
// 2. 保存前バックアップの作成
|
||
string backupPath = BakinSaveService.CreateBackup(doc.FilePath, folderName, rootDirectory);
|
||
|
||
// 3. メインファイルのチャンク再構築&書き出し
|
||
if (doc.IsCrossSaveFile)
|
||
{
|
||
if (doc.CrossSaveChunk != null && doc.RawChunks.Count > 0)
|
||
{
|
||
doc.RawChunks[0] = BakinSaveService.SerializeCrossSaveChunk(doc.CrossSaveChunk);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (doc.PartyChunk != null && doc.RawChunks.Count > 0)
|
||
{
|
||
doc.RawChunks[0] = BakinSaveService.SerializePartyChunk(doc.PartyChunk);
|
||
}
|
||
|
||
if (doc.SystemChunk != null && doc.RawChunks.Count > 1)
|
||
{
|
||
doc.RawChunks[1] = BakinSaveService.SerializeSystemDataChunk(doc.SystemChunk);
|
||
}
|
||
}
|
||
|
||
var outputBytes = BakinSaveService.WriteYukrChunks(doc.DataVersion, doc.RawChunks);
|
||
File.WriteAllBytes(doc.FilePath, outputBytes);
|
||
|
||
// 4. 付随する Save_xx.sgs 側の項目が変更されていたら、Save_xx.sgs も自動バックアップ&保存
|
||
if (!doc.IsCrossSaveFile &&
|
||
!string.IsNullOrEmpty(doc.CompanionCrossSavePath) &&
|
||
doc.CompanionCrossSaveChunk != null &&
|
||
doc.CompanionCrossSaveRawChunks.Count > 0 &&
|
||
doc.Entries.Any(e => e.BelongsToCompanionCrossSave && e.IsModified))
|
||
{
|
||
BakinSaveService.CreateBackup(doc.CompanionCrossSavePath, folderName, rootDirectory);
|
||
doc.CompanionCrossSaveRawChunks[0] = BakinSaveService.SerializeCrossSaveChunk(doc.CompanionCrossSaveChunk);
|
||
var crossOutBytes = BakinSaveService.WriteYukrChunks(doc.CompanionCrossSaveVersion, doc.CompanionCrossSaveRawChunks);
|
||
File.WriteAllBytes(doc.CompanionCrossSavePath, crossOutBytes);
|
||
}
|
||
|
||
// 5. 全エントリの OriginalValueText を更新
|
||
foreach (var entry in doc.Entries)
|
||
{
|
||
entry.CommitValue();
|
||
}
|
||
|
||
return backupPath;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 指定されたセーブファイルの最新バックアップを探して復元します。
|
||
/// </summary>
|
||
/// <param name="targetSaveFilePath">復元先のセーブファイルパス</param>
|
||
/// <param name="folderName">ゲームフォルダ名</param>
|
||
/// <param name="rootDirectory">ゲームルートディレクトリ</param>
|
||
/// <returns>(成功フラグ, メッセージ)</returns>
|
||
public static (bool Success, string Message) RestoreLatestBackup(string targetSaveFilePath, string folderName, string rootDirectory)
|
||
{
|
||
try
|
||
{
|
||
var backupDir = Path.Combine(AppPathHelper.GetGameBackupDirectory(folderName, rootDirectory), "BakinSaves");
|
||
if (!Directory.Exists(backupDir))
|
||
{
|
||
return (false, "このゲームのセーブデータバックアップはまだ作成されていません。");
|
||
}
|
||
|
||
var fileName = Path.GetFileName(targetSaveFilePath);
|
||
var candidates = Directory.GetFiles(backupDir, $"{fileName}.*.bak", SearchOption.TopDirectoryOnly)
|
||
.OrderByDescending(f => f, StringComparer.OrdinalIgnoreCase)
|
||
.ToList();
|
||
|
||
if (candidates.Count == 0)
|
||
{
|
||
return (false, $"「{fileName}」に対応するバックアップファイルが見つかりませんでした。");
|
||
}
|
||
|
||
var latestBackup = candidates[0];
|
||
File.Copy(latestBackup, targetSaveFilePath, overwrite: true);
|
||
|
||
// もし Save_xx.sgs のバックアップも存在すれば、必要に応じて案内
|
||
return (true, $"バックアップから「{fileName}」を復元しました。\n復元元: {Path.GetFileName(latestBackup)}");
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return (false, $"バックアップからの復元中にエラーが発生しました:\n{ex.Message}");
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region □メソッド(Private)
|
||
|
||
private static string CreateBackup(string filePath, string folderName, string rootDirectory)
|
||
{
|
||
var backupDir = Path.Combine(AppPathHelper.GetGameBackupDirectory(folderName, rootDirectory), "BakinSaves");
|
||
if (!Directory.Exists(backupDir))
|
||
{
|
||
Directory.CreateDirectory(backupDir);
|
||
}
|
||
|
||
string fileName = Path.GetFileName(filePath);
|
||
string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
|
||
string backupFilePath = Path.Combine(backupDir, $"{fileName}.{timestamp}.bak");
|
||
|
||
// 初回オリジナル保護用 (.orig.bak) も無ければ作成しておく
|
||
string origBackupPath = Path.Combine(backupDir, $"{fileName}.orig.bak");
|
||
if (!File.Exists(origBackupPath) && File.Exists(filePath))
|
||
{
|
||
File.Copy(filePath, origBackupPath, overwrite: false);
|
||
}
|
||
|
||
if (File.Exists(filePath))
|
||
{
|
||
File.Copy(filePath, backupFilePath, overwrite: true);
|
||
}
|
||
|
||
return backupFilePath;
|
||
}
|
||
|
||
private static string BuildQuickSummary(string filePath, FileInfo fi, bool isCross)
|
||
{
|
||
string timeStr = fi.LastWriteTime.ToString("yyyy/MM/dd HH:mm");
|
||
try
|
||
{
|
||
var bytes = File.ReadAllBytes(filePath);
|
||
var (_, chunks) = BakinSaveService.ReadYukrChunks(bytes);
|
||
if (isCross)
|
||
{
|
||
if (chunks.Count > 0 && BakinSaveService.TryParseCrossSaveChunk(chunks[0], out var cross) && cross != null)
|
||
{
|
||
return $"{fi.Name} [クロスセーブ / 共通変数: {cross.Variables.Count}個] (更新: {timeStr})";
|
||
}
|
||
return $"{fi.Name} [クロスセーブ] (更新: {timeStr})";
|
||
}
|
||
|
||
int money = 0;
|
||
int lv = 1;
|
||
int hp = 0;
|
||
int maxHp = 0;
|
||
int varCount = 0;
|
||
string extraInfo = string.Empty;
|
||
|
||
if (chunks.Count > 0 && BakinSaveService.TryParsePartyChunk(chunks[0], out var party) && party != null)
|
||
{
|
||
money = party.Money;
|
||
if (party.Members.Count > 0 && party.Members[0].HasValidHeader)
|
||
{
|
||
lv = party.Members[0].Level;
|
||
hp = party.Members[0].Hitpoint;
|
||
maxHp = party.Members[0].MaxHitpoint;
|
||
}
|
||
}
|
||
|
||
if (chunks.Count > 1 && BakinSaveService.TryParseSystemDataChunk(chunks[1], out var sys) && sys != null)
|
||
{
|
||
varCount = sys.Variables.Count;
|
||
var chapterVar = sys.Variables.FirstOrDefault(v => v.Name == "章" && v.Type == 0);
|
||
var dayVar = sys.Variables.FirstOrDefault(v => v.Name == "章日数" && v.Type == 0);
|
||
var apVar = sys.Variables.FirstOrDefault(v => v.Name == "行動力" && v.Type == 0);
|
||
var parts = new List<string>();
|
||
if (chapterVar != null) parts.Add($"第{(int)chapterVar.DoubleValue}章");
|
||
if (dayVar != null) parts.Add($"{(int)dayVar.DoubleValue}日目");
|
||
if (apVar != null) parts.Add($"行動力:{(int)apVar.DoubleValue}");
|
||
if (parts.Count > 0)
|
||
{
|
||
extraInfo = " / " + string.Join(" ", parts);
|
||
}
|
||
}
|
||
|
||
return $"{fi.Name} [所持金: {money:N0} / 先頭Lv:{lv} HP:{hp}/{maxHp}{extraInfo} / 変数:{varCount}個] (更新: {timeStr})";
|
||
}
|
||
catch
|
||
{
|
||
return $"{fi.Name} ({fi.Length:N0} bytes / 更新: {timeStr})";
|
||
}
|
||
}
|
||
|
||
private static (int Version, List<byte[]> Chunks) ReadYukrChunks(byte[] fileBytes)
|
||
{
|
||
if (fileBytes == null || fileBytes.Length < 12)
|
||
{
|
||
throw new InvalidDataException("ファイルサイズが小さすぎるため、有効な Bakin セーブデータではありません。");
|
||
}
|
||
|
||
var sig = Encoding.ASCII.GetString(fileBytes, 0, 8);
|
||
if (!string.Equals(sig, BakinSaveService.YukrSignature, StringComparison.Ordinal))
|
||
{
|
||
throw new InvalidDataException($"ヘッダシグネチャが YUKRDATA ではありません ({sig})。");
|
||
}
|
||
|
||
int version = BitConverter.ToInt32(fileBytes, 8);
|
||
var chunks = new List<byte[]>();
|
||
int pos = 12;
|
||
while (pos + 4 <= fileBytes.Length)
|
||
{
|
||
int len = BitConverter.ToInt32(fileBytes, pos);
|
||
pos += 4;
|
||
if (len < 0 || pos + len > fileBytes.Length)
|
||
{
|
||
break;
|
||
}
|
||
|
||
var chunk = new byte[len];
|
||
Buffer.BlockCopy(fileBytes, pos, chunk, 0, len);
|
||
chunks.Add(chunk);
|
||
pos += len;
|
||
}
|
||
|
||
return (version, chunks);
|
||
}
|
||
|
||
private static byte[] WriteYukrChunks(int version, List<byte[]> chunks)
|
||
{
|
||
using var ms = new MemoryStream();
|
||
using var bw = new BinaryWriter(ms, Encoding.UTF8, leaveOpen: true);
|
||
|
||
bw.Write(Encoding.ASCII.GetBytes(BakinSaveService.YukrSignature));
|
||
bw.Write(version);
|
||
|
||
foreach (var chunk in chunks)
|
||
{
|
||
bw.Write(chunk.Length);
|
||
bw.Write(chunk);
|
||
}
|
||
|
||
bw.Flush();
|
||
return ms.ToArray();
|
||
}
|
||
|
||
private static bool TryParsePartyChunk(byte[] chunkBytes, out BakinPartyChunk? result)
|
||
{
|
||
result = null;
|
||
try
|
||
{
|
||
using var ms = new MemoryStream(chunkBytes);
|
||
using var br = new BinaryReader(ms, Encoding.UTF8);
|
||
|
||
var party = new BakinPartyChunk();
|
||
|
||
int memberCount = br.ReadInt32();
|
||
if (memberCount < 0 || memberCount > 200) return false;
|
||
for (int i = 0; i < memberCount; i++)
|
||
{
|
||
int hLen = br.ReadInt32();
|
||
if (hLen < 0 || ms.Position + hLen > ms.Length) return false;
|
||
byte[] hBytes = br.ReadBytes(hLen);
|
||
party.Members.Add(BakinSaveService.ParseHeroSubChunk(hBytes));
|
||
}
|
||
|
||
int reserveCount = br.ReadInt32();
|
||
if (reserveCount < 0 || reserveCount > 500) return false;
|
||
for (int i = 0; i < reserveCount; i++)
|
||
{
|
||
int hLen = br.ReadInt32();
|
||
if (hLen < 0 || ms.Position + hLen > ms.Length) return false;
|
||
byte[] hBytes = br.ReadBytes(hLen);
|
||
party.Reserves.Add(BakinSaveService.ParseHeroSubChunk(hBytes));
|
||
}
|
||
|
||
int itemsCount = br.ReadInt32();
|
||
if (itemsCount < 0 || itemsCount > 100000) return false;
|
||
for (int i = 0; i < itemsCount; i++)
|
||
{
|
||
if (ms.Position + 20 > ms.Length) return false;
|
||
var guid = new Guid(br.ReadBytes(16));
|
||
int num = br.ReadInt32();
|
||
party.Items.Add(new BakinItemStack { ItemGuid = guid, Num = num });
|
||
}
|
||
|
||
if (ms.Position + 8 > ms.Length) return false;
|
||
party.Money = br.ReadInt32();
|
||
|
||
int itemDictCount = br.ReadInt32();
|
||
if (itemDictCount < 0 || itemDictCount > 100000) return false;
|
||
for (int i = 0; i < itemDictCount; i++)
|
||
{
|
||
if (ms.Position + 20 > ms.Length) return false;
|
||
var guid = new Guid(br.ReadBytes(16));
|
||
int num = br.ReadInt32();
|
||
party.ItemDict.Add(new BakinItemStack { ItemGuid = guid, Num = num });
|
||
}
|
||
|
||
int modInfoCount = br.ReadInt32();
|
||
if (modInfoCount < 0 || modInfoCount > 10000) return false;
|
||
for (int i = 0; i < modInfoCount; i++)
|
||
{
|
||
if (ms.Position + 48 > ms.Length) return false;
|
||
party.ModifiedInfos.Add(br.ReadBytes(48));
|
||
}
|
||
|
||
int customNameCount = br.ReadInt32();
|
||
if (customNameCount < 0 || customNameCount > 10000) return false;
|
||
for (int i = 0; i < customNameCount; i++)
|
||
{
|
||
var guid = new Guid(br.ReadBytes(16));
|
||
string name = br.ReadString();
|
||
party.CustomHeroNames.Add(new BakinCustomHeroName { HeroGuid = guid, Name = name });
|
||
}
|
||
|
||
party.InventoryMax = br.ReadInt32();
|
||
|
||
int remaining = (int)(ms.Length - ms.Position);
|
||
party.TrailingBytes = remaining > 0 ? br.ReadBytes(remaining) : Array.Empty<byte>();
|
||
|
||
result = party;
|
||
return true;
|
||
}
|
||
catch
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private static BakinHeroSubChunk ParseHeroSubChunk(byte[] rawBytes)
|
||
{
|
||
var hero = new BakinHeroSubChunk
|
||
{
|
||
RawBytes = rawBytes
|
||
};
|
||
|
||
if (rawBytes.Length >= 60)
|
||
{
|
||
var guidBytes = new byte[16];
|
||
Buffer.BlockCopy(rawBytes, 0, guidBytes, 0, 16);
|
||
hero.RomGuid = new Guid(guidBytes);
|
||
hero.Level = BitConverter.ToInt32(rawBytes, 16);
|
||
hero.MaxHitpoint = BitConverter.ToInt32(rawBytes, 20);
|
||
hero.MaxMagicpoint = BitConverter.ToInt32(rawBytes, 24);
|
||
hero.Hitpoint = BitConverter.ToInt32(rawBytes, 28);
|
||
hero.Magicpoint = BitConverter.ToInt32(rawBytes, 32);
|
||
hero.Power = BitConverter.ToInt32(rawBytes, 36);
|
||
hero.Vitality = BitConverter.ToInt32(rawBytes, 40);
|
||
hero.Magic = BitConverter.ToInt32(rawBytes, 44);
|
||
hero.Speed = BitConverter.ToInt32(rawBytes, 48);
|
||
hero.Exp = BitConverter.ToInt32(rawBytes, 52);
|
||
}
|
||
|
||
return hero;
|
||
}
|
||
|
||
private static byte[] SerializeHeroSubChunk(BakinHeroSubChunk hero)
|
||
{
|
||
if (!hero.HasValidHeader)
|
||
{
|
||
return hero.RawBytes;
|
||
}
|
||
|
||
var copy = new byte[hero.RawBytes.Length];
|
||
Buffer.BlockCopy(hero.RawBytes, 0, copy, 0, hero.RawBytes.Length);
|
||
|
||
Buffer.BlockCopy(BitConverter.GetBytes(hero.Level), 0, copy, 16, 4);
|
||
Buffer.BlockCopy(BitConverter.GetBytes(hero.MaxHitpoint), 0, copy, 20, 4);
|
||
Buffer.BlockCopy(BitConverter.GetBytes(hero.MaxMagicpoint), 0, copy, 24, 4);
|
||
Buffer.BlockCopy(BitConverter.GetBytes(hero.Hitpoint), 0, copy, 28, 4);
|
||
Buffer.BlockCopy(BitConverter.GetBytes(hero.Magicpoint), 0, copy, 32, 4);
|
||
Buffer.BlockCopy(BitConverter.GetBytes(hero.Power), 0, copy, 36, 4);
|
||
Buffer.BlockCopy(BitConverter.GetBytes(hero.Vitality), 0, copy, 40, 4);
|
||
Buffer.BlockCopy(BitConverter.GetBytes(hero.Magic), 0, copy, 44, 4);
|
||
Buffer.BlockCopy(BitConverter.GetBytes(hero.Speed), 0, copy, 48, 4);
|
||
Buffer.BlockCopy(BitConverter.GetBytes(hero.Exp), 0, copy, 52, 4);
|
||
|
||
return copy;
|
||
}
|
||
|
||
private static byte[] SerializePartyChunk(BakinPartyChunk party)
|
||
{
|
||
using var ms = new MemoryStream();
|
||
using var bw = new BinaryWriter(ms, Encoding.UTF8, leaveOpen: true);
|
||
|
||
bw.Write(party.Members.Count);
|
||
foreach (var m in party.Members)
|
||
{
|
||
var hBytes = BakinSaveService.SerializeHeroSubChunk(m);
|
||
bw.Write(hBytes.Length);
|
||
bw.Write(hBytes);
|
||
}
|
||
|
||
bw.Write(party.Reserves.Count);
|
||
foreach (var r in party.Reserves)
|
||
{
|
||
var hBytes = BakinSaveService.SerializeHeroSubChunk(r);
|
||
bw.Write(hBytes.Length);
|
||
bw.Write(hBytes);
|
||
}
|
||
|
||
bw.Write(party.Items.Count);
|
||
foreach (var item in party.Items)
|
||
{
|
||
bw.Write(item.ItemGuid.ToByteArray());
|
||
bw.Write(item.Num);
|
||
}
|
||
|
||
bw.Write(party.Money);
|
||
|
||
bw.Write(party.ItemDict.Count);
|
||
foreach (var kv in party.ItemDict)
|
||
{
|
||
bw.Write(kv.ItemGuid.ToByteArray());
|
||
bw.Write(kv.Num);
|
||
}
|
||
|
||
bw.Write(party.ModifiedInfos.Count);
|
||
foreach (var info in party.ModifiedInfos)
|
||
{
|
||
bw.Write(info);
|
||
}
|
||
|
||
bw.Write(party.CustomHeroNames.Count);
|
||
foreach (var cn in party.CustomHeroNames)
|
||
{
|
||
bw.Write(cn.HeroGuid.ToByteArray());
|
||
bw.Write(cn.Name ?? string.Empty);
|
||
}
|
||
|
||
bw.Write(party.InventoryMax);
|
||
|
||
if (party.TrailingBytes.Length > 0)
|
||
{
|
||
bw.Write(party.TrailingBytes);
|
||
}
|
||
|
||
bw.Flush();
|
||
return ms.ToArray();
|
||
}
|
||
|
||
private static bool TryParseSystemDataChunk(byte[] chunkBytes, out BakinSystemDataChunk? result)
|
||
{
|
||
result = null;
|
||
try
|
||
{
|
||
using var ms = new MemoryStream(chunkBytes);
|
||
using var br = new BinaryReader(ms, Encoding.UTF8);
|
||
|
||
var sys = new BakinSystemDataChunk();
|
||
|
||
int varCount = br.ReadInt32();
|
||
if (varCount < 0 || varCount > 100000) return false;
|
||
for (int i = 0; i < varCount; i++)
|
||
{
|
||
string name = br.ReadString();
|
||
byte type = br.ReadByte();
|
||
if (type == 0)
|
||
{
|
||
sys.Variables.Add(new BakinVariableEntry { Name = name, Type = 0, DoubleValue = br.ReadDouble() });
|
||
}
|
||
else if (type == 1)
|
||
{
|
||
sys.Variables.Add(new BakinVariableEntry { Name = name, Type = 1, StringValue = br.ReadString() });
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
sys.MenuAvailable = br.ReadBoolean();
|
||
sys.EncountAvailable = br.ReadBoolean();
|
||
sys.BgmVolume = br.ReadInt32();
|
||
sys.SeVolume = br.ReadInt32();
|
||
sys.MessageSpeed = br.ReadInt32();
|
||
sys.CursorPosition = br.ReadInt32();
|
||
sys.ControlType = br.ReadInt32();
|
||
sys.PlayTime = br.ReadSingle();
|
||
sys.SaveAvailable = br.ReadBoolean();
|
||
sys.DashAvailable = br.ReadBoolean();
|
||
sys.MoveSpeed = br.ReadInt32();
|
||
|
||
int localVarCount = br.ReadInt32();
|
||
if (localVarCount < 0 || localVarCount > 100000) return false;
|
||
for (int i = 0; i < localVarCount; i++)
|
||
{
|
||
var guid = new Guid(br.ReadBytes(16));
|
||
string name = br.ReadString();
|
||
byte type = br.ReadByte();
|
||
if (type == 0)
|
||
{
|
||
sys.LocalVariables.Add(new BakinLocalVariableEntry { EventGuid = guid, Name = name, Type = 0, DoubleValue = br.ReadDouble() });
|
||
}
|
||
else if (type == 1)
|
||
{
|
||
sys.LocalVariables.Add(new BakinLocalVariableEntry { EventGuid = guid, Name = name, Type = 1, StringValue = br.ReadString() });
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
sys.JumpAvailable = br.ReadBoolean();
|
||
|
||
int battleCamCount = br.ReadInt32();
|
||
if (battleCamCount < 0 || battleCamCount > 10000) return false;
|
||
sys.BattleCameraFlags = br.ReadBytes(battleCamCount);
|
||
|
||
int changedLayoutsCount = br.ReadInt32();
|
||
if (changedLayoutsCount < 0 || changedLayoutsCount > 10000) return false;
|
||
sys.ChangedLayoutsBytes = br.ReadBytes(changedLayoutsCount * 20);
|
||
|
||
int dynLocalVarCount = br.ReadInt32();
|
||
if (dynLocalVarCount < 0 || dynLocalVarCount > 100000) return false;
|
||
for (int i = 0; i < dynLocalVarCount; i++)
|
||
{
|
||
var guid = new Guid(br.ReadBytes(16));
|
||
string name = br.ReadString();
|
||
byte type = br.ReadByte();
|
||
if (type == 0)
|
||
{
|
||
sys.DynamicLocalVariables.Add(new BakinLocalVariableEntry { EventGuid = guid, Name = name, Type = 0, DoubleValue = br.ReadDouble() });
|
||
}
|
||
else if (type == 1)
|
||
{
|
||
sys.DynamicLocalVariables.Add(new BakinLocalVariableEntry { EventGuid = guid, Name = name, Type = 1, StringValue = br.ReadString() });
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
int arrayCount = br.ReadInt32();
|
||
if (arrayCount < 0 || arrayCount > 100000) return false;
|
||
for (int i = 0; i < arrayCount; i++)
|
||
{
|
||
string arrName = br.ReadString();
|
||
int elemCount = br.ReadInt32();
|
||
if (elemCount < 0 || elemCount > 100000) return false;
|
||
var arrEntry = new BakinVariableArrayEntry { ArrayName = arrName };
|
||
for (int j = 0; j < elemCount; j++)
|
||
{
|
||
int idx = br.ReadInt32();
|
||
byte type = br.ReadByte();
|
||
if (type == 0)
|
||
{
|
||
arrEntry.Elements.Add(new BakinVariableArrayElement { Index = idx, Type = 0, DoubleValue = br.ReadDouble() });
|
||
}
|
||
else if (type == 1)
|
||
{
|
||
arrEntry.Elements.Add(new BakinVariableArrayElement { Index = idx, Type = 1, StringValue = br.ReadString() });
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
sys.VariableArrays.Add(arrEntry);
|
||
}
|
||
|
||
int remaining = (int)(ms.Length - ms.Position);
|
||
sys.TrailingBytes = remaining > 0 ? br.ReadBytes(remaining) : Array.Empty<byte>();
|
||
|
||
result = sys;
|
||
return true;
|
||
}
|
||
catch
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private static byte[] SerializeSystemDataChunk(BakinSystemDataChunk sys)
|
||
{
|
||
using var ms = new MemoryStream();
|
||
using var bw = new BinaryWriter(ms, Encoding.UTF8, leaveOpen: true);
|
||
|
||
bw.Write(sys.Variables.Count);
|
||
foreach (var v in sys.Variables)
|
||
{
|
||
bw.Write(v.Name ?? string.Empty);
|
||
bw.Write(v.Type);
|
||
if (v.Type == 0)
|
||
{
|
||
bw.Write(v.DoubleValue);
|
||
}
|
||
else
|
||
{
|
||
bw.Write(v.StringValue ?? string.Empty);
|
||
}
|
||
}
|
||
|
||
bw.Write(sys.MenuAvailable);
|
||
bw.Write(sys.EncountAvailable);
|
||
bw.Write(sys.BgmVolume);
|
||
bw.Write(sys.SeVolume);
|
||
bw.Write(sys.MessageSpeed);
|
||
bw.Write(sys.CursorPosition);
|
||
bw.Write(sys.ControlType);
|
||
bw.Write(sys.PlayTime);
|
||
bw.Write(sys.SaveAvailable);
|
||
bw.Write(sys.DashAvailable);
|
||
bw.Write(sys.MoveSpeed);
|
||
|
||
bw.Write(sys.LocalVariables.Count);
|
||
foreach (var lv in sys.LocalVariables)
|
||
{
|
||
bw.Write(lv.EventGuid.ToByteArray());
|
||
bw.Write(lv.Name ?? string.Empty);
|
||
bw.Write(lv.Type);
|
||
if (lv.Type == 0)
|
||
{
|
||
bw.Write(lv.DoubleValue);
|
||
}
|
||
else
|
||
{
|
||
bw.Write(lv.StringValue ?? string.Empty);
|
||
}
|
||
}
|
||
|
||
bw.Write(sys.JumpAvailable);
|
||
|
||
bw.Write(sys.BattleCameraFlags.Length);
|
||
bw.Write(sys.BattleCameraFlags);
|
||
|
||
bw.Write(sys.ChangedLayoutsBytes.Length / 20);
|
||
bw.Write(sys.ChangedLayoutsBytes);
|
||
|
||
bw.Write(sys.DynamicLocalVariables.Count);
|
||
foreach (var dlv in sys.DynamicLocalVariables)
|
||
{
|
||
bw.Write(dlv.EventGuid.ToByteArray());
|
||
bw.Write(dlv.Name ?? string.Empty);
|
||
bw.Write(dlv.Type);
|
||
if (dlv.Type == 0)
|
||
{
|
||
bw.Write(dlv.DoubleValue);
|
||
}
|
||
else
|
||
{
|
||
bw.Write(dlv.StringValue ?? string.Empty);
|
||
}
|
||
}
|
||
|
||
bw.Write(sys.VariableArrays.Count);
|
||
foreach (var arr in sys.VariableArrays)
|
||
{
|
||
bw.Write(arr.ArrayName ?? string.Empty);
|
||
bw.Write(arr.Elements.Count);
|
||
foreach (var elem in arr.Elements)
|
||
{
|
||
bw.Write(elem.Index);
|
||
bw.Write(elem.Type);
|
||
if (elem.Type == 0)
|
||
{
|
||
bw.Write(elem.DoubleValue);
|
||
}
|
||
else
|
||
{
|
||
bw.Write(elem.StringValue ?? string.Empty);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (sys.TrailingBytes.Length > 0)
|
||
{
|
||
bw.Write(sys.TrailingBytes);
|
||
}
|
||
|
||
bw.Flush();
|
||
return ms.ToArray();
|
||
}
|
||
|
||
private static bool TryParseCrossSaveChunk(byte[] chunkBytes, out BakinCrossSaveChunk? result)
|
||
{
|
||
result = null;
|
||
try
|
||
{
|
||
using var ms = new MemoryStream(chunkBytes);
|
||
using var br = new BinaryReader(ms, Encoding.UTF8);
|
||
|
||
int count = br.ReadInt32();
|
||
if (count < 0 || count > 100000) return false;
|
||
|
||
var cross = new BakinCrossSaveChunk();
|
||
for (int i = 0; i < count; i++)
|
||
{
|
||
string name = br.ReadString();
|
||
byte type = br.ReadByte();
|
||
if (type == 0)
|
||
{
|
||
cross.Variables.Add(new BakinVariableEntry { Name = name, Type = 0, DoubleValue = br.ReadDouble() });
|
||
}
|
||
else if (type == 1)
|
||
{
|
||
cross.Variables.Add(new BakinVariableEntry { Name = name, Type = 1, StringValue = br.ReadString() });
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
if (ms.Position != ms.Length)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
result = cross;
|
||
return true;
|
||
}
|
||
catch
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private static byte[] SerializeCrossSaveChunk(BakinCrossSaveChunk cross)
|
||
{
|
||
using var ms = new MemoryStream();
|
||
using var bw = new BinaryWriter(ms, Encoding.UTF8, leaveOpen: true);
|
||
|
||
bw.Write(cross.Variables.Count);
|
||
foreach (var v in cross.Variables)
|
||
{
|
||
bw.Write(v.Name ?? string.Empty);
|
||
bw.Write(v.Type);
|
||
if (v.Type == 0)
|
||
{
|
||
bw.Write(v.DoubleValue);
|
||
}
|
||
else
|
||
{
|
||
bw.Write(v.StringValue ?? string.Empty);
|
||
}
|
||
}
|
||
|
||
bw.Flush();
|
||
return ms.ToArray();
|
||
}
|
||
|
||
private static void PopulateStandardSaveEntries(BakinSaveDocument doc)
|
||
{
|
||
var party = doc.PartyChunk;
|
||
var sys = doc.SystemChunk;
|
||
|
||
// 1. 基本・システム設定
|
||
if (party != null)
|
||
{
|
||
BakinSaveService.AddIntEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryBasic,
|
||
"💰 所持金 (Money)",
|
||
"Party.Money",
|
||
party.Money,
|
||
val => party.Money = val);
|
||
|
||
BakinSaveService.AddIntEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryBasic,
|
||
"🎒 最大インベントリ枠数 (InventoryMax)",
|
||
"Party.InventoryMax",
|
||
party.InventoryMax,
|
||
val => party.InventoryMax = val);
|
||
|
||
for (int i = 0; i < party.CustomHeroNames.Count; i++)
|
||
{
|
||
var cn = party.CustomHeroNames[i];
|
||
int idx = i + 1;
|
||
BakinSaveService.AddStringEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryBasic,
|
||
$"🏷️ カスタムキャラ名 #{idx} ({cn.HeroGuid.ToString()[..8]})",
|
||
$"Party.CustomHeroName[{i}]",
|
||
cn.Name,
|
||
val => cn.Name = val);
|
||
}
|
||
}
|
||
|
||
if (sys != null)
|
||
{
|
||
BakinSaveService.AddFloatEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryBasic,
|
||
"⏱️ プレイ時間 (秒)",
|
||
"System.PlayTime",
|
||
sys.PlayTime,
|
||
val => sys.PlayTime = val);
|
||
|
||
BakinSaveService.AddBoolEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryBasic,
|
||
"📋 メニュー画面の開閉許可 (MenuAvailable)",
|
||
"System.MenuAvailable",
|
||
sys.MenuAvailable,
|
||
val => sys.MenuAvailable = val);
|
||
|
||
BakinSaveService.AddBoolEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryBasic,
|
||
"💾 いつでもセーブ許可 (SaveAvailable)",
|
||
"System.SaveAvailable",
|
||
sys.SaveAvailable,
|
||
val => sys.SaveAvailable = val);
|
||
|
||
BakinSaveService.AddBoolEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryBasic,
|
||
"👾 ランダムエンカウント発生 (EncountAvailable)",
|
||
"System.EncountAvailable",
|
||
sys.EncountAvailable,
|
||
val => sys.EncountAvailable = val);
|
||
|
||
BakinSaveService.AddBoolEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryBasic,
|
||
"🏃 ダッシュ許可 (DashAvailable)",
|
||
"System.DashAvailable",
|
||
sys.DashAvailable,
|
||
val => sys.DashAvailable = val);
|
||
|
||
BakinSaveService.AddBoolEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryBasic,
|
||
"🦘 ジャンプ許可 (JumpAvailable)",
|
||
"System.JumpAvailable",
|
||
sys.JumpAvailable,
|
||
val => sys.JumpAvailable = val);
|
||
|
||
BakinSaveService.AddIntEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryBasic,
|
||
"👟 移動速度レベル (MoveSpeed)",
|
||
"System.MoveSpeed",
|
||
sys.MoveSpeed,
|
||
val => sys.MoveSpeed = val);
|
||
}
|
||
|
||
// 2. パーティ・キャラクターステータス
|
||
if (party != null)
|
||
{
|
||
for (int i = 0; i < party.Members.Count; i++)
|
||
{
|
||
var hero = party.Members[i];
|
||
string customName = party.CustomHeroNames.FirstOrDefault(c => c.HeroGuid == hero.RomGuid)?.Name ?? string.Empty;
|
||
string labelPrefix = string.IsNullOrEmpty(customName)
|
||
? $"パーティ[{i + 1}] (ID:{hero.RomGuid.ToString()[..8]})"
|
||
: $"パーティ[{i + 1}] {customName}";
|
||
|
||
BakinSaveService.AddHeroEntries(doc.Entries, hero, labelPrefix, $"Party.Members[{i}]");
|
||
}
|
||
|
||
for (int i = 0; i < party.Reserves.Count; i++)
|
||
{
|
||
var hero = party.Reserves[i];
|
||
string customName = party.CustomHeroNames.FirstOrDefault(c => c.HeroGuid == hero.RomGuid)?.Name ?? string.Empty;
|
||
string labelPrefix = string.IsNullOrEmpty(customName)
|
||
? $"控えメンバー[{i + 1}] (ID:{hero.RomGuid.ToString()[..8]})"
|
||
: $"控えメンバー[{i + 1}] {customName}";
|
||
|
||
BakinSaveService.AddHeroEntries(doc.Entries, hero, labelPrefix, $"Party.Reserves[{i}]");
|
||
}
|
||
|
||
// 3. 所持アイテム(items と itemDict の両方を同期更新)
|
||
var allItemGuids = party.Items.Select(x => x.ItemGuid)
|
||
.Concat(party.ItemDict.Select(x => x.ItemGuid))
|
||
.Distinct()
|
||
.ToList();
|
||
|
||
for (int i = 0; i < allItemGuids.Count; i++)
|
||
{
|
||
Guid guid = allItemGuids[i];
|
||
var itemSlot = party.Items.FirstOrDefault(x => x.ItemGuid == guid);
|
||
var dictSlot = party.ItemDict.FirstOrDefault(x => x.ItemGuid == guid);
|
||
int currentNum = itemSlot?.Num ?? dictSlot?.Num ?? 0;
|
||
int slotIndex = i + 1;
|
||
|
||
BakinSaveService.AddIntEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryItems,
|
||
$"🎒 所持アイテム #{slotIndex:D2} (GUID: {guid})",
|
||
$"Party.Item[{guid}]",
|
||
currentNum,
|
||
val =>
|
||
{
|
||
foreach (var it in party.Items.Where(x => x.ItemGuid == guid))
|
||
{
|
||
it.Num = val;
|
||
}
|
||
foreach (var dt in party.ItemDict.Where(x => x.ItemGuid == guid))
|
||
{
|
||
dt.Num = val;
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
// 4. ゲーム変数 (Variables)
|
||
if (sys != null)
|
||
{
|
||
for (int i = 0; i < sys.Variables.Count; i++)
|
||
{
|
||
var v = sys.Variables[i];
|
||
int varIdx = i;
|
||
if (v.Type == 0)
|
||
{
|
||
BakinSaveService.AddDoubleEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryVariables,
|
||
$"変数[{varIdx:D3}] {v.Name}",
|
||
$"System.Variables[{varIdx}]({v.Name})",
|
||
v.DoubleValue,
|
||
val => v.DoubleValue = val);
|
||
}
|
||
else
|
||
{
|
||
BakinSaveService.AddStringEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryVariables,
|
||
$"変数[{varIdx:D3}] {v.Name}",
|
||
$"System.Variables[{varIdx}]({v.Name})",
|
||
v.StringValue,
|
||
val => v.StringValue = val);
|
||
}
|
||
}
|
||
|
||
// 5. 配列変数 (VariableArrays)
|
||
foreach (var arr in sys.VariableArrays)
|
||
{
|
||
foreach (var elem in arr.Elements)
|
||
{
|
||
var targetElem = elem;
|
||
if (targetElem.Type == 0)
|
||
{
|
||
BakinSaveService.AddDoubleEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryArrays,
|
||
$"配列 {arr.ArrayName}[{targetElem.Index}]",
|
||
$"System.VariableArrays[{arr.ArrayName}][{targetElem.Index}]",
|
||
targetElem.DoubleValue,
|
||
val => targetElem.DoubleValue = val);
|
||
}
|
||
else
|
||
{
|
||
BakinSaveService.AddStringEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryArrays,
|
||
$"配列 {arr.ArrayName}[{targetElem.Index}]",
|
||
$"System.VariableArrays[{arr.ArrayName}][{targetElem.Index}]",
|
||
targetElem.StringValue,
|
||
val => targetElem.StringValue = val);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 6. ローカル変数 (LocalVariables)
|
||
for (int i = 0; i < sys.LocalVariables.Count; i++)
|
||
{
|
||
var lv = sys.LocalVariables[i];
|
||
string shortGuid = lv.EventGuid.ToString()[..8];
|
||
if (lv.Type == 0)
|
||
{
|
||
BakinSaveService.AddDoubleEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryLocalVars,
|
||
$"ローカル変数 ({shortGuid}) {lv.Name}",
|
||
$"System.LocalVariables[{i}]",
|
||
lv.DoubleValue,
|
||
val => lv.DoubleValue = val);
|
||
}
|
||
else
|
||
{
|
||
BakinSaveService.AddStringEntry(
|
||
doc.Entries,
|
||
BakinSaveService.CategoryLocalVars,
|
||
$"ローカル変数 ({shortGuid}) {lv.Name}",
|
||
$"System.LocalVariables[{i}]",
|
||
lv.StringValue,
|
||
val => lv.StringValue = val);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private static void PopulateCrossSaveEntries(BakinSaveDocument doc, BakinCrossSaveChunk crossChunk, bool isCompanion)
|
||
{
|
||
for (int i = 0; i < crossChunk.Variables.Count; i++)
|
||
{
|
||
var v = crossChunk.Variables[i];
|
||
int idx = i;
|
||
string prefix = isCompanion ? "🌐 共通(Save_xx)" : "🌐 クロスセーブ変数";
|
||
if (v.Type == 0)
|
||
{
|
||
var entry = BakinSaveService.CreateDoubleEntry(
|
||
BakinSaveService.CategoryCrossSave,
|
||
$"{prefix}[{idx:D2}] {v.Name}",
|
||
$"CrossSave.Variables[{idx}]({v.Name})",
|
||
v.DoubleValue,
|
||
val => v.DoubleValue = val);
|
||
entry.BelongsToCompanionCrossSave = isCompanion;
|
||
doc.Entries.Add(entry);
|
||
}
|
||
else
|
||
{
|
||
var entry = BakinSaveService.CreateStringEntry(
|
||
BakinSaveService.CategoryCrossSave,
|
||
$"{prefix}[{idx:D2}] {v.Name}",
|
||
$"CrossSave.Variables[{idx}]({v.Name})",
|
||
v.StringValue,
|
||
val => v.StringValue = val);
|
||
entry.BelongsToCompanionCrossSave = isCompanion;
|
||
doc.Entries.Add(entry);
|
||
}
|
||
}
|
||
}
|
||
|
||
private static void AddHeroEntries(List<BakinSaveEntry> entries, BakinHeroSubChunk hero, string labelPrefix, string keyPrefix)
|
||
{
|
||
if (!hero.HasValidHeader)
|
||
{
|
||
return;
|
||
}
|
||
|
||
BakinSaveService.AddIntEntry(entries, BakinSaveService.CategoryParty, $"{labelPrefix} - レベル (Lv)", $"{keyPrefix}.Level", hero.Level, v => hero.Level = v);
|
||
BakinSaveService.AddIntEntry(entries, BakinSaveService.CategoryParty, $"{labelPrefix} - 経験値 (EXP)", $"{keyPrefix}.Exp", hero.Exp, v => hero.Exp = v);
|
||
BakinSaveService.AddIntEntry(entries, BakinSaveService.CategoryParty, $"{labelPrefix} - 現在HP", $"{keyPrefix}.HP", hero.Hitpoint, v => hero.Hitpoint = v);
|
||
BakinSaveService.AddIntEntry(entries, BakinSaveService.CategoryParty, $"{labelPrefix} - 最大HP (MaxHP)", $"{keyPrefix}.MaxHP", hero.MaxHitpoint, v => hero.MaxHitpoint = v);
|
||
BakinSaveService.AddIntEntry(entries, BakinSaveService.CategoryParty, $"{labelPrefix} - 現在MP", $"{keyPrefix}.MP", hero.Magicpoint, v => hero.Magicpoint = v);
|
||
BakinSaveService.AddIntEntry(entries, BakinSaveService.CategoryParty, $"{labelPrefix} - 最大MP (MaxMP)", $"{keyPrefix}.MaxMP", hero.MaxMagicpoint, v => hero.MaxMagicpoint = v);
|
||
BakinSaveService.AddIntEntry(entries, BakinSaveService.CategoryParty, $"{labelPrefix} - 攻撃力 / 力 (Power)", $"{keyPrefix}.Power", hero.Power, v => hero.Power = v);
|
||
BakinSaveService.AddIntEntry(entries, BakinSaveService.CategoryParty, $"{labelPrefix} - 防御力 / 体力 (Vitality)", $"{keyPrefix}.Vitality", hero.Vitality, v => hero.Vitality = v);
|
||
BakinSaveService.AddIntEntry(entries, BakinSaveService.CategoryParty, $"{labelPrefix} - 魔力 (Magic)", $"{keyPrefix}.Magic", hero.Magic, v => hero.Magic = v);
|
||
BakinSaveService.AddIntEntry(entries, BakinSaveService.CategoryParty, $"{labelPrefix} - 素早さ / 敏捷 (Speed)", $"{keyPrefix}.Speed", hero.Speed, v => hero.Speed = v);
|
||
}
|
||
|
||
private static void AddIntEntry(List<BakinSaveEntry> list, string category, string displayKey, string internalKey, int initialValue, Action<int> setter)
|
||
{
|
||
var entry = new BakinSaveEntry
|
||
{
|
||
Category = category,
|
||
DisplayKey = displayKey,
|
||
ValueType = "Int32",
|
||
InternalKey = internalKey,
|
||
ApplyAction = text =>
|
||
{
|
||
if (int.TryParse(text.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out int parsed))
|
||
{
|
||
setter(parsed);
|
||
}
|
||
else if (double.TryParse(text.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out double dParsed))
|
||
{
|
||
setter((int)Math.Clamp(dParsed, int.MinValue, int.MaxValue));
|
||
}
|
||
}
|
||
};
|
||
entry.SetInitialValue(initialValue.ToString(CultureInfo.InvariantCulture));
|
||
list.Add(entry);
|
||
}
|
||
|
||
private static void AddDoubleEntry(List<BakinSaveEntry> list, string category, string displayKey, string internalKey, double initialValue, Action<double> setter)
|
||
{
|
||
list.Add(BakinSaveService.CreateDoubleEntry(category, displayKey, internalKey, initialValue, setter));
|
||
}
|
||
|
||
private static BakinSaveEntry CreateDoubleEntry(string category, string displayKey, string internalKey, double initialValue, Action<double> setter)
|
||
{
|
||
var entry = new BakinSaveEntry
|
||
{
|
||
Category = category,
|
||
DisplayKey = displayKey,
|
||
ValueType = "Double",
|
||
InternalKey = internalKey,
|
||
ApplyAction = text =>
|
||
{
|
||
if (double.TryParse(text.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out double parsed))
|
||
{
|
||
setter(parsed);
|
||
}
|
||
}
|
||
};
|
||
entry.SetInitialValue(initialValue.ToString("G17", CultureInfo.InvariantCulture));
|
||
return entry;
|
||
}
|
||
|
||
private static void AddFloatEntry(List<BakinSaveEntry> list, string category, string displayKey, string internalKey, float initialValue, Action<float> setter)
|
||
{
|
||
var entry = new BakinSaveEntry
|
||
{
|
||
Category = category,
|
||
DisplayKey = displayKey,
|
||
ValueType = "Single",
|
||
InternalKey = internalKey,
|
||
ApplyAction = text =>
|
||
{
|
||
if (float.TryParse(text.Trim(), NumberStyles.Float, CultureInfo.InvariantCulture, out float parsed))
|
||
{
|
||
setter(parsed);
|
||
}
|
||
}
|
||
};
|
||
entry.SetInitialValue(initialValue.ToString("G9", CultureInfo.InvariantCulture));
|
||
list.Add(entry);
|
||
}
|
||
|
||
private static void AddBoolEntry(List<BakinSaveEntry> list, string category, string displayKey, string internalKey, bool initialValue, Action<bool> setter)
|
||
{
|
||
var entry = new BakinSaveEntry
|
||
{
|
||
Category = category,
|
||
DisplayKey = displayKey,
|
||
ValueType = "Boolean",
|
||
InternalKey = internalKey,
|
||
ApplyAction = text =>
|
||
{
|
||
var t = text.Trim();
|
||
if (bool.TryParse(t, out bool b))
|
||
{
|
||
setter(b);
|
||
}
|
||
else if (t == "1" || string.Equals(t, "on", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
setter(true);
|
||
}
|
||
else if (t == "0" || string.Equals(t, "off", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
setter(false);
|
||
}
|
||
}
|
||
};
|
||
entry.SetInitialValue(initialValue ? "True" : "False");
|
||
list.Add(entry);
|
||
}
|
||
|
||
private static void AddStringEntry(List<BakinSaveEntry> list, string category, string displayKey, string internalKey, string initialValue, Action<string> setter)
|
||
{
|
||
list.Add(BakinSaveService.CreateStringEntry(category, displayKey, internalKey, initialValue, setter));
|
||
}
|
||
|
||
private static BakinSaveEntry CreateStringEntry(string category, string displayKey, string internalKey, string initialValue, Action<string> setter)
|
||
{
|
||
var entry = new BakinSaveEntry
|
||
{
|
||
Category = category,
|
||
DisplayKey = displayKey,
|
||
ValueType = "String",
|
||
InternalKey = internalKey,
|
||
ApplyAction = text => setter(text ?? string.Empty)
|
||
};
|
||
entry.SetInitialValue(initialValue ?? string.Empty);
|
||
return entry;
|
||
}
|
||
|
||
#endregion
|
||
}
|
||
}
|