internal static void Initialize()
{
try
{
string filepath = Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "MelonLoader"), (Imports.IsIl2CppGame() ? "MelonLoader.Support.Il2Cpp.dll"
: (File.Exists(Path.Combine(Imports.GetAssemblyDirectory(), "UnityEngine.CoreModule.dll")) ? "MelonLoader.Support.Mono.dll" : "MelonLoader.Support.Mono.Pre2017.dll")));
if (File.Exists(filepath))
{
byte[] data = File.ReadAllBytes(filepath);
if (data.Length > 0)
{
assembly = Assembly.Load(data);
if (!assembly.Equals(null))
{
type = assembly.GetType("MelonLoader.Support.Main");
if (!type.Equals(null))
{
MethodInfo method = type.GetMethod("Initialize", BindingFlags.NonPublic | BindingFlags.Static);
if (!method.Equals(null))
{
supportModule = (ISupportModule)method.Invoke(null, new object[0]);
}
}
}
}
}
else
{
MelonModLogger.LogError("Unable to load Support Module! Support Module is Missing!");
MelonModLogger.Log("------------------------------");
}
}
catch (Exception e)
{
MelonModLogger.LogError("Unable to load Support Module!\n" + e.ToString());
MelonModLogger.Log("------------------------------");
}
}
private static void LoadDLLs(bool plugins = false)
{
string searchdir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, (plugins ? "Plugins" : "Mods"));
if (!Directory.Exists(searchdir))
{
Directory.CreateDirectory(searchdir);
}
else
{
// DLL
string[] files = Directory.GetFiles(searchdir, "*.dll");
if (files.Length > 0)
{
for (int i = 0; i < files.Length; i++)
{
string file = files[i];
if (!string.IsNullOrEmpty(file))
{
if (plugins)
{
if ((Imports.IsDevPluginsOnly() && !file.EndsWith("-dev.dll")) || (!Imports.IsDevPluginsOnly() && file.EndsWith("-dev.dll")))
{
continue;
}
}
else
{
if ((Imports.IsDevModsOnly() && !file.EndsWith("-dev.dll")) || (!Imports.IsDevModsOnly() && file.EndsWith("-dev.dll")))
{
continue;
}
}
try
{
LoadAssembly(File.ReadAllBytes(file), plugins, file);
}
catch (Exception e)
{
MelonModLogger.LogError("Unable to load " + file + ":\n" + e.ToString());
MelonModLogger.Log("------------------------------");
}
}
}
}
// ZIP
string[] zippedFiles = Directory.GetFiles(searchdir, "*.zip");
if (zippedFiles.Length > 0)
{
for (int i = 0; i < zippedFiles.Length; i++)
{
string file = zippedFiles[i];
if (!string.IsNullOrEmpty(file))
{
try
{
using (var fileStream = File.OpenRead(file))
{
using (var zipInputStream = new ZipInputStream(fileStream))
{
ZipEntry entry;
while ((entry = zipInputStream.GetNextEntry()) != null)
{
string filename = Path.GetFileName(entry.Name);
if (string.IsNullOrEmpty(filename) || !filename.EndsWith(".dll"))
{
continue;
}
if (plugins)
{
if ((Imports.IsDevPluginsOnly() && !filename.EndsWith("-dev.dll")) || (!Imports.IsDevPluginsOnly() && filename.EndsWith("-dev.dll")))
{
continue;
}
}
else
{
if ((Imports.IsDevModsOnly() && !filename.EndsWith("-dev.dll")) || (!Imports.IsDevModsOnly() && filename.EndsWith("-dev.dll")))
{
continue;
}
}
using (var unzippedFileStream = new MemoryStream())
{
int size = 0;
byte[] buffer = new byte[4096];
while (true)
{
size = zipInputStream.Read(buffer, 0, buffer.Length);
if (size > 0)
{
unzippedFileStream.Write(buffer, 0, size);
}
else
{
break;
}
}
LoadAssembly(unzippedFileStream.ToArray(), plugins, (file + "/" + filename));
}
}
}
}
}
catch (Exception e)
{
MelonModLogger.LogError("Unable to load " + file + ":\n" + e.ToString());
MelonModLogger.Log("------------------------------");
}
}
}
}
}
}
private static void OnApplicationStart()
{
if (!HasGeneratedAssembly)
{
return;
}
if (Imports.IsIl2CppGame())
{
if (IsVRChat)
{
Assembly_CSharp = Assembly.Load("Assembly-CSharp");
}
UnhollowerSupport.Initialize();
}
SupportModule.Initialize();
MelonModLogger.Log("------------------------------");
MelonModLogger.Log("Unity " + UnityVersion);
MelonModLogger.Log("------------------------------");
MelonModLogger.Log("Name: " + CurrentGameAttribute.GameName);
MelonModLogger.Log("Developer: " + CurrentGameAttribute.Developer);
MelonModLogger.Log("Type: " + (Imports.IsIl2CppGame() ? "Il2Cpp" : (Imports.IsOldMono() ? "Mono" : "MonoBleedingEdge")));
MelonModLogger.Log("------------------------------");
MelonModLogger.Log("Using v" + BuildInfo.Version + " Open-Beta");
MelonModLogger.Log("------------------------------");
LoadDLLs();
if (Plugins.Count > 0)
{
for (int i = 0; i < Plugins.Count; i++)
{
MelonPlugin plugin = Plugins[i];
if (plugin != null)
{
MelonModLogger.Log(plugin.InfoAttribute.Name
+ (!string.IsNullOrEmpty(plugin.InfoAttribute.Version)
? (" v" + plugin.InfoAttribute.Version) : "")
+ (!string.IsNullOrEmpty(plugin.InfoAttribute.Author)
? (" by " + plugin.InfoAttribute.Author) : "")
+ (!string.IsNullOrEmpty(plugin.InfoAttribute.DownloadLink)
? (" (" + plugin.InfoAttribute.DownloadLink + ")")
: "")
);
MelonModLogger.LogDLLStatus(plugin.Compatibility);
MelonModLogger.Log("------------------------------");
}
}
Plugins = TempPlugins;
}
if (Plugins.Count <= 0)
{
MelonModLogger.Log("No Plugins Loaded!");
MelonModLogger.Log("------------------------------");
}
if (Mods.Count > 0)
{
for (int i = 0; i < Mods.Count; i++)
{
MelonMod mod = Mods[i];
if (mod != null)
{
MelonModLogger.Log(mod.InfoAttribute.Name
+ (!string.IsNullOrEmpty(mod.InfoAttribute.Version)
? (" v" + mod.InfoAttribute.Version) : "")
+ (!string.IsNullOrEmpty(mod.InfoAttribute.Author)
? (" by " + mod.InfoAttribute.Author) : "")
+ (!string.IsNullOrEmpty(mod.InfoAttribute.DownloadLink)
? (" (" + mod.InfoAttribute.DownloadLink + ")")
: "")
);
MelonModLogger.LogDLLStatus(mod.Compatibility);
MelonModLogger.Log("------------------------------");
}
}
Mods.RemoveAll((MelonMod mod) => (mod.Compatibility >= MelonBase.MelonCompatibility.INCOMPATIBLE));
DependencyGraph <MelonMod> .TopologicalSort(Mods, mod => mod.InfoAttribute.Name);
}
if (Mods.Count <= 0)
{
MelonModLogger.Log("No Mods Loaded!");
MelonModLogger.Log("------------------------------");
}
if ((Plugins.Count > 0) || (Mods.Count > 0))
{
AddUnityDebugLog();
}
if (Plugins.Count > 0)
{
HashSet <MelonPlugin> failedPlugins = new HashSet <MelonPlugin>();
for (int i = 0; i < Plugins.Count; i++)
{
MelonPlugin plugin = Plugins[i];
if (plugin != null)
{
try { InitializeModOrPlugin(plugin); } catch (Exception ex) { MelonModLogger.LogDLLError(ex.ToString(), plugin.InfoAttribute.Name); failedPlugins.Add(plugin); }
}
}
Plugins.RemoveAll(plugin => failedPlugins.Contains(plugin));
}
if (Mods.Count > 0)
{
HashSet <MelonMod> failedMods = new HashSet <MelonMod>();
for (int i = 0; i < Mods.Count; i++)
{
MelonMod mod = Mods[i];
if (mod != null)
{
try { InitializeModOrPlugin(mod); } catch (Exception ex) { MelonModLogger.LogDLLError(ex.ToString(), mod.InfoAttribute.Name); failedMods.Add(mod); }
}
}
Mods.RemoveAll(mod => failedMods.Contains(mod));
}
if ((Plugins.Count <= 0) && (Mods.Count <= 0))
{
SupportModule.Destroy();
}
}
private static void Initialize()
{
if (string.IsNullOrEmpty(AppDomain.CurrentDomain.BaseDirectory))
{
((AppDomainSetup)typeof(AppDomain).GetProperty("SetupInformationNoCopy", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(AppDomain.CurrentDomain, new object[0])).ApplicationBase = Imports.GetGameDirectory();
}
Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);
AppDomain.CurrentDomain.UnhandledException += ExceptionHandler;
CurrentGameAttribute = new MelonModGameAttribute(Imports.GetCompanyName(), Imports.GetProductName());
UnityVersion = GetUnityVersion();
if (Imports.IsIl2CppGame())
{
IsVRChat = CurrentGameAttribute.IsGame("VRChat", "VRChat");
IsBoneworks = CurrentGameAttribute.IsGame("Stress Level Zero", "BONEWORKS");
}
if (!Imports.IsDebugMode()
#if !DEBUG
&& Imports.IsConsoleEnabled()
#endif
)
{
Console.Enabled = true;
Console.Create();
}
if (!Imports.IsIl2CppGame() || AssemblyGenerator.Main.Initialize())
{
HasGeneratedAssembly = true;
}
else
{
Imports.UNLOAD_MELONLOADER();
}
if (HasGeneratedAssembly)
{
LoadDLLs(true);
if (Plugins.Count > 0)
{
HashSet <MelonPlugin> failedPlugins = new HashSet <MelonPlugin>();
TempPlugins = Plugins.Where(plugin => (plugin.Compatibility < MelonBase.MelonCompatibility.INCOMPATIBLE)).ToList();
DependencyGraph <MelonPlugin> .TopologicalSort(TempPlugins, plugin => plugin.InfoAttribute.Name);
for (int i = 0; i < TempPlugins.Count; i++)
{
MelonPlugin plugin = TempPlugins[i];
if (plugin != null)
{
try { plugin.OnPreInitialization(); } catch (Exception ex) { MelonModLogger.LogDLLError(ex.ToString(), plugin.InfoAttribute.Name); failedPlugins.Add(plugin); }
}
}
TempPlugins.RemoveAll(plugin => failedPlugins.Contains(plugin));
}
}
}
