public static void Configure()
{
var settings = ThunderKitSettings.GetOrCreateSettings <ThunderKitSettings>();
LoadGame(settings);
if (string.IsNullOrEmpty(settings.GamePath) || string.IsNullOrEmpty(settings.GameExecutable))
{
return;
}
SetBitness(settings);
EditorUtility.SetDirty(settings);
if (!CheckUnityVersion(settings))
{
return;
}
var packageName = Path.GetFileNameWithoutExtension(settings.GameExecutable);
AssertDestinations(packageName);
GetReferences(packageName, settings);
EditorUtility.SetDirty(settings);
SetupPackageManifest(settings, packageName);
AssetDatabase.Refresh();
}
private static void SetupPackageManifest(ThunderKitSettings settings, string packageName)
{
var name = packageName.ToLower().Split(' ').Aggregate((a, b) => $"{a}{b}");
var fileVersionInfo = FileVersionInfo.GetVersionInfo(Path.Combine(settings.GamePath, settings.GameExecutable));
var unityVersion = new Version(fileVersionInfo.FileVersion);
var author = new Author
{
name = fileVersionInfo.CompanyName,
};
var packageManifest = new PackageManagerManifest(author, name, packageName, "1.0.0", $"{unityVersion.Major}.{unityVersion.Minor}", $"Imported Assets from game {packageName}");
var packageManifestJson = JsonUtility.ToJson(packageManifest);
File.WriteAllText(Combine("Packages", packageName, "package.json"), packageManifestJson);
}
private static bool CheckUnityVersion(ThunderKitSettings settings)
{
var regs = new Regex("(\\d\\d\\d\\d\\.\\d+\\.\\d+).*");
var unityVersion = regs.Replace(Application.unityVersion, match => match.Groups[1].Value);
var playerVersion = FileVersionInfo.GetVersionInfo(Path.Combine(settings.GamePath, settings.GameExecutable)).ProductVersion;
playerVersion = regs.Replace(playerVersion, match => match.Groups[1].Value);
var versionMatch = unityVersion.Equals(playerVersion);
Debug.Log($"Unity Editor version ({unityVersion}), Unity Player version ({playerVersion}){(versionMatch ? "" : ", aborting setup.\r\n\t Make sure you're using the same version of the Unity Editor as the Unity Player for the game.")}");
return(versionMatch);
}
private static void LoadGame(ThunderKitSettings settings)
{
string currentDir = Directory.GetCurrentDirectory();
var foundExecutable = !string.IsNullOrEmpty(settings.GamePath) &&
Directory.GetFiles(settings.GamePath ?? currentDir, Path.GetFileName(settings.GameExecutable)).Any();
while (!foundExecutable)
{
string path = EditorUtility.OpenFilePanel("Open Game Executable", currentDir, "exe");
if (string.IsNullOrEmpty(path))
{
return;
}
settings.GameExecutable = Path.GetFileName(path);
settings.GamePath = Path.GetDirectoryName(path);
foundExecutable = Directory.GetFiles(settings.GamePath, settings.GameExecutable).Any();
}
EditorUtility.SetDirty(settings);
}
private static void GetReferences(string packageName, ThunderKitSettings settings)
{
Debug.Log("Acquiring references");
var blackList = AppDomain.CurrentDomain.GetAssemblies()
.Where(asm => !asm.IsDynamic)
.Select(asm => Path.GetFileName(asm.Location))
.ToArray();
var managedPath = Path.Combine(settings.GamePath, $"{Path.GetFileNameWithoutExtension(settings.GameExecutable)}_Data", "Managed");
var pluginsPath = Path.Combine(settings.GamePath, $"{Path.GetFileNameWithoutExtension(settings.GameExecutable)}_Data", "Plugins");
var packagePath = Path.Combine("Packages", packageName);
var packagePluginsPath = Path.Combine(packagePath, "plugins");
var managedAssemblies = Directory.EnumerateFiles(managedPath, "*.dll").ToArray();
var plugins = Directory.EnumerateFiles(pluginsPath, "*.dll").ToArray();
GetReferences(packageName, packagePath, managedAssemblies, blackList);
GetReferences(packageName, packagePluginsPath, plugins, Enumerable.Empty <string>());
}
private static void GetReferences(string packageName, ThunderKitSettings settings)
{
Debug.Log("Acquiring references");
var blackList = AppDomain.CurrentDomain.GetAssemblies()
#if NET_4_6
.Where(asm => !asm.IsDynamic)
#else
.Where(asm =>
{
if (asm.ManifestModule is System.Reflection.Emit.ModuleBuilder mb)
{
return(!mb.IsTransient());
}
return(true);
})
#endif
.Select(asm =>
{
try
{
return(Path.GetFileName(asm.Location));
}
catch
{
return(string.Empty);
}
})
.ToArray();
var managedPath = Combine(settings.GamePath, $"{Path.GetFileNameWithoutExtension(settings.GameExecutable)}_Data", "Managed");
var pluginsPath = Combine(settings.GamePath, $"{Path.GetFileNameWithoutExtension(settings.GameExecutable)}_Data", "Plugins");
var packagePath = Path.Combine("Packages", packageName);
var packagePluginsPath = Path.Combine(packagePath, "plugins");
var managedAssemblies = Directory.GetFiles(managedPath, "*.dll");
var plugins = Directory.GetFiles(pluginsPath, "*.dll");
GetReferences(packagePath, managedAssemblies, blackList);
GetReferences(packagePluginsPath, plugins, Enumerable.Empty <string>());
}
public static void SetBitness(ThunderKitSettings settings)
{
var assembly = Path.Combine(settings.GamePath, settings.GameExecutable);
using (var stream = File.OpenRead(assembly))
using (var binStream = new BinaryReader(stream))
{
stream.Seek(0x3C, SeekOrigin.Begin);
if (binStream.PeekChar() != -1)
{
var e_lfanew = binStream.ReadInt32();
stream.Seek(e_lfanew + 0x4, SeekOrigin.Begin);
var cpuType = binStream.ReadUInt16();
if (cpuType == 0x8664)
{
settings.Is64Bit = true;
return;
}
}
}
settings.Is64Bit = false;
}
public static void Execute()
{
var settings = ThunderKitSettings.GetOrCreateSettings <ThunderKitSettings>();
var gamePath = settings.GamePath;
var gameName = Path.GetFileNameWithoutExtension(settings.GameExecutable);
var gameMonoPath = Path.Combine(gamePath, $"MonoBleedingEdge");
var gameDataPath = Path.Combine(gamePath, $"{gameName}_Data");
var gameManagedPath = Path.Combine(gameDataPath, "Managed");
var gameBootConfigFile = Path.Combine(gameDataPath, "boot.config");
var editorPath = Path.GetDirectoryName(EditorApplication.applicationPath);
var windowsStandalonePath = Combine(editorPath, "Data", "PlaybackEngines", "windowsstandalonesupport");
var gamePlayer = Path.Combine(gamePath, $"{gameName}.exe");
var monoString = settings.Is64Bit ? "win64_development_mono" : "win32_development_mono";
var crashHandlerFile = settings.Is64Bit ? "UnityCrashHandler64.exe" : "UnityCrashHandler32.exe";
var playerPdbFile = settings.Is64Bit ? "UnityPlayer_Win64_development_mono_x64.pdb" : "UnityPlayer_Win32_development_mono_x86.pdb";
var playerReleasePdb = settings.Is64Bit ? "WindowsPlayer_Release_mono_x64.pdb" : "WindowsPlayer_Release_mono_x86.pdb";
var bitVersionPath = Combine(windowsStandalonePath, "Variations", monoString);
var monoBleedingEdgePath = Path.Combine(bitVersionPath, "MonoBleedingEdge");
var dataManagedPath = Combine(bitVersionPath, "Data", "Managed");
var winPlayer = Path.Combine(bitVersionPath, "WindowsPlayer.exe");
var crashHandler = GetSwapPair(bitVersionPath, gamePath, crashHandlerFile);
var player = GetSwapPair(bitVersionPath, gamePath, "UnityPlayer.dll");
var playerLib = GetSwapPair(bitVersionPath, gamePath, "UnityPlayer.dll.lib");
var playerPdb = GetSwapPair(bitVersionPath, gamePath, playerPdbFile);
var releasePdb = GetSwapPair(bitVersionPath, gamePath, playerReleasePdb);
var winPix = GetSwapPair(bitVersionPath, gamePath, "WinPixEventRuntime.dll");
var editorVersion = FileVersionInfo.GetVersionInfo(winPlayer);
var gameVersion = FileVersionInfo.GetVersionInfo(gamePlayer);
if (!editorVersion.Equals(editorVersion))
{
Debug.LogError($"Unity Editor Version: {editorVersion} does not match {settings.GameExecutable} Unity version: {gameVersion}");
return;
}
Overwrite(new SwapPair {
newFile = winPlayer, originalFile = gamePlayer
});
Overwrite(crashHandler);
Overwrite(player);
Overwrite(playerLib);
Overwrite(playerPdb);
Overwrite(releasePdb);
if (File.Exists(winPix.newFile))
{
Overwrite(winPix);
}
CopyFolder(monoBleedingEdgePath, gameMonoPath);
CopyFolder(dataManagedPath, gameManagedPath);
if (File.Exists(gameBootConfigFile))
{
bool foundConnectionDebug = false;
using (var sr = File.OpenText(gameBootConfigFile))
{
string line;
while ((line = sr.ReadLine()) != null)
{
if (line.Contains(playerConnectionDebug1))
{
foundConnectionDebug = true;
break;
}
}
}
if (!foundConnectionDebug)
{
File.AppendAllText(gameBootConfigFile, playerConnectionDebug1);
}
}
else
{
File.WriteAllText(gameBootConfigFile, playerConnectionDebug1);
}
}
public override string GetPath(PathReference output, Pipeline pipeline) => ThunderKitSettings.GetOrCreateSettings <ThunderKitSettings>().GameExecutable;
