Files
GameLauncher/Engines/Evb/EvbUnpackService.cs
armonica ae86b53147 スタイル: コーディング規約に準拠したコードフォーマットの適用(this.の明示、空白スタイルの統一)
- 自インスタンスメンバーアクセスへの this. 付与(28ファイル)
- .editorconfig に準拠したインデント・波括弧・空白スタイルの適用
- UTF-8 (BOMあり)、CRLF改行コード、行末空白除去の整合性検証
2026-10-20 10:14:26 +09:00

439 lines
18 KiB
C#

using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Threading;
using GameLauncher.Engines.Common;
namespace GameLauncher.Engines.Evb
{
/// <summary>
/// Orchestrates detection and unpacking of Enigma Virtual Box (EVB) packed games,
/// then re-detects the real engine from the unpacked content.
///
/// Design (per AGENTS.md):
/// - Everything engine-local lives under `Engines/Evb/`.
/// - The original packed exe is backed up (`.glbak`) before being replaced, so the
/// operation can always be restored (Enigma recovery / manual restore).
/// - Unpacked output is written into a game-local `_evb_extracted` folder, so no
/// other game is ever affected.
/// - The bundled evbunpack tool (see <see cref="EvbUnpackerToolProvider"/>) does the work;
/// if it is missing the operation degrades gracefully (returns a failed result).
/// </summary>
public sealed class EvbUnpackService
{
/// <summary>Game-local folder that receives the unpacked files.</summary>
public const string ExtractedDirName = "_evb_extracted";
/// <summary>Marker file written last when an extraction finished successfully.</summary>
public const string CompleteMarkerName = ".evb_complete";
/// <summary>Backup suffix applied to the original packed executable.</summary>
public const string ExeBackupSuffix = ".glbak";
/// <summary>Result of an unpack attempt.</summary>
public sealed class UnpackResult
{
/// <summary>True when unpacking produced usable output.</summary>
public bool Success { get; init; }
/// <summary>Folder that contains the unpacked files (null on failure).</summary>
public string? OutputDirectory { get; init; }
/// <summary>Absolute path of the original packed executable (null when not found).</summary>
public string? SourceExePath { get; init; }
/// <summary>Absolute path of the backed-up original executable (null when no backup was made).</summary>
public string? BackupExePath { get; init; }
/// <summary>Engine name re-detected from the unpacked content (canonical name).</summary>
public string UnderlyingEngine { get; init; } = EngineDetectionHelper.EngineUnknown;
/// <summary>Human-readable message describing the outcome.</summary>
public string Message { get; init; } = string.Empty;
/// <summary>True when output was already present and re-used (idempotent skip).</summary>
public bool ReusedExisting { get; init; }
}
/// <summary>Game-local extraction folder for the given game root.</summary>
public static string GetExtractedDir(string gameRootDir)
=> Path.Combine(gameRootDir, ExtractedDirName);
/// <summary>Marker file path inside the extraction folder.</summary>
public static string GetCompleteMarkerPath(string outputDirectory)
=> Path.Combine(outputDirectory, CompleteMarkerName);
/// <summary>
/// Resolves the executable to launch from an unpacked output folder.
/// Prefers a well-known game exe name, then the first `.exe` found (top level first,
/// then one level deep). Returns null when nothing usable is found.
/// </summary>
public static string? FindLaunchExecutable(string? outputDirectory)
{
if (string.IsNullOrWhiteSpace(outputDirectory) || !Directory.Exists(outputDirectory))
{
return null;
}
try
{
// Preferred names commonly used by NW.js / RPG Maker / Tyrano bundles.
string[] preferred = ["Game.exe", "game.exe", "nw.exe", "Game_boxed.exe"];
foreach (var name in preferred)
{
var direct = Path.Combine(outputDirectory, name);
if (File.Exists(direct))
{
return direct;
}
}
// First exe at the top level, then one level deeper.
var top = Directory.GetFiles(outputDirectory, "*.exe", SearchOption.TopDirectoryOnly);
if (top.Length > 0)
{
return top[0];
}
foreach (var sub in Directory.GetDirectories(outputDirectory))
{
var nested = Directory.GetFiles(sub, "*.exe", SearchOption.TopDirectoryOnly);
if (nested.Length > 0)
{
return nested[0];
}
}
}
catch
{
// Ignore IO errors and fall back to no result.
}
return null;
}
/// <summary>
/// True when the game folder already holds a completed EVB extraction.
/// A non-empty output folder is NOT enough: the run may have been interrupted,
/// so the presence of the completion marker is required.
/// </summary>
public static bool IsExtractionComplete(string gameRootDir, out string? outputDirectory)
{
outputDirectory = GetExtractedDir(gameRootDir);
try
{
return Directory.Exists(outputDirectory) &&
File.Exists(GetCompleteMarkerPath(outputDirectory));
}
catch
{
return false;
}
}
/// <summary>
/// Unpacks the EVB-packed executable in the game folder and re-detects the
/// underlying engine. Idempotent: a completed prior extraction is re-used.
/// </summary>
/// <param name="gameRootDir">Game root folder containing the packed exe.</param>
/// <param name="progress">Optional progress sink.</param>
public UnpackResult Unpack(
string gameRootDir,
IProgress<string>? progress = null,
bool legacyFileSystem = false,
string? peVariant = null)
{
if (string.IsNullOrWhiteSpace(gameRootDir) || !Directory.Exists(gameRootDir))
{
return new UnpackResult { Success = false, Message = "ゲームフォルダが見つかりません。" };
}
// Idempotent: reuse a previous successful extraction.
if (IsExtractionComplete(gameRootDir, out var existingDir) && existingDir != null)
{
var reusedEngine = EngineDetectionHelper.RepairMisdetection(
existingDir, EngineDetectionHelper.EngineUnknown);
return new UnpackResult
{
Success = true,
OutputDirectory = existingDir,
UnderlyingEngine = reusedEngine,
ReusedExisting = true,
Message = $"既に解凍済みです({ExtractedDirName} を再利用)。",
};
}
var sourceExe = EvbDetectionHelper.FindEvbPackedExecutable(gameRootDir);
if (sourceExe == null)
{
return new UnpackResult
{
Success = false,
Message = "EVB パック済みの実行ファイルが見つかりませんでした。",
};
}
var toolPath = EvbUnpackerToolProvider.GetToolPath();
if (toolPath == null)
{
return new UnpackResult
{
Success = false,
SourceExePath = sourceExe,
Message = "解凍ツール (evbunpack) が見つかりません。Engines\\Evb\\Tools\\evbunpack\\ に配置してください。",
};
}
var outputDir = GetExtractedDir(gameRootDir);
try
{
// Start clean so partial output never mixes with a fresh run.
if (Directory.Exists(outputDir))
{
Directory.Delete(outputDir, recursive: true);
}
Directory.CreateDirectory(outputDir);
progress?.Report($"EVB 解凍を開始します: {Path.GetFileName(sourceExe)}");
var args = EvbUnpackerToolProvider.BuildArguments(sourceExe, outputDir, legacyFileSystem, peVariant);
if (!RunTool(toolPath, args, gameRootDir, progress, out var exitCode))
{
return new UnpackResult
{
Success = false,
SourceExePath = sourceExe,
OutputDirectory = outputDir,
Message = $"evbunpack の実行に失敗しました (exit code={exitCode})。",
};
}
if (!Directory.EnumerateFileSystemEntries(outputDir).Any())
{
return new UnpackResult
{
Success = false,
SourceExePath = sourceExe,
OutputDirectory = outputDir,
Message = "解凍は実行されましたが出力が空でした。PE バリアント (-pe 10_70 / 7_80) を変えて再試行してください。",
};
}
// Move the original packed exe out of the way so it is no longer recognized
// as an executable by the scanner (`.glbak` is not scanned as `*.exe`).
string? backupPath = null;
try
{
backupPath = sourceExe + ExeBackupSuffix;
if (File.Exists(backupPath))
{
// A previous backup exists; remove it so the move can succeed.
File.Delete(backupPath);
}
File.Move(sourceExe, backupPath);
progress?.Report($"元の実行ファイルを退避しました: {Path.GetFileName(backupPath)}");
}
catch (Exception ex)
{
progress?.Report($"バックアップに失敗しました(解凍自体は成功): {ex.Message}");
}
// Completion marker is written last, so an interrupted run is detectable.
File.WriteAllText(GetCompleteMarkerPath(outputDir), DateTime.UtcNow.ToString("o"));
// Re-detect the real engine from the unpacked content.
var underlying = ReDetectUnderlyingEngine(outputDir);
progress?.Report($"解凍後のエンジン再判定: {underlying}");
return new UnpackResult
{
Success = true,
OutputDirectory = outputDir,
SourceExePath = sourceExe,
BackupExePath = backupPath,
UnderlyingEngine = underlying,
Message = $"EVB 解凍が完了しました(再判定エンジン: {underlying})。",
};
}
catch (Exception ex)
{
return new UnpackResult
{
Success = false,
SourceExePath = sourceExe,
OutputDirectory = outputDir,
Message = $"EVB 解凍中にエラーが発生しました: {ex.Message}",
};
}
}
/// <summary>
/// Restores a previously unpacked game by removing the extraction output and
/// the backup copy is kept intact for the user. Returns true when something
/// was restored.
/// </summary>
public static bool Restore(string gameRootDir, IProgress<string>? progress = null)
{
if (string.IsNullOrWhiteSpace(gameRootDir) || !Directory.Exists(gameRootDir))
{
return false;
}
var restored = false;
var outputDir = GetExtractedDir(gameRootDir);
try
{
if (Directory.Exists(outputDir))
{
Directory.Delete(outputDir, recursive: true);
progress?.Report($"解凍フォルダを削除しました: {ExtractedDirName}");
restored = true;
}
}
catch (Exception ex)
{
progress?.Report($"解凍フォルダの削除に失敗しました: {ex.Message}");
}
// Restore the renamed backup back to its original `.exe` name.
try
{
foreach (var backup in Directory.GetFiles(gameRootDir, "*" + ExeBackupSuffix))
{
var original = backup[..^ExeBackupSuffix.Length];
if (!File.Exists(original))
{
File.Move(backup, original);
progress?.Report($"元の実行ファイルを復元しました: {Path.GetFileName(original)}");
restored = true;
}
}
}
catch (Exception ex)
{
progress?.Report($"元の実行ファイルの復元に失敗しました: {ex.Message}");
}
return restored;
}
/// <summary>
/// Runs the detection helper against the unpacked folder to determine the real engine.
/// </summary>
private static string ReDetectUnderlyingEngine(string outputDir)
{
var engine = EngineDetectionHelper.RepairMisdetection(
outputDir, EngineDetectionHelper.EngineUnknown);
// If the flat output still hides the engine, probe its immediate subfolders
// (evbunpack may keep the original layout one level down).
if (engine == EngineDetectionHelper.EngineUnknown)
{
try
{
foreach (var sub in Directory.GetDirectories(outputDir))
{
var candidate = EngineDetectionHelper.RepairMisdetection(
sub, EngineDetectionHelper.EngineUnknown);
if (candidate != EngineDetectionHelper.EngineUnknown)
{
return candidate;
}
}
}
catch { }
}
return engine;
}
/// <summary>Runs evbunpack with ArgumentList (no manual quoting) and waits for exit.</summary>
private static bool RunTool(
string toolPath,
System.Collections.Generic.IReadOnlyList<string> args,
string workingDir,
IProgress<string>? progress,
out int exitCode)
{
exitCode = -1;
try
{
var psi = new ProcessStartInfo
{
FileName = toolPath,
WorkingDirectory = workingDir,
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
};
foreach (var arg in args)
{
psi.ArgumentList.Add(arg);
}
// Throttle progress reporting: evbunpack emits thousands of lines on large
// bundles, and every Report() is marshalled onto the UI thread. Reporting
// each line saturates the UI and makes the window appear frozen, so only the
// latest line is reported at most a few times per second.
var throttle = Stopwatch.StartNew();
var lastReportUtc = DateTime.MinValue;
var lastLine = string.Empty;
void ReportThrottled(string? data)
{
if (string.IsNullOrWhiteSpace(data))
{
return;
}
lastLine = data!;
var now = DateTime.UtcNow;
if (now - lastReportUtc >= TimeSpan.FromMilliseconds(400))
{
lastReportUtc = now;
progress?.Report(data!);
}
}
using var proc = Process.Start(psi);
if (proc == null)
{
return false;
}
proc.OutputDataReceived += (_, e) => ReportThrottled(e.Data);
proc.ErrorDataReceived += (_, e) => ReportThrottled(e.Data);
proc.BeginOutputReadLine();
proc.BeginErrorReadLine();
// evbunpack can take a while on large bundles, but a shorter bound keeps the
// operation from looking hung if the tool never terminates.
if (!proc.WaitForExit(10 * 60 * 1000))
{
try { proc.Kill(entireProcessTree: true); } catch { }
progress?.Report("evbunpack がタイムアウトしました(10分)。処理を中断しました。");
exitCode = -1;
return false;
}
// Flush the final line that throttling may have skipped.
if (!string.IsNullOrWhiteSpace(lastLine))
{
progress?.Report(lastLine);
}
exitCode = proc.ExitCode;
return exitCode == 0;
}
catch (Exception ex)
{
progress?.Report($"evbunpack の起動に失敗しました: {ex.Message}");
return false;
}
}
}
}