public static void SimulationDataReady()
{
Log.Info($"LifeCycle.SimulationDataReady() called. mode={Mode} updateMode={UpdateMode}, scene={Scene}");
System.Threading.Thread.Sleep(1000 * 50); //50 sec
Log.Info($"LifeCycle.SimulationDataReady() after sleep");
if (Scene == "ThemeEditor")
{
return;
}
CSURUtil.Init();
if (Settings.GameConfig == null)
{
switch (Mode)
{
case LoadMode.NewGameFromScenario:
case LoadMode.LoadScenario:
case LoadMode.LoadMap:
// no NC or old NC
Settings.GameConfig = GameConfigT.LoadGameDefault;
break;
default:
Settings.GameConfig = GameConfigT.NewGameDefault;
break;
}
}
HarmonyUtil.InstallHarmony(HARMONY_ID); // game config is checked in patch.
NodeManager.Instance.OnLoad();
SegmentEndManager.Instance.OnLoad();
Loaded = true;
Log.Info("LifeCycle.SimulationDataReady() sucessful");
}
public static void Load()
{
try {
Log.Info("LifeCycle.Load() called");
Log.Info("testing stack trace:\n" + Environment.StackTrace, false);
NetworkExtensionManager.Instance.OnLoad();
Log.Info($"Scene={Scene} LoadMode={Mode}");
if (Scene != "AssetEditor")
{
Log.Info("Applying in game patches");
HarmonyUtil.InstallHarmony <InGamePatchAttribute>(HARMONY_ID);
}
else
{
Log.Info("Applying all patches");
HarmonyUtil.InstallHarmony(HARMONY_ID, forbidden: typeof(PreloadPatchAttribute));
HintBox.Create();
}
NetInfoExtionsion.Ensure_EditedNetInfos();
ObserverDisposable = GeometryManager.Instance.Subscribe(new ARTMPEObsever());
ARTool.Create();
Log.Info("LifeCycle.Load() successfull!");
Log.Flush();
} catch (Exception ex) {
Log.Exception(ex);
throw ex;
}
}
public static void Exit()
{
Log.Buffered = false;
Log.Info("LifeCycle.Exit() called");
HarmonyUtil.UninstallHarmony(HARMONY_ID_MANUAL);
preloadPatchesApplied_ = false;
}
public static void Enable()
{
try {
Log.Debug("Testing StackTrace:\n" + new StackTrace(true).ToString(), copyToGameLog: false);
KianCommons.UI.TextureUtil.EmbededResources = false;
HelpersExtensions.VERBOSE = false;
Loaded = false;
Log.Buffered = true;
HarmonyHelper.EnsureHarmonyInstalled();
//LoadingManager.instance.m_simulationDataReady += SimulationDataReady; // load/update data
LoadingManager.instance.m_levelPreLoaded += Preload;
if (LoadingManager.instance.m_loadingComplete)
{
HotReload();
}
#if FAST_TEST_HARMONY
HarmonyHelper.DoOnHarmonyReady(() => {
HarmonyUtil.InstallHarmony(HARMONY_ID);
Process.GetCurrentProcess().Kill();
});
#endif
Test();
} catch (Exception ex) {
Log.Exception(ex);
}
}
public static void Disable()
{
LogCalled();
LoadingManager.instance.m_levelPreLoaded -= PreLoad; //install harmony
LoadingManager.instance.m_simulationDataReady -= SimulationDataReady;
LoadingManager.instance.m_levelPreUnloaded -= ExitToMainMenu;
HarmonyUtil.UninstallHarmony(HarmonyId);
ExitToMainMenu(); // in case of hot unload
}
// first thing that happens when start game/editor from main menue or load another game.
public static void PreLoad()
{
try {
LogCalled();
HarmonyUtil.InstallHarmony(HarmonyId); // if not installed already.
} catch (Exception e) {
Log.Exception(e);
}
}
public static void Unload()
{
LogCalled();
ARTool.Release();
ObserverDisposable?.Dispose();
HintBox.Release();
HarmonyUtil.UninstallHarmony(HARMONY_ID);
NetworkExtensionManager.RawInstance?.OnUnload();
}
public void OnEnabled()
{
System.IO.File.WriteAllText("mod.debug.log", ""); // restart log.
HarmonyHelper.DoOnHarmonyReady(() => HarmonyUtil.InstallHarmony(HarmonyId));
if (HelpersExtensions.InGame)
{
LifeCycle.Load();
}
}
//static LoadOrderMod() => Log.Debug("Static Ctor " + Environment.StackTrace);
//public LoadOrderMod() => Log.Debug("Instance Ctor " + Environment.StackTrace);
public void OnEnabled()
{
try {
Log.Called();
Util.LoadOrderUtil.ApplyGameLoggingImprovements();
var args = Environment.GetCommandLineArgs();
Log.Info("command line args are: " + string.Join(" ", args));
Log.ShowGap = true;
#if DEBUG
Log.Buffered = true;
#else
Log.Buffered = true;
#endif
//Log.Debug("Testing StackTrace:\n" + new StackTrace(true).ToString(), copyToGameLog: true);
//KianCommons.UI.TextureUtil.EmbededResources = false;
//HelpersExtensions.VERBOSE = false;
//foreach(var p in ColossalFramework.Plugins.PluginManager.instance.GetPluginsInfo()) {
// string savedKey = p.name + p.modPath.GetHashCode().ToString() + ".enabled";
// Log.Debug($"plugin info: savedKey={savedKey} cachedName={p.name} modPath={p.modPath}");
//}
CheckPatchLoader();
HarmonyHelper.DoOnHarmonyReady(() => {
//HarmonyLib.Harmony.DEBUG = true;
HarmonyUtil.InstallHarmony(HARMONY_ID, null, null); // continue on error.
});
SceneManager.sceneLoaded += OnSceneLoaded;
SceneManager.activeSceneChanged += OnActiveSceneChanged;
LoadingManager.instance.m_introLoaded += LoadOrderUtil.TurnOffSteamPanels;
LoadingManager.instance.m_introLoaded += CheckPatchLoader;
LoadOrderUtil.TurnOffSteamPanels();
bool introLoaded = ContentManagerUtil.IsIntroLoaded;
if (introLoaded)
{
CacheUtil.CacheData();
}
else
{
LoadingManager.instance.m_introLoaded += CacheUtil.CacheData;
}
if (!Settings.ConfigUtil.Config.IgnoranceIsBliss)
{
CheckSubsUtil.RegisterEvents();
}
Log.Flush();
} catch (Exception ex) {
Log.Exception(ex);
}
}
public static void Disable()
{
LoadingManager.instance.m_simulationDataReady -= SimulationDataReady;
Unload(); // in case of hot unload
if (fastTestHarmony)
{
HarmonyUtil.UninstallHarmony(HARMONY_ID);
}
}
static IEnumerable <CodeInstruction> Transpiler(IEnumerable <CodeInstruction> codes)
{
var from = typeof(NetAI).GetMethod("SimulationStep", BindingFlags.Public | BindingFlags.Instance, null,
new Type[] { typeof(ushort), typeof(NetSegment).MakeByRefType() }, null);
var to = typeof(NetManagerPatch).GetMethod("SimulationStep", BindingFlags.Static | BindingFlags.NonPublic);
var list = codes.ToList();
HarmonyUtil.ReplaceCalls(list, from, to);
return(list);
}
public static void Disable()
{
Log.Buffered = false;
//LoadingManager.instance.m_simulationDataReady -= SimulationDataReady;
LoadingManager.instance.m_levelPreLoaded -= Preload;
Unload(); // in case of hot unload
Exit();
#if FAST_TEST_HARMONY
HarmonyUtil.UninstallHarmony(HARMONY_ID);
#endif
}
public static void Unload()
{
if (!Loaded)
{
return; //protect against disabling from main menu.
}
Log.Info("LifeCycle.Unload() called");
HarmonyUtil.UninstallHarmony(HARMONY_ID);
Settings.GameConfig = null;
NodeControllerTool.Remove();
Loaded = false;
}
public static void Preload()
{
try {
Log.Info("LifeCycle.Preload() called");
PluginUtil.LogPlugins();
if (!preloadPatchesApplied_)
{
HarmonyUtil.InstallHarmony <PreloadPatchAttribute>(HARMONY_ID_MANUAL);
preloadPatchesApplied_ = true;
}
} catch (Exception ex) {
Log.Exception(ex);
}
}
public static void Unload()
{
try {
LogCalled();
UI.Debug.PWSelector.Release();
UI.Debug.PWModifier.Release();
ARTool.Release();
ObserverDisposable?.Dispose();
HintBox.Release();
HarmonyUtil.UninstallHarmony(HARMONY_ID);
NetworkExtensionManager.RawInstance?.OnUnload();
}catch (Exception ex) {
Log.Exception(ex);
}
}
static IEnumerable <CodeInstruction> Transpiler(IEnumerable <CodeInstruction> codes)
{
var fromSS = typeof(BuildingAI).GetMethod("SimulationStep", BindingFlags.Public | BindingFlags.Instance, null,
new Type[] { typeof(ushort), typeof(Building).MakeByRefType() }, null);
var toSS = typeof(BuildingManagerPatch).GetMethod("SimulationStep", BindingFlags.Static | BindingFlags.NonPublic);
var fromCU = typeof(BuildingAI).GetMethod("CheckUnlocking", BindingFlags.Public | BindingFlags.Instance);
var toCU = typeof(BuildingManagerPatch).GetMethod("CheckUnlocking", BindingFlags.Static | BindingFlags.NonPublic);
var list = codes.ToList();
HarmonyUtil.ReplaceCalls(list, fromSS, toSS);
HarmonyUtil.ReplaceCalls(list, fromCU, toCU);
return(list);
}
public static void Enable()
{
Log.Debug("Testing StackTrace:\n" + new StackTrace(true).ToString(), copyToGameLog: false);
KianCommons.UI.TextureUtil.EmbededResources = false;
HelpersExtensions.VERBOSE = false;
Loaded = false;
HarmonyHelper.EnsureHarmonyInstalled();
LoadingManager.instance.m_simulationDataReady += SimulationDataReady; // load/update data
if (HelpersExtensions.InGameOrEditor)
{
HotReload();
}
if (fastTestHarmony)
{
HarmonyUtil.InstallHarmony(HARMONY_ID);
}
}
public void OnDisabled()
{
Log.Info("OnDisabled() called Name:" + Name);
_isEnabled = false;
if (HelpersExtensions.InGameOrEditor)
{
HarmonyUtil.UninstallHarmony(LoadingExtension.HARMONY_ID);
}
PrefabUtils.ClearCache();
LoadingWrapperPatch.OnPostLevelLoaded -= PrefabUtils.CachePrefabs;
LoadingManager.instance.m_levelUnloaded -= PrefabUtils.ClearCache;
#if DEBUG
LoadingWrapperPatch.OnPostLevelLoaded -= TestOnLoad.Test;
#endif
Options.instance = null;
}
public void OnDisabled()
{
try {
foreach (var item in GameObject.FindObjectsOfType <EntryStatusPanel>())
{
GameObject.DestroyImmediate(item?.gameObject);
}
LoadingManager.instance.m_introLoaded -= CacheUtil.CacheData;
LoadingManager.instance.m_introLoaded -= LoadOrderUtil.TurnOffSteamPanels;
LoadingManager.instance.m_introLoaded -= CheckPatchLoader;
HarmonyUtil.UninstallHarmony(HARMONY_ID);
MonoStatus.Release();
LOMAssetDataExtension.Release();
Settings.ConfigUtil.Terminate();
CheckSubsUtil.RemoveEvents();
Log.Buffered = false;
} catch (Exception ex) {
Log.Exception(ex);
}
}
public static void InstallHarmony() => HarmonyUtil.InstallHarmony(HARMONY_ID);
public static void UninstallHarmony() => HarmonyUtil.UninstallHarmony(HARMONY_ID);
public void OnDisabled()
{
LifeCycle.Release();
HarmonyUtil.UninstallHarmony(HarmonyId);
}
public override void OnCreated(ILoading loading) => HarmonyUtil.InstallHarmony(HARMONY_ID);
public override void OnReleased() => HarmonyUtil.UninstallHarmony(HARMONY_ID);
public void OnEnabled()
{
HarmonyHelper.EnsureHarmonyInstalled();
HarmonyHelper.DoOnHarmonyReady(() => HarmonyUtil.InstallHarmony(HARMONY_ID));
}
public void OnApplicationStart()
{
HarmonyUtil.PatchGame();
config = Conf.CreateConfig(ConfigType.YAML, BeatSaber.UserDataPath, "BSMOTDPlus");
}
public void initDetours()
{
// TODO realize detouring with annotations
if (!DetourInited)
{
Log.Info("Init detours");
bool detourFailed = false;
try {
Log.Info("Deploying Harmony patches");
#if DEBUG
HarmonyInstance.DEBUG = true;
#endif
Assembly assembly = Assembly.GetExecutingAssembly();
HarmonyMethodStates.Clear();
// Harmony attribute-driven patching
Log.Info($"Performing Harmony attribute-driven patching");
HarmonyInst = HarmonyInstance.Create(HARMONY_ID);
HarmonyInst.PatchAll(assembly);
foreach (Type type in assembly.GetTypes())
{
object[] attributes = type.GetCustomAttributes(typeof(HarmonyPatch), true);
if (attributes.Length <= 0)
{
continue;
}
foreach (object attr in attributes)
{
HarmonyPatch harmonyPatchAttr = (HarmonyPatch)attr;
MethodBase info = HarmonyUtil.GetOriginalMethod(harmonyPatchAttr.info);
IntPtr ptr = info.MethodHandle.GetFunctionPointer();
RedirectCallsState state = RedirectionHelper.GetState(ptr);
HarmonyMethodStates[info] = state;
}
}
// Harmony manual patching
Log.Info($"Performing Harmony manual patching");
foreach (ManualHarmonyPatch manualPatch in ManualHarmonyPatches)
{
Log.Info($"Manually patching method {manualPatch.method.DeclaringType.FullName}.{manualPatch.method.Name}. Prefix: {manualPatch.prefix?.method}, Postfix: {manualPatch.postfix?.method}, Transpiler: {manualPatch.transpiler?.method}");
HarmonyInst.Patch(manualPatch.method, manualPatch.prefix, manualPatch.postfix, manualPatch.transpiler);
IntPtr ptr = manualPatch.method.MethodHandle.GetFunctionPointer();
RedirectCallsState state = RedirectionHelper.GetState(ptr);
HarmonyMethodStates[manualPatch.method] = state;
}
} catch (Exception e) {
Log.Error("Could not deploy Harmony patches");
Log.Info(e.ToString());
Log.Info(e.StackTrace);
detourFailed = true;
}
try {
Log.Info("Deploying attribute-driven detours");
DetouredMethodStates = AssemblyRedirector.Deploy();
} catch (Exception e) {
Log.Error("Could not deploy attribute-driven detours");
Log.Info(e.ToString());
Log.Info(e.StackTrace);
detourFailed = true;
}
if (detourFailed)
{
Log.Info("Detours failed");
Singleton <SimulationManager> .instance.m_ThreadingWrapper.QueueMainThread(() => {
UIView.library.ShowModal <ExceptionPanel>("ExceptionPanel").SetMessage("TM:PE failed to load", "Traffic Manager: President Edition failed to load. You can continue playing but it's NOT recommended. Traffic Manager will not work as expected.", true);
});
}
else
{
Log.Info("Detours successful");
}
DetourInited = true;
}
}
public void OnDisabled()
{
HarmonyUtil.UninstallHarmony(HARMONY_ID);
}
