private static void InitializeUnityVersion()
{
string unityVersion = string.Copy(MelonUtils.GetUnityVersion());
if (string.IsNullOrEmpty(unityVersion))
{
return;
}
string[] unityVersionSplit = unityVersion.Split('.');
if ((unityVersionSplit == null) || (unityVersionSplit.Length < 2))
{
return;
}
int major = int.Parse(unityVersionSplit[0]);
int minor = int.Parse(unityVersionSplit[1]);
int patch = 0;
if (unityVersionSplit.Length > 2)
{
string patchString = unityVersionSplit[2];
char firstBadChar = patchString.FirstOrDefault(it => it <'0' || it> '9');
patch = int.Parse(firstBadChar == 0 ? patchString : patchString.Substring(0, patchString.IndexOf(firstBadChar)));
}
UnityVersionHandler.Initialize(major, minor, patch);
}
public static void Setup()
{
#if DEBUG
Console.WriteLine(Environment.Version);
Console.WriteLine(Application.unityVersion);
Console.WriteLine(Directory.GetCurrentDirectory());
LogSupport.RemoveAllHandlers();
LogSupport.TraceHandler += LogSupport_TraceHandler;
LogSupport.ErrorHandler += LogSupport_TraceHandler;
LogSupport.InfoHandler += LogSupport_TraceHandler;
LogSupport.WarningHandler += LogSupport_TraceHandler;
#endif
ClassInjector.DoHook?.GetInvocationList().ToList().ForEach(d => ClassInjector.DoHook -= (Action <IntPtr, IntPtr>)d);
ClassInjector.DoHook += JmpPatch;
UnityVersionHandler.Initialize(2019, 3, 14);
ClassInjector.RegisterTypeInIl2Cpp <ModManager>();
while (BaseObject = GameObject.Find("ModManager"))
{
GameObject.DestroyImmediate(BaseObject);
}
BaseObject = new GameObject("ModManager");
GameObject.DontDestroyOnLoad(BaseObject);
var modMgr = BaseObject.AddComponent <ModManager>();
var types = Assembly.GetExecutingAssembly().GetTypes().ToList().Where(t => t.BaseType == typeof(ModBase) && !t.IsNested);
foreach (var type in types)
{
modMgr.Mods.Add((ModBase)Activator.CreateInstance(type));
}
}
public override void Load()
{
UnityVersionHandler.Initialize(2019, 4, 9);
ModLoader.Instance.IsClient = true;
LoadVanillaRegistries();
StartLoadingAsync().GetAwaiter().GetResult();
}
private static ISupportModule Initialize()
{
LogSupport.RemoveAllHandlers();
if (true)
{
LogSupport.InfoHandler += MelonLogger.Log;
}
LogSupport.WarningHandler += MelonLogger.LogWarning;
LogSupport.ErrorHandler += MelonLogger.LogError;
if (true)
{
LogSupport.TraceHandler += MelonLogger.Log;
}
ClassInjector.DoHook += Imports.Hook;
GetUnityVersionNumbers(out var major, out var minor, out var patch);
UnityVersionHandler.Initialize(major, minor, patch);
// Il2CppSystem.Console.SetOut(new Il2CppSystem.IO.StreamWriter(Il2CppSystem.IO.Stream.Null));
try
{
var il2CppSystemAssembly = Assembly.Load("Il2Cppmscorlib");
var consoleType = il2CppSystemAssembly.GetType("Il2CppSystem.Console");
var streamWriterType = il2CppSystemAssembly.GetType("Il2CppSystem.IO.StreamWriter");
var streamType = il2CppSystemAssembly.GetType("Il2CppSystem.IO.Stream");
var setOutMethod = consoleType.GetMethod("SetOut", BindingFlags.Static | BindingFlags.Public);
var nullStreamField = streamType.GetProperty("Null", BindingFlags.Static | BindingFlags.Public).GetGetMethod();
var streamWriterCtor = streamWriterType.GetConstructor(new[] { streamType });
var nullStream = nullStreamField.Invoke(null, new object[0]);
var steamWriter = streamWriterCtor.Invoke(new[] { nullStream });
setOutMethod.Invoke(null, new[] { steamWriter });
}
catch (Exception ex)
{
MelonLogger.LogError($"Console cleaning failed: {ex}");
}
SetAsLastSiblingDelegateField = IL2CPP.ResolveICall <SetAsLastSiblingDelegate>("UnityEngine.Transform::SetAsLastSibling");
ClassInjector.RegisterTypeInIl2Cpp <MelonLoaderComponent>();
//MelonLogger.Log("ClassInjector.RegisterTypeInIl2Cpp<MelonLoaderComponent> done");
MelonLoaderComponent.Create();
//MelonLogger.Log("MelonLoaderComponent.Create() done");
SceneManager.sceneLoaded = (
(SceneManager.sceneLoaded == null)
? new Action <Scene, LoadSceneMode>(OnSceneLoad)
: Il2CppSystem.Delegate.Combine(SceneManager.sceneLoaded, (UnityAction <Scene, LoadSceneMode>) new Action <Scene, LoadSceneMode>(OnSceneLoad)).Cast <UnityAction <Scene, LoadSceneMode> >()
);
Camera.onPostRender = (
(Camera.onPostRender == null)
? new Action <Camera>(OnPostRender)
: Il2CppSystem.Delegate.Combine(Camera.onPostRender, (Camera.CameraCallback) new Action <Camera>(OnPostRender)).Cast <Camera.CameraCallback>()
);
return(new Module());
}
private static ISupportModule_To Initialize(ISupportModule_From interface_from)
{
Interface = interface_from;
UnityMappers.RegisterMappers();
LogSupport.RemoveAllHandlers();
if (MelonDebug.IsEnabled())
{
LogSupport.InfoHandler += MelonLogger.Msg;
}
LogSupport.WarningHandler += MelonLogger.Warning;
LogSupport.ErrorHandler += MelonLogger.Error;
if (MelonDebug.IsEnabled())
{
LogSupport.TraceHandler += MelonLogger.Msg;
}
ClassInjector.Detour = new UnhollowerDetour();
UnityVersionHandler.Initialize(
InternalUtils.UnityInformationHandler.EngineVersion.Major,
InternalUtils.UnityInformationHandler.EngineVersion.Minor,
InternalUtils.UnityInformationHandler.EngineVersion.Build);
if (MelonLaunchOptions.Console.CleanUnityLogs)
{
ConsoleCleaner();
}
try
{
SceneManager.sceneLoaded = (
(ReferenceEquals(SceneManager.sceneLoaded, null))
? new Action <Scene, LoadSceneMode>(OnSceneLoad)
: Il2CppSystem.Delegate.Combine(SceneManager.sceneLoaded, (UnityAction <Scene, LoadSceneMode>) new Action <Scene, LoadSceneMode>(OnSceneLoad)).Cast <UnityAction <Scene, LoadSceneMode> >()
);
}
catch (Exception ex) { MelonLogger.Error($"SceneManager.sceneLoaded override failed: {ex}"); }
try
{
SceneManager.sceneUnloaded = (
(ReferenceEquals(SceneManager.sceneUnloaded, null))
? new Action <Scene>(OnSceneUnload)
: Il2CppSystem.Delegate.Combine(SceneManager.sceneUnloaded, (UnityAction <Scene>) new Action <Scene>(OnSceneUnload)).Cast <UnityAction <Scene> >()
);
}
catch (Exception ex) { MelonLogger.Error($"SceneManager.sceneUnloaded override failed: {ex}"); }
MonoEnumeratorWrapper.Register();
ClassInjector.RegisterTypeInIl2Cpp <SM_Component>();
SM_Component.Create();
unhollower = new UnhollowerInterface();
Interface.SetUnhollowerSupportInterface(unhollower);
HarmonyLib.Public.Patching.PatchManager.ResolvePatcher += HarmonyMethodPatcher.TryResolve;
return(new SupportModule_To());
}
public override unsafe void Initialize(string gameExePath = null)
{
UnhollowerBaseLib.GeneratedDatabasesUtil.DatabasesLocationOverride = Preloader.IL2CPPUnhollowedPath;
PatchManager.ResolvePatcher += IL2CPPDetourMethodPatcher.TryResolve;
base.Initialize(gameExePath);
Instance = this;
var version = //Version.Parse(Application.unityVersion);
Version.Parse(Process.GetCurrentProcess().MainModule.FileVersionInfo.FileVersion);
UnityVersionHandler.Initialize(version.Major, version.Minor, version.Revision);
// One or the other here for Unhollower to work correctly
//ClassInjector.Detour = new DetourHandler();
ClassInjector.DoHook = (ptr, patchedFunctionPtr) =>
{
IntPtr originalFunc = new IntPtr(*(void **)ptr);
var detour = new FastNativeDetour(originalFunc, patchedFunctionPtr);
detour.Apply();
*(void **)ptr = (void *)detour.TrampolinePtr;
};
var gameAssemblyModule = Process.GetCurrentProcess().Modules.Cast <ProcessModule>().First(x => x.ModuleName.Contains("GameAssembly"));
// TODO: Check that DynDll.GetFunction works fine now
var runtimeInvokePtr = GetProcAddress(gameAssemblyModule.BaseAddress, "il2cpp_runtime_invoke"); //DynDll.GetFunction(gameAssemblyModule.BaseAddress, "il2cpp_runtime_invoke");
PreloaderLogger.Log.LogDebug($"Runtime invoke pointer: 0x{runtimeInvokePtr.ToInt64():X}");
RuntimeInvokeDetour = FastNativeDetour.CreateAndApply(runtimeInvokePtr, OnInvokeMethod, out originalInvoke, CallingConvention.Cdecl);
var installTlsPtr = GetProcAddress(gameAssemblyModule.BaseAddress, "il2cpp_unity_install_unitytls_interface");
if (installTlsPtr != IntPtr.Zero)
{
InstallUnityTlsInterfaceDetour = FastNativeDetour.CreateAndApply(installTlsPtr, OnInstallUnityTlsInterface, out originalInstallUnityTlsInterface, CallingConvention.Cdecl);
}
Logger.LogDebug("Initializing TLS adapters");
Il2CppTlsAdapter.Initialize();
PreloaderLogger.Log.LogDebug("Runtime invoke patched");
}
private static ISupportModule Initialize()
{
if (Console.Enabled || Imports.IsDebugMode())
{
LogSupport.InfoHandler -= System.Console.WriteLine;
LogSupport.InfoHandler += MelonModLogger.Log;
}
LogSupport.WarningHandler -= System.Console.WriteLine;
LogSupport.WarningHandler += MelonModLogger.LogWarning;
LogSupport.ErrorHandler -= System.Console.WriteLine;
LogSupport.ErrorHandler += MelonModLogger.LogError;
if (Imports.IsDebugMode())
{
LogSupport.TraceHandler -= System.Console.WriteLine;
LogSupport.TraceHandler += MelonModLogger.Log;
}
try
{
unsafe {
var tlsHookTarget = typeof(Uri).Assembly.GetType("Mono.Unity.UnityTls").GetMethod("GetUnityTlsInterface", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).MethodHandle.GetFunctionPointer();
var unityMethodField = UnhollowerUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod(typeof(Il2CppMono.Unity.UnityTls).GetMethod("GetUnityTlsInterface", BindingFlags.Public | BindingFlags.Static));
var unityMethodPtr = (IntPtr)unityMethodField.GetValue(null);
var unityMethod = *(IntPtr *)unityMethodPtr;
Imports.Hook((IntPtr)(&tlsHookTarget), unityMethod);
}
} catch (Exception ex) {
MelonModLogger.LogWarning("Exception while setting up TLS, mods will not be able to use HTTPS: " + ex);
}
ClassInjector.DoHook += Imports.Hook;
GetUnityVersionNumbers(out var major, out var minor, out var patch);
UnityVersionHandler.Initialize(major, minor, patch);
ClassInjector.RegisterTypeInIl2Cpp <MelonLoaderComponent>();
MelonLoaderComponent.CreateComponent();
SceneManager.sceneLoaded = (
(SceneManager.sceneLoaded == null)
? new Action <Scene, LoadSceneMode>(OnSceneLoad)
: Il2CppSystem.Delegate.Combine(SceneManager.sceneLoaded, (UnityAction <Scene, LoadSceneMode>) new Action <Scene, LoadSceneMode>(OnSceneLoad)).Cast <UnityAction <Scene, LoadSceneMode> >()
);
Camera.onPostRender = (
(Camera.onPostRender == null)
? new Action <Camera>(OnPostRender)
: Il2CppSystem.Delegate.Combine(Camera.onPostRender, (Camera.CameraCallback) new Action <Camera>(OnPostRender)).Cast <Camera.CameraCallback>()
);
return(new Module());
}
public override unsafe void Initialize(string gameExePath = null)
{
UnhollowerBaseLib.GeneratedDatabasesUtil.DatabasesLocationOverride = Preloader.IL2CPPUnhollowedPath;
PatchManager.ResolvePatcher += IL2CPPDetourMethodPatcher.TryResolve;
base.Initialize(gameExePath);
Instance = this;
var version = //Version.Parse(Application.unityVersion);
Version.Parse(Process.GetCurrentProcess().MainModule.FileVersionInfo.FileVersion);
UnityVersionHandler.Initialize(version.Major, version.Minor, version.Revision);
// One or the other here for Unhollower to work correctly
//ClassInjector.Detour = new DetourHandler();
ClassInjector.DoHook = (ptr, patchedFunctionPtr) =>
{
IntPtr originalFunc = new IntPtr(*(void **)ptr);
var detour = new FastNativeDetour(originalFunc, patchedFunctionPtr);
detour.Apply();
*(void **)ptr = (void *)detour.TrampolinePtr;
};
var gameAssemblyModule = Process.GetCurrentProcess().Modules.Cast <ProcessModule>().First(x => x.ModuleName.Contains("GameAssembly"));
var functionPtr = GetProcAddress(gameAssemblyModule.BaseAddress, "il2cpp_runtime_invoke"); //DynDll.GetFunction(gameAssemblyModule.BaseAddress, "il2cpp_runtime_invoke");
PreloaderLogger.Log.LogDebug($"Runtime invoke pointer: 0x{functionPtr.ToInt64():X}");
RuntimeInvokeDetour = new FastNativeDetour(functionPtr,
MonoExtensions.GetFunctionPointerForDelegate(new RuntimeInvokeDetourDelegate(OnInvokeMethod), CallingConvention.Cdecl));
RuntimeInvokeDetour.Apply();
originalInvoke = RuntimeInvokeDetour.GenerateTrampoline <RuntimeInvokeDetourDelegate>();
PreloaderLogger.Log.LogDebug("Runtime invoke patched");
}
private static bool TryInitializeUnityVersion(string version)
{
try
{
if (string.IsNullOrWhiteSpace(version))
{
return(false);
}
var parts = version.Split('.');
var major = 0;
var minor = 0;
var build = 0;
// Issue #229 - Don't use Version.Parse("2019.4.16.14703470L&ProductVersion")
bool success = int.TryParse(parts[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out major);
if (success && parts.Length > 1)
{
success = int.TryParse(parts[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out minor);
}
if (success && parts.Length > 2)
{
success = int.TryParse(parts[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out build);
}
if (!success)
{
Log.LogError($"Failed to parse Unity version: {version}");
return(false);
}
UnityVersionHandler.Initialize(major, minor, build);
Log.LogInfo($"Running under Unity v{major}.{minor}.{build}");
return(true);
}
catch (Exception ex)
{
Log.LogError($"Failed to parse Unity version: {ex}");
return(false);
}
}
private static ISupportModule Initialize()
{
if (Console.Enabled || Imports.IsDebugMode())
{
LogSupport.InfoHandler -= System.Console.WriteLine;
LogSupport.InfoHandler += MelonModLogger.Log;
}
LogSupport.WarningHandler -= System.Console.WriteLine;
LogSupport.WarningHandler += MelonModLogger.LogWarning;
LogSupport.ErrorHandler -= System.Console.WriteLine;
LogSupport.ErrorHandler += MelonModLogger.LogError;
if (Imports.IsDebugMode())
{
LogSupport.TraceHandler -= System.Console.WriteLine;
LogSupport.TraceHandler += MelonModLogger.Log;
}
ClassInjector.DoHook += Imports.Hook;
GetUnityVersionNumbers(out var major, out var minor, out var patch);
UnityVersionHandler.Initialize(major, minor, patch);
ClassInjector.RegisterTypeInIl2Cpp <MelonLoaderComponent>();
MelonLoaderComponent.CreateComponent();
add_sceneLoaded_potato(new Action <Scene, LoadSceneMode>(OnSceneLoad));
return(new Module());
}
private static ISupportModule Initialize()
{
LogSupport.RemoveAllHandlers();
if (Console.Enabled || Imports.IsDebugMode())
{
LogSupport.InfoHandler += MelonModLogger.Log;
}
LogSupport.WarningHandler += MelonModLogger.LogWarning;
LogSupport.ErrorHandler += MelonModLogger.LogError;
if (Imports.IsDebugMode())
{
LogSupport.TraceHandler += MelonModLogger.Log;
}
try
{
Assembly il2cppSystem = Assembly.Load("Il2CppSystem");
if (il2cppSystem != null)
{
Type unitytls = il2cppSystem.GetType("Il2CppMono.Unity.UnityTls");
if (unitytls != null)
{
unsafe
{
var tlsHookTarget = typeof(Uri).Assembly.GetType("Mono.Unity.UnityTls").GetMethod("GetUnityTlsInterface", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).MethodHandle.GetFunctionPointer();
var unityMethodField = UnhollowerUtils.GetIl2CppMethodInfoPointerFieldForGeneratedMethod(unitytls.GetMethod("GetUnityTlsInterface", BindingFlags.Public | BindingFlags.Static));
var unityMethodPtr = (IntPtr)unityMethodField.GetValue(null);
var unityMethod = *(IntPtr *)unityMethodPtr;
Imports.Hook((IntPtr)(&tlsHookTarget), unityMethod);
}
}
else
{
throw new Exception("Failed to get Type Il2CppMono.Unity.UnityTls!");
}
}
else
{
throw new Exception("Failed to get Assembly Il2CppSystem!");
}
}
catch (Exception ex)
{
MelonModLogger.LogWarning("Exception while setting up TLS, mods will not be able to use HTTPS: " + ex);
}
if (MelonLoader.Main.IsVRChat)
{
try
{
Assembly Transmtn = Assembly.Load("Transmtn");
if (Transmtn != null)
{
Type Transmtn_HttpConnection = Transmtn.GetType("Transmtn.HttpConnection");
if (Transmtn_HttpConnection != null)
{
Il2CppSystem_Console_WriteLine = typeof(Il2CppSystem.Console).GetMethods(BindingFlags.Public | BindingFlags.Static).First(x => (x.Name.Equals("WriteLine") && (x.GetParameters().Count() == 1) && (x.GetParameters()[0].ParameterType == typeof(string))));
if (harmonyInstance == null)
{
harmonyInstance = HarmonyInstance.Create("MelonLoader.Support.Il2Cpp");
}
harmonyInstance.Patch(Transmtn_HttpConnection.GetMethod("get", BindingFlags.Public | BindingFlags.Instance), new HarmonyMethod(typeof(Main).GetMethod("Transmtn_HttpConnection_get_Prefix", BindingFlags.NonPublic | BindingFlags.Static)), new HarmonyMethod(typeof(Main).GetMethod("Transmtn_HttpConnection_get_Postfix", BindingFlags.NonPublic | BindingFlags.Static)));
}
else
{
throw new Exception("Failed to get Type Transmtn.HttpConnection!");
}
}
else
{
throw new Exception("Failed to get Assembly Transmtn!");
}
}
catch (Exception ex)
{
MelonModLogger.LogWarning("Exception while setting up Auth Token Hider, Auth Tokens may show in Console: " + ex);
}
}
ClassInjector.DoHook += Imports.Hook;
GetUnityVersionNumbers(out var major, out var minor, out var patch);
UnityVersionHandler.Initialize(major, minor, patch);
SetAsLastSiblingDelegateField = IL2CPP.ResolveICall <SetAsLastSiblingDelegate>("UnityEngine.Transform::SetAsLastSibling");
ClassInjector.RegisterTypeInIl2Cpp <MelonLoaderComponent>();
MelonLoaderComponent.Create();
SceneManager.sceneLoaded = (
(SceneManager.sceneLoaded == null)
? new Action <Scene, LoadSceneMode>(OnSceneLoad)
: Il2CppSystem.Delegate.Combine(SceneManager.sceneLoaded, (UnityAction <Scene, LoadSceneMode>) new Action <Scene, LoadSceneMode>(OnSceneLoad)).Cast <UnityAction <Scene, LoadSceneMode> >()
);
Camera.onPostRender = (
(Camera.onPostRender == null)
? new Action <Camera>(OnPostRender)
: Il2CppSystem.Delegate.Combine(Camera.onPostRender, (Camera.CameraCallback) new Action <Camera>(OnPostRender)).Cast <Camera.CameraCallback>()
);
return(new Module());
}
public static void Run()
{
try
{
HarmonyBackendFix.Initialize();
ConsoleManager.Initialize(false, false);
PreloaderLog = new PreloaderConsoleListener();
Logger.Listeners.Add(PreloaderLog);
if (ConsoleManager.ConsoleEnabled)
{
ConsoleManager.CreateConsole();
Logger.Listeners.Add(new ConsoleLogListener());
}
ChainloaderLogHelper.PrintLogInfo(Log);
Log.Log(LogLevel.Debug, $"Game executable path: {Paths.ExecutablePath}");
Log.Log(LogLevel.Debug, $"Unhollowed assembly directory: {IL2CPPUnhollowedPath}");
Log.Log(LogLevel.Debug, $"BepInEx root path: {Paths.BepInExRootPath}");
UnhollowerLog = Logger.CreateLogSource("Unhollower");
LogSupport.InfoHandler += UnhollowerLog.LogInfo;
LogSupport.WarningHandler += UnhollowerLog.LogWarning;
LogSupport.TraceHandler += UnhollowerLog.LogDebug;
LogSupport.ErrorHandler += UnhollowerLog.LogError;
InitializeUnityVersion();
if (ProxyAssemblyGenerator.CheckIfGenerationRequired())
{
ProxyAssemblyGenerator.GenerateAssemblies();
}
UnityVersionHandler.Initialize(UnityVersion.Major, UnityVersion.Minor, UnityVersion.Build);
using (var assemblyPatcher = new AssemblyPatcher())
{
assemblyPatcher.AddPatchersFromDirectory(Paths.PatcherPluginPath);
Log.LogInfo($"{assemblyPatcher.PatcherContext.PatcherPlugins.Count} patcher plugin{(assemblyPatcher.PatcherContext.PatcherPlugins.Count == 1 ? "" : "s")} loaded");
assemblyPatcher.LoadAssemblyDirectories(IL2CPPUnhollowedPath);
Log.LogInfo($"{assemblyPatcher.PatcherContext.PatcherPlugins.Count} assemblies discovered");
assemblyPatcher.PatchAndLoad();
}
Logger.Listeners.Remove(PreloaderLog);
Chainloader = new IL2CPPChainloader();
Chainloader.Initialize();
}
catch (Exception ex)
{
Log.Log(LogLevel.Fatal, ex);
throw;
}
}
private static ISupportModule Initialize()
{
LogSupport.RemoveAllHandlers();
if (MelonConsole.Enabled || Imports.IsDebugMode())
{
LogSupport.InfoHandler += MelonLogger.Log;
}
LogSupport.WarningHandler += MelonLogger.LogWarning;
LogSupport.ErrorHandler += MelonLogger.LogError;
if (Imports.IsDebugMode())
{
LogSupport.TraceHandler += MelonLogger.Log;
}
if (MelonLoaderBase.IsVRChat)
{
try
{
Assembly Transmtn = Assembly.Load("Transmtn");
if (Transmtn != null)
{
Type Transmtn_HttpConnection = Transmtn.GetType("Transmtn.HttpConnection");
if (Transmtn_HttpConnection != null)
{
Il2CppSystem_Console_WriteLine = typeof(Il2CppSystem.Console).GetMethods(BindingFlags.Public | BindingFlags.Static).First(x => (x.Name.Equals("WriteLine") && (x.GetParameters().Count() == 1) && (x.GetParameters()[0].ParameterType == typeof(string))));
if (harmonyInstance == null)
{
harmonyInstance = HarmonyInstance.Create("MelonLoader.Support.Il2Cpp");
}
harmonyInstance.Patch(Transmtn_HttpConnection.GetMethod("get", BindingFlags.Public | BindingFlags.Instance), new HarmonyMethod(typeof(Main).GetMethod("Transmtn_HttpConnection_get_Prefix", BindingFlags.NonPublic | BindingFlags.Static)), new HarmonyMethod(typeof(Main).GetMethod("Transmtn_HttpConnection_get_Postfix", BindingFlags.NonPublic | BindingFlags.Static)));
}
else
{
throw new Exception("Failed to get Type Transmtn.HttpConnection!");
}
}
else
{
throw new Exception("Failed to get Assembly Transmtn!");
}
}
catch (Exception ex)
{
MelonLogger.LogWarning("Exception while setting up Auth Token Hider, Auth Tokens may show in Console: " + ex);
}
}
ClassInjector.DoHook += Imports.Hook;
GetUnityVersionNumbers(out var major, out var minor, out var patch);
UnityVersionHandler.Initialize(major, minor, patch);
SetAsLastSiblingDelegateField = IL2CPP.ResolveICall <SetAsLastSiblingDelegate>("UnityEngine.Transform::SetAsLastSibling");
ClassInjector.RegisterTypeInIl2Cpp <MelonLoaderComponent>();
MelonLoaderComponent.Create();
SceneManager.sceneLoaded = (
(SceneManager.sceneLoaded == null)
? new Action <Scene, LoadSceneMode>(OnSceneLoad)
: Il2CppSystem.Delegate.Combine(SceneManager.sceneLoaded, (UnityAction <Scene, LoadSceneMode>) new Action <Scene, LoadSceneMode>(OnSceneLoad)).Cast <UnityAction <Scene, LoadSceneMode> >()
);
Camera.onPostRender = (
(Camera.onPostRender == null)
? new Action <Camera>(OnPostRender)
: Il2CppSystem.Delegate.Combine(Camera.onPostRender, (Camera.CameraCallback) new Action <Camera>(OnPostRender)).Cast <Camera.CameraCallback>()
);
return(new Module());
}
