Decompiled source of AdvancedWardenObjective v1.0.12
AdvancedWardenObjective.dll
Decompiled a month ago
The result has been truncated due to the large size, download it to view full contents!
using System; using System.CodeDom.Compiler; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Versioning; using System.Security; using System.Security.Cryptography; using System.Security.Permissions; using System.Text; using System.Text.Json; using System.Text.Json.Serialization; using AIGraph; using AK; using AWO.CustomFields; using AWO.Events; using AWO.Jsons; using AWO.Modules.WEE; using AWO.Modules.WOE; using AWO.Networking; using AWO.Networking.CommonReplicator.Inject; using AWO.Networking.Inject; using AWO.Sessions; using AWO.Utils; using AWO.WEE.Detours; using AWO.WEE.Events; using AWO.WEE.JsonInjects; using AWO.WEE.Replicators; using Agents; using BepInEx; using BepInEx.Core.Logging.Interpolation; using BepInEx.Logging; using BepInEx.Unity.IL2CPP; using BepInEx.Unity.IL2CPP.Hook; using BepInEx.Unity.IL2CPP.Utils; using BepInEx.Unity.IL2CPP.Utils.Collections; using ChainedPuzzles; using Enemies; using Expedition; using GTFO.API; using GTFO.API.Utilities; using GameData; using Globals; using HarmonyLib; using Il2CppInterop.Runtime; using Il2CppInterop.Runtime.Attributes; using Il2CppInterop.Runtime.Injection; using Il2CppInterop.Runtime.InteropTypes; using Il2CppInterop.Runtime.InteropTypes.Arrays; using Il2CppInterop.Runtime.InteropTypes.Fields; using Il2CppInterop.Runtime.Runtime; using Il2CppJsonNet; using Il2CppJsonNet.Linq; using Il2CppSystem; using Il2CppSystem.Collections.Generic; using InjectLib.FieldInjection; using InjectLib.JsonNETInjection; using InjectLib.JsonNETInjection.Converter; using InjectLib.JsonNETInjection.Handler; using InjectLib.JsonNETInjection.Supports; using LevelGeneration; using Localization; using Microsoft.CodeAnalysis; using Player; using SNetwork; using UnityEngine; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")] [assembly: AssemblyCompany("AdvancedWardenObjective")] [assembly: AssemblyConfiguration("Release")] [assembly: AssemblyFileVersion("1.0.12")] [assembly: AssemblyInformationalVersion("1.0.12+git00c1113-dirty-master.00c1113e8d709cb6d8ba8e22fa367ce077e1f344")] [assembly: AssemblyProduct("AdvancedWardenObjective")] [assembly: AssemblyTitle("AdvancedWardenObjective")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("1.0.12.0")] [module: UnverifiableCode] namespace Microsoft.CodeAnalysis { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] internal sealed class EmbeddedAttribute : Attribute { } } namespace System.Runtime.CompilerServices { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)] internal sealed class NullableAttribute : Attribute { public readonly byte[] NullableFlags; public NullableAttribute(byte P_0) { NullableFlags = new byte[1] { P_0 }; } public NullableAttribute(byte[] P_0) { NullableFlags = P_0; } } [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)] internal sealed class NullableContextAttribute : Attribute { public readonly byte Flag; public NullableContextAttribute(byte P_0) { Flag = P_0; } } } namespace AWO { [BepInPlugin("GTFO.AWO", "AWO", "1.0.12")] [BepInDependency(/*Could not decode attribute arguments.*/)] [BepInDependency(/*Could not decode attribute arguments.*/)] internal class EntryPoint : BasePlugin { public class AWOTerminalCommands { public WEE_EventData data; public bool hidden; public bool used; public AWOTerminalCommands(WEE_EventData e) { used = false; hidden = false; data = e; } } public static List<AWOTerminalCommands> AWOCommandList = new List<AWOTerminalCommands>(); public static float CountdownStarted { get; set; } public override void Load() { //IL_000f: Unknown result type (might be due to invalid IL or missing references) WardenEventExt.Initialize(); WardenObjectiveExt.Initialize(); new Harmony("AWO.Harmony").PatchAll(); AssetAPI.OnStartupAssetsLoaded += AssetAPI_OnStartupAssetsLoaded; WOEventDataFields.Init(); WODataBlockFields.Init(); } private void AssetAPI_OnStartupAssetsLoaded() { BlackoutState.AssetLoaded(); LevelFailUpdateState.AssetLoaded(); } } internal static class Logger { private static readonly ManualLogSource _Logger; static Logger() { //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_000f: Expected O, but got Unknown _Logger = new ManualLogSource("AWO"); Logger.Sources.Add((ILogSource)(object)_Logger); } private static string Format(object msg) { return msg.ToString(); } public static void Info(BepInExInfoLogInterpolatedStringHandler handler) { _Logger.LogInfo(handler); } public static void Info(string str) { _Logger.LogMessage((object)str); } public static void Info(object data) { _Logger.LogMessage((object)Format(data)); } public static void Debug(BepInExDebugLogInterpolatedStringHandler handler) { _Logger.LogDebug(handler); } public static void Debug(string str) { _Logger.LogDebug((object)str); } public static void Debug(object data) { _Logger.LogDebug((object)Format(data)); } public static void Error(BepInExErrorLogInterpolatedStringHandler handler) { _Logger.LogError(handler); } public static void Error(string str) { _Logger.LogError((object)str); } public static void Error(object data) { _Logger.LogError((object)Format(data)); } public static void Fatal(BepInExFatalLogInterpolatedStringHandler handler) { _Logger.LogFatal(handler); } public static void Fatal(string str) { _Logger.LogFatal((object)str); } public static void Fatal(object data) { _Logger.LogFatal((object)Format(data)); } public static void Warn(BepInExWarningLogInterpolatedStringHandler handler) { _Logger.LogWarning(handler); } public static void Warn(string str) { _Logger.LogWarning((object)str); } public static void Warn(object data) { _Logger.LogWarning((object)Format(data)); } [Conditional("DEBUG")] public static void DebugOnly(object data) { } } [GeneratedCode("VersionInfoGenerator", "2.0.0+git50a4b1a-master")] [CompilerGenerated] internal static class VersionInfo { public const string RootNamespace = "AWO"; public const string Version = "1.0.12"; public const string VersionPrerelease = null; public const string VersionMetadata = "git00c1113-dirty-master"; public const string SemVer = "1.0.12+git00c1113-dirty-master"; public const string GitRevShort = "00c1113-dirty"; public const string GitRevLong = "00c1113e8d709cb6d8ba8e22fa367ce077e1f344-dirty"; public const string GitBranch = "master"; public const string GitTag = null; public const bool GitIsDirty = true; } } namespace AWO.Utils { internal static class LocalizedTextExtensions { public static string ToText(this LocalizedText text) { if (!text.HasTranslation) { return text.UntranslatedText; } return Text.Get(text.Id); } } internal static class RandomExtensions { public static bool MeetProbability(this Random rand, float prob) { if (prob >= 1f) { return true; } if (prob <= 0f) { return false; } return prob >= rand.NextFloat01(); } public static float NextRange(this Random rand, float min, float max) { return rand.NextFloat01() * (max - min) + min; } public static float NextFloat01(this Random rand) { return (float)rand.NextDouble(); } } internal static class RNG { private static readonly Random _Rand = new Random(); public static float Float01 => (float)_Rand.NextDouble(); public static int Int0Positive => _Rand.Next(0, int.MaxValue); public static int Int0Negative => _Rand.Next(int.MinValue, 1); public static int Int => _Rand.Next(int.MinValue, int.MaxValue); public static bool MeetProbability(float prob) { if (prob >= 1f) { return true; } if (prob <= 0f) { return false; } return prob >= Float01; } } } namespace AWO.Sessions { internal struct BlackoutStatus { public bool blackoutEnabled; } internal static class BlackoutState { private static StateReplicator<BlackoutStatus> _Replicator; public static bool BlackoutEnabled { get; private set; } internal static void AssetLoaded() { if (_Replicator == null) { _Replicator = StateReplicator<BlackoutStatus>.Create(1u, new BlackoutStatus { blackoutEnabled = false }, LifeTimeType.Permanent); _Replicator.OnStateChanged += OnStateChanged; LevelEvents.OnLevelCleanup += LevelCleanup; } } private static void LevelCleanup() { SetEnabled(enabled: false); } public static void SetEnabled(bool enabled) { _Replicator.SetState(new BlackoutStatus { blackoutEnabled = enabled }); } private static void OnStateChanged(BlackoutStatus _, BlackoutStatus state, bool isRecall) { //IL_01c4: Unknown result type (might be due to invalid IL or missing references) //IL_01ca: Invalid comparison between Unknown and I4 //IL_02b7: Unknown result type (might be due to invalid IL or missing references) //IL_02bc: Unknown result type (might be due to invalid IL or missing references) bool flag = !state.blackoutEnabled; foreach (LG_LabDisplay labDisplay in LG_Objects.LabDisplays) { if (!((Object)(object)labDisplay == (Object)null) && !((Object)(object)labDisplay.m_Text == (Object)null)) { ((Behaviour)labDisplay.m_Text).enabled = flag; } } foreach (LG_ComputerTerminal terminal in LG_Objects.Terminals) { if ((Object)(object)terminal == (Object)null) { continue; } terminal.OnProximityExit(); Interact_ComputerTerminal componentInChildren = ((Component)terminal).GetComponentInChildren<Interact_ComputerTerminal>(true); if ((Object)(object)componentInChildren != (Object)null) { ((Behaviour)componentInChildren).enabled = flag; ((Interact_Base)componentInChildren).SetActive(flag); } GUIX_VirtualSceneLink component = ((Component)terminal).GetComponent<GUIX_VirtualSceneLink>(); if ((Object)(object)component != (Object)null && (Object)(object)component.m_virtualScene != (Object)null) { GUIX_VirtualCamera virtualCamera = component.m_virtualScene.virtualCamera; float num = (flag ? 0.3f : 0f); float num2 = (flag ? 1000f : 0f); virtualCamera.SetFovAndClip(virtualCamera.paramCamera.fieldOfView, num, num2); } if ((Object)(object)terminal.m_text != (Object)null) { ((Behaviour)terminal.m_text).enabled = flag; } if (!flag) { PlayerAgent localInteractionSource = terminal.m_localInteractionSource; if ((Object)(object)localInteractionSource != (Object)null && localInteractionSource.FPItemHolder.InTerminalTrigger) { terminal.ExitFPSView(); } } } foreach (LG_DoorButton doorButton in LG_Objects.DoorButtons) { if ((Object)(object)doorButton == (Object)null) { continue; } ((Component)doorButton.m_anim).gameObject.SetActive(flag); doorButton.m_enabled = flag; if (flag) { LG_WeakLock componentInChildren2 = ((Component)doorButton).GetComponentInChildren<LG_WeakLock>(); if ((Object)(object)componentInChildren2 == (Object)null) { doorButton.m_enabled = true; } else if ((int)componentInChildren2.Status == 3) { doorButton.m_enabled = true; } } } foreach (LG_WeakLock weakLock in LG_Objects.WeakLocks) { if ((Object)(object)weakLock == (Object)null) { continue; } ((Interact_Base)weakLock.m_intHack).m_isActive = flag; Transform val = ((Component)weakLock).transform.FindChild("HackableLock/SecurityLock/g_WeakLock/Security_Display_Locked"); if ((Object)(object)val != (Object)null) { ((Component)val).gameObject.active = flag; continue; } val = ((Component)weakLock).transform.FindChild("HackableLock/Security_Display_Locked"); if ((Object)(object)val != (Object)null) { ((Component)val).gameObject.active = flag; } } foreach (LG_HSUActivator_Core hSUActivator in LG_Objects.HSUActivators) { if ((Object)(object)hSUActivator == (Object)null || !hSUActivator.m_isWardenObjective || (int)hSUActivator.m_stateReplicator.State.status != 0) { continue; } hSUActivator.m_insertHSUInteraction.SetActive(flag); foreach (GameObject item in (Il2CppArrayBase<GameObject>)(object)hSUActivator.m_activateWhenActive) { item.SetActive(flag); } } BlackoutEnabled = state.blackoutEnabled; } } internal enum LevelFailMode { Default, Never, AnyPlayerDown } internal struct LevelFailCheck { public LevelFailMode mode; } internal sealed class LevelFailUpdateState { private static StateReplicator<LevelFailCheck> _Replicator; internal static void AssetLoaded() { if (_Replicator == null) { _Replicator = StateReplicator<LevelFailCheck>.Create(1u, new LevelFailCheck { mode = LevelFailMode.Default }, LifeTimeType.Permanent); LG_Factory.OnFactoryBuildStart += Action.op_Implicit((Action)delegate { _Replicator.ClearAllRecallSnapshot(); _Replicator.SetState(new LevelFailCheck { mode = LevelFailMode.Default }); }); _Replicator.OnStateChanged += OnStateChanged; LevelEvents.OnLevelCleanup += LevelCleanup; } } private static void LevelCleanup() { SetFailAllowed(allowed: true); } public static void SetFailAllowed(bool allowed) { _Replicator.SetState(new LevelFailCheck { mode = ((!allowed) ? LevelFailMode.Never : LevelFailMode.Default) }); } public static void SetFailWhenAnyPlayerDown(bool enabled) { _Replicator.SetState(new LevelFailCheck { mode = (enabled ? LevelFailMode.AnyPlayerDown : LevelFailMode.Default) }); } private static void OnStateChanged(LevelFailCheck _, LevelFailCheck state, bool __) { switch (state.mode) { case LevelFailMode.Default: Inject_LevelFailCheck.LevelFailAllowed = true; Inject_LevelFailCheck.LevelFailWhenAnyPlayerDown = false; break; case LevelFailMode.Never: Inject_LevelFailCheck.LevelFailAllowed = false; Inject_LevelFailCheck.LevelFailWhenAnyPlayerDown = false; break; case LevelFailMode.AnyPlayerDown: Inject_LevelFailCheck.LevelFailAllowed = true; Inject_LevelFailCheck.LevelFailWhenAnyPlayerDown = true; break; } } } public static class LG_Objects { private static readonly List<LG_ComputerTerminal> _TerminalList; private static readonly List<LG_LabDisplay> _LabDisplayList; private static readonly List<LG_DoorButton> _DoorButtonList; private static readonly List<LG_WeakLock> _WeakLockList; private static readonly List<LG_HSUActivator_Core> _HSUActivatorList; public static IEnumerable<LG_ComputerTerminal> Terminals => _TerminalList; public static IEnumerable<LG_LabDisplay> LabDisplays => _LabDisplayList; public static IEnumerable<LG_DoorButton> DoorButtons => _DoorButtonList; public static IEnumerable<LG_WeakLock> WeakLocks => _WeakLockList; public static IEnumerable<LG_HSUActivator_Core> HSUActivators => _HSUActivatorList; static LG_Objects() { _TerminalList = new List<LG_ComputerTerminal>(); _LabDisplayList = new List<LG_LabDisplay>(); _DoorButtonList = new List<LG_DoorButton>(); _WeakLockList = new List<LG_WeakLock>(); _HSUActivatorList = new List<LG_HSUActivator_Core>(); LevelEvents.OnLevelCleanup += OnLevelCleanup; } private static void OnLevelCleanup() { Clear(); } internal static void Clear() { _TerminalList.Clear(); _LabDisplayList.Clear(); _DoorButtonList.Clear(); _WeakLockList.Clear(); _HSUActivatorList.Clear(); EntryPoint.AWOCommandList.Clear(); } public static void AddTerminal(LG_ComputerTerminal terminal) { AddToList<LG_ComputerTerminal>(in _TerminalList, terminal); } public static void RemoveTerminal(LG_ComputerTerminal terminal) { RemoveFromList<LG_ComputerTerminal>(in _TerminalList, terminal); } public static void AddLabDisplay(LG_LabDisplay display) { AddToList<LG_LabDisplay>(in _LabDisplayList, display); } public static void RemoveLabDisplay(LG_LabDisplay display) { RemoveFromList<LG_LabDisplay>(in _LabDisplayList, display); } public static void AddDoorButton(LG_DoorButton button) { AddToList<LG_DoorButton>(in _DoorButtonList, button); } public static void RemoveDoorButton(LG_DoorButton button) { RemoveFromList<LG_DoorButton>(in _DoorButtonList, button); } public static void AddWeakLock(LG_WeakLock weaklock) { AddToList<LG_WeakLock>(in _WeakLockList, weaklock); } public static void RemoveWeakLock(LG_WeakLock weaklock) { RemoveFromList<LG_WeakLock>(in _WeakLockList, weaklock); } public static void AddHSUActivator(LG_HSUActivator_Core activator) { AddToList<LG_HSUActivator_Core>(in _HSUActivatorList, activator); } public static void RemoveHSUActivator(LG_HSUActivator_Core activator) { RemoveFromList<LG_HSUActivator_Core>(in _HSUActivatorList, activator); } private static void AddToList<O>(in List<O> list, O itemToAdd) where O : Component { int id = ((Object)(object)itemToAdd).GetInstanceID(); if (!list.Any((O t) => ((Object)(object)t).GetInstanceID() == id)) { list.Add(itemToAdd); } } private static void RemoveFromList<O>(in List<O> list, O itemToRemove) where O : Component { int id = ((Object)(object)itemToRemove).GetInstanceID(); int num = list.FindIndex((O i) => ((Object)(object)i).GetInstanceID() == id); if (num > -1) { list.RemoveAt(num); } } } } namespace AWO.Sessions.Inject { [HarmonyPatch(typeof(LG_DoorButton), "OnWeakLockUnlocked")] internal static class Inject_PreventDoorButtonUnlock { private static bool Prefix() { return !BlackoutState.BlackoutEnabled; } } [HarmonyPatch(typeof(LG_ComputerTerminal), "OnProximityEnter")] [HarmonyPatch(typeof(LG_ComputerTerminal), "OnProximityExit")] internal static class Inject_PreventTerminalProximity { private static bool Prefix() { return !BlackoutState.BlackoutEnabled; } } } namespace AWO.Sessions.Inject.LG { [HarmonyPatch(typeof(LG_ComputerTerminal))] internal static class Inject_LG_ComputerTerminal_Track { [HarmonyPatch("Setup")] [HarmonyPostfix] private static void Post_Spawn(LG_ComputerTerminal __instance) { LG_Objects.AddTerminal(__instance); } } [HarmonyPatch(typeof(LG_DoorButton))] internal static class Inject_LG_DoorButton_Track { [HarmonyPatch("Setup")] [HarmonyPostfix] private static void Post_Spawn(LG_DoorButton __instance) { LG_Objects.AddDoorButton(__instance); } } [HarmonyPatch(typeof(LG_HSUActivator_Core))] internal static class Inject_LG_HSUActivator_Track { [HarmonyPatch("Start")] [HarmonyPostfix] private static void Post_Spawn(LG_HSUActivator_Core __instance) { LG_Objects.AddHSUActivator(__instance); } } [HarmonyPatch(typeof(LG_LabDisplay))] internal static class Inject_LG_LabDisplay_Track { [HarmonyPatch("GenerateText")] [HarmonyPatch(new Type[] { typeof(int), typeof(SubComplex) })] [HarmonyPostfix] private static void Post_Spawn(LG_LabDisplay __instance) { LG_Objects.AddLabDisplay(__instance); } } [HarmonyPatch(typeof(LG_WeakLock))] internal static class Inject_LG_WeakLock_Track { [HarmonyPatch("Setup")] [HarmonyPostfix] private static void Post_Spawn(LG_WeakLock __instance) { LG_Objects.AddWeakLock(__instance); } } } namespace AWO.Networking { public interface IStateReplicatorHolder<S> where S : struct { StateReplicator<S> Replicator { get; } void OnStateChange(S oldState, S state, bool isRecall); } public sealed class ReplicatorHandshake { public delegate void ClientRequestedSyncDel(SNet_Player requestedPlayer); public struct Packet { public uint replicatorID; public PacketAction action; } public enum PacketAction : byte { Created, Destroyed, SyncRequest } public sealed class Data { public bool SetupOnHost; public bool SetupOnClient; } private readonly Dictionary<uint, Data> _Lookup = new Dictionary<uint, Data>(); public string EventName { get; private set; } public bool IsReadyToSync { get; private set; } public event ClientRequestedSyncDel OnClientSyncRequested; public static ReplicatorHandshake Create(string guid) { if (string.IsNullOrWhiteSpace(guid)) { return null; } string text = "RHs" + guid; if (!NetworkAPI.IsEventRegistered(text)) { return new ReplicatorHandshake(text); } return null; } private ReplicatorHandshake(string eventName) { EventName = eventName; NetworkAPI.RegisterEvent<Packet>(eventName, (Action<ulong, Packet>)OnSyncAction); } public void Reset() { _Lookup.Clear(); } private void OnSyncAction(ulong sender, Packet packet) { //IL_0090: Unknown result type (might be due to invalid IL or missing references) //IL_0096: Expected O, but got Unknown if (!SNet.IsMaster && sender == SNet.Master.Lookup) { if (packet.action == PacketAction.Created) { SetHostState(packet.replicatorID, isSetup: true); } else if (packet.action == PacketAction.Destroyed) { SetHostState(packet.replicatorID, isSetup: false); } } else { if (!SNet.IsMaster) { return; } if (packet.action == PacketAction.Created) { SetClientState(packet.replicatorID, isSetup: true); } else if (packet.action == PacketAction.Destroyed) { SetClientState(packet.replicatorID, isSetup: false); } else { if (packet.action != PacketAction.SyncRequest) { return; } SNet_Player requestedPlayer = default(SNet_Player); if (!SNet.TryGetPlayer(sender, ref requestedPlayer)) { bool flag = default(bool); BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(32, 1, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Cannot find player from sender: "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ulong>(sender); } Logger.Error(val); } else { this.OnClientSyncRequested?.Invoke(requestedPlayer); } } } } public void UpdateCreated(uint id) { if (SNet.IsInLobby) { if (SNet.IsMaster) { SetHostState(id, isSetup: true); NetworkAPI.InvokeEvent<Packet>(EventName, new Packet { replicatorID = id, action = PacketAction.Created }, (SNet_ChannelType)2); } else if (SNet.HasMaster) { SetClientState(id, isSetup: true); NetworkAPI.InvokeEvent<Packet>(EventName, new Packet { replicatorID = id, action = PacketAction.Created }, SNet.Master, (SNet_ChannelType)2); } else { Logger.Error("Handshake::MASTER is NULL in lobby; This should NOT happen!!!!!!!!!!!!"); } } else { Logger.Error("Handshake::Session Type StateReplicator cannot be created without lobby!"); } } public void UpdateDestroyed(uint id) { if (SNet.IsInLobby) { if (SNet.IsMaster) { SetHostState(id, isSetup: true); NetworkAPI.InvokeEvent<Packet>(EventName, new Packet { replicatorID = id, action = PacketAction.Destroyed }, (SNet_ChannelType)2); } else if (SNet.HasMaster) { SetClientState(id, isSetup: true); NetworkAPI.InvokeEvent<Packet>(EventName, new Packet { replicatorID = id, action = PacketAction.Destroyed }, SNet.Master, (SNet_ChannelType)2); } else { Logger.Error("Handshake::MASTER is NULL in lobby; This should NOT happen!!!!!!!!!!!!"); } } else { Logger.Error("Handshake::Session Type StateReplicator cannot be created without lobby!"); } } private void SetHostState(uint id, bool isSetup) { if (_Lookup.TryGetValue(id, out Data value)) { value.SetupOnHost = isSetup; } else { _Lookup[id] = new Data { SetupOnHost = isSetup }; } UpdateSyncState(id); } private void SetClientState(uint id, bool isSetup) { if (_Lookup.TryGetValue(id, out Data value)) { value.SetupOnClient = isSetup; } else { _Lookup[id] = new Data { SetupOnClient = isSetup }; } UpdateSyncState(id); } private void UpdateSyncState(uint id) { bool isReadyToSync = IsReadyToSync; if (_Lookup.TryGetValue(id, out Data value)) { IsReadyToSync = value.SetupOnHost && value.SetupOnClient; } else { IsReadyToSync = false; } if (IsReadyToSync && isReadyToSync != IsReadyToSync && SNet.HasMaster && !SNet.IsMaster) { NetworkAPI.InvokeEvent<Packet>(EventName, new Packet { replicatorID = id, action = PacketAction.SyncRequest }, SNet.Master, (SNet_ChannelType)2); } } } public delegate void OnReceiveDel<S>(ulong sender, uint replicatorID, S newState) where S : struct; public static class StatePayloads { public enum Size { State4Byte = 4, State8Byte = 8, State16Byte = 16, State32Byte = 32, State48Byte = 48, State64Byte = 64, State80Byte = 80, State96Byte = 96, State128Byte = 128, State196Byte = 196, State256Byte = 256 } public static Size GetSizeType(int size) { Size size2 = Size.State8Byte; foreach (object value in Enum.GetValues(typeof(Size))) { if (size <= (int)value && (int)size2 < (int)value) { size2 = (Size)value; break; } } return size2; } public static IReplicatorEvent<S> CreateEvent<S>(Size size, string eventName, OnReceiveDel<S> onReceiveCallback) where S : struct { return size switch { Size.State4Byte => ReplicatorPayloadWrapper<S, StatePayload4Byte>.Create(eventName, onReceiveCallback), Size.State8Byte => ReplicatorPayloadWrapper<S, StatePayload8Byte>.Create(eventName, onReceiveCallback), Size.State16Byte => ReplicatorPayloadWrapper<S, StatePayload16Byte>.Create(eventName, onReceiveCallback), Size.State32Byte => ReplicatorPayloadWrapper<S, StatePayload32Byte>.Create(eventName, onReceiveCallback), Size.State48Byte => ReplicatorPayloadWrapper<S, StatePayload48Byte>.Create(eventName, onReceiveCallback), Size.State64Byte => ReplicatorPayloadWrapper<S, StatePayload64Byte>.Create(eventName, onReceiveCallback), Size.State80Byte => ReplicatorPayloadWrapper<S, StatePayload80Byte>.Create(eventName, onReceiveCallback), Size.State96Byte => ReplicatorPayloadWrapper<S, StatePayload96Byte>.Create(eventName, onReceiveCallback), Size.State128Byte => ReplicatorPayloadWrapper<S, StatePayload128Byte>.Create(eventName, onReceiveCallback), Size.State196Byte => ReplicatorPayloadWrapper<S, StatePayload196Byte>.Create(eventName, onReceiveCallback), Size.State256Byte => ReplicatorPayloadWrapper<S, StatePayload256Byte>.Create(eventName, onReceiveCallback), _ => null, }; } public static S Get<S>(byte[] bytes, int bytesLength) where S : struct { int num = Marshal.SizeOf(typeof(S)); if (num > bytesLength) { throw new ArgumentException($"StateData Exceed size of {bytesLength} : Unable to Deserialize", "S"); } IntPtr intPtr = Marshal.AllocHGlobal(num); Marshal.Copy(bytes, 0, intPtr, num); S result = (S)Marshal.PtrToStructure(intPtr, typeof(S)); Marshal.FreeHGlobal(intPtr); return result; } public static void Set<S>(S stateData, int size, ref byte[] payloadBytes) where S : struct { if (Marshal.SizeOf(stateData) > size) { throw new ArgumentException($"StateData Exceed size of {size} : Unable to Serialize", "S"); } byte[] array = new byte[size]; IntPtr intPtr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(stateData, intPtr, fDeleteOld: false); Marshal.Copy(intPtr, array, 0, size); Marshal.FreeHGlobal(intPtr); payloadBytes = array; } } public interface IReplicatorEvent<S> where S : struct { string Name { get; } bool IsRegistered { get; } void Invoke(uint replicatorID, S data); void Invoke(uint replicatorID, S data, SNet_ChannelType channelType); void Invoke(uint replicatorID, S data, SNet_Player target); void Invoke(uint replicatorID, S data, SNet_Player target, SNet_ChannelType channelType); } public class ReplicatorPayloadWrapper<S, P> : IReplicatorEvent<S> where S : struct where P : struct, IStatePayload { public string Name { get; private set; } public bool IsRegistered { get; private set; } public static IReplicatorEvent<S> Create(string eventName, OnReceiveDel<S> onReceiveCallback) { ReplicatorPayloadWrapper<S, P> replicatorPayloadWrapper = new ReplicatorPayloadWrapper<S, P>(); replicatorPayloadWrapper.Register(eventName, onReceiveCallback); if (!replicatorPayloadWrapper.IsRegistered) { return null; } return replicatorPayloadWrapper; } public void Register(string eventName, OnReceiveDel<S> onReceiveCallback) { OnReceiveDel<S> onReceiveCallback2 = onReceiveCallback; if (!IsRegistered && !NetworkAPI.IsEventRegistered(eventName)) { NetworkAPI.RegisterEvent<P>(eventName, (Action<ulong, P>)delegate(ulong sender, P payload) { onReceiveCallback2?.Invoke(sender, payload.ID, payload.Get<S>()); }); IsRegistered = true; Name = eventName; } } public void Invoke(uint replicatorID, S data) { P val = new P { ID = replicatorID }; val.Set(data); NetworkAPI.InvokeEvent<P>(Name, val, (SNet_ChannelType)2); } public void Invoke(uint replicatorID, S data, SNet_ChannelType channelType) { //IL_002b: Unknown result type (might be due to invalid IL or missing references) P val = new P { ID = replicatorID }; val.Set(data); NetworkAPI.InvokeEvent<P>(Name, val, channelType); } public void Invoke(uint replicatorID, S data, SNet_Player target) { P val = new P { ID = replicatorID }; val.Set(data); NetworkAPI.InvokeEvent<P>(Name, val, target, (SNet_ChannelType)2); } public void Invoke(uint replicatorID, S data, SNet_Player target, SNet_ChannelType channelType) { //IL_002c: Unknown result type (might be due to invalid IL or missing references) P val = new P { ID = replicatorID }; val.Set(data); NetworkAPI.InvokeEvent<P>(Name, val, target, channelType); } } public interface IStatePayload { uint ID { get; set; } S Get<S>() where S : struct; void Set<S>(S stateData) where S : struct; } public struct StatePayload4Byte : IStatePayload { public const int Size = 4; private uint id; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] public byte[] PayloadBytes; public uint ID { get { return id; } set { id = value; } } public S Get<S>() where S : struct { return StatePayloads.Get<S>(PayloadBytes, 4); } public void Set<S>(S stateData) where S : struct { StatePayloads.Set(stateData, 4, ref PayloadBytes); } } public struct StatePayload8Byte : IStatePayload { public const int Size = 8; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)] public byte[] PayloadBytes; [field: MarshalAs(UnmanagedType.U4)] public uint ID { get; set; } public S Get<S>() where S : struct { return StatePayloads.Get<S>(PayloadBytes, 8); } public void Set<S>(S stateData) where S : struct { StatePayloads.Set(stateData, 8, ref PayloadBytes); } } public struct StatePayload16Byte : IStatePayload { public const int Size = 16; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)] public byte[] PayloadBytes; [field: MarshalAs(UnmanagedType.U4)] public uint ID { get; set; } public S Get<S>() where S : struct { return StatePayloads.Get<S>(PayloadBytes, 16); } public void Set<S>(S stateData) where S : struct { StatePayloads.Set(stateData, 16, ref PayloadBytes); } } public struct StatePayload32Byte : IStatePayload { public const int Size = 32; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)] public byte[] PayloadBytes; [field: MarshalAs(UnmanagedType.U4)] public uint ID { get; set; } public S Get<S>() where S : struct { return StatePayloads.Get<S>(PayloadBytes, 32); } public void Set<S>(S stateData) where S : struct { StatePayloads.Set(stateData, 32, ref PayloadBytes); } } public struct StatePayload48Byte : IStatePayload { public const int Size = 48; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 48)] public byte[] PayloadBytes; [field: MarshalAs(UnmanagedType.U4)] public uint ID { get; set; } public S Get<S>() where S : struct { return StatePayloads.Get<S>(PayloadBytes, 48); } public void Set<S>(S stateData) where S : struct { StatePayloads.Set(stateData, 48, ref PayloadBytes); } } public struct StatePayload64Byte : IStatePayload { public const int Size = 64; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 64)] public byte[] PayloadBytes; [field: MarshalAs(UnmanagedType.U4)] public uint ID { get; set; } public S Get<S>() where S : struct { return StatePayloads.Get<S>(PayloadBytes, 64); } public void Set<S>(S stateData) where S : struct { StatePayloads.Set(stateData, 64, ref PayloadBytes); } } public struct StatePayload80Byte : IStatePayload { public const int Size = 80; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 80)] public byte[] PayloadBytes; [field: MarshalAs(UnmanagedType.U4)] public uint ID { get; set; } public S Get<S>() where S : struct { return StatePayloads.Get<S>(PayloadBytes, 80); } public void Set<S>(S stateData) where S : struct { StatePayloads.Set(stateData, 80, ref PayloadBytes); } } public struct StatePayload96Byte : IStatePayload { public const int Size = 96; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 96)] public byte[] PayloadBytes; [field: MarshalAs(UnmanagedType.U4)] public uint ID { get; set; } public S Get<S>() where S : struct { return StatePayloads.Get<S>(PayloadBytes, 96); } public void Set<S>(S stateData) where S : struct { StatePayloads.Set(stateData, 96, ref PayloadBytes); } } public struct StatePayload128Byte : IStatePayload { public const int Size = 128; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 128)] public byte[] PayloadBytes; [field: MarshalAs(UnmanagedType.U4)] public uint ID { get; set; } public S Get<S>() where S : struct { return StatePayloads.Get<S>(PayloadBytes, 128); } public void Set<S>(S stateData) where S : struct { StatePayloads.Set(stateData, 128, ref PayloadBytes); } } public struct StatePayload196Byte : IStatePayload { public const int Size = 196; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 196)] public byte[] PayloadBytes; [field: MarshalAs(UnmanagedType.U4)] public uint ID { get; set; } public S Get<S>() where S : struct { return StatePayloads.Get<S>(PayloadBytes, 196); } public void Set<S>(S stateData) where S : struct { StatePayloads.Set(stateData, 196, ref PayloadBytes); } } public struct StatePayload256Byte : IStatePayload { public const int Size = 256; [MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)] public byte[] PayloadBytes; [field: MarshalAs(UnmanagedType.U4)] public uint ID { get; set; } public S Get<S>() where S : struct { return StatePayloads.Get<S>(PayloadBytes, 256); } public void Set<S>(S stateData) where S : struct { StatePayloads.Set(stateData, 256, ref PayloadBytes); } } public enum LifeTimeType { Permanent, Session } public sealed class StateReplicator<S> where S : struct { private readonly Dictionary<eBufferType, S> _RecallStateSnapshots = new Dictionary<eBufferType, S>(); public static readonly string Name; public static readonly string HashName; public static readonly string ClientRequestEventName; public static readonly string HostSetStateEventName; public static readonly string HostSetRecallStateEventName; public static readonly int StateSize; public static readonly StatePayloads.Size StateSizeType; private static readonly IReplicatorEvent<S> _C_RequestEvent; private static readonly IReplicatorEvent<S> _H_SetStateEvent; private static readonly IReplicatorEvent<S> _H_SetRecallStateEvent; private static readonly ReplicatorHandshake _Handshake; private static readonly Dictionary<uint, StateReplicator<S>> _Replicators; public bool IsValid => ID != 0; public bool IsInvalid => ID == 0; public uint ID { get; private set; } public LifeTimeType LifeTime { get; private set; } public IStateReplicatorHolder<S> Holder { get; private set; } public S State { get; private set; } public bool ClientSendStateAllowed { get; set; } = true; public bool CanSendToClient { get { if (SNet.IsInLobby) { return SNet.IsMaster; } return false; } } public bool CanSendToHost { get { if (SNet.IsInLobby && !SNet.IsMaster && SNet.HasMaster) { return ClientSendStateAllowed; } return false; } } public event Action<S, S, bool> OnStateChanged; public void SetState(S state) { if (!IsInvalid) { DoSync(state); } } public void SetStateUnsynced(S state) { if (!IsInvalid) { State = state; } } public void Unload() { if (IsValid) { _Replicators.Remove(ID); _RecallStateSnapshots.Clear(); _Handshake.UpdateDestroyed(ID); ID = 0u; } } private void DoSync(S newState) { if (!IsInvalid) { if (CanSendToClient) { _H_SetStateEvent.Invoke(ID, newState); Internal_ChangeState(newState, isRecall: false); } else if (CanSendToHost) { _C_RequestEvent.Invoke(ID, newState, SNet.Master); } } } private void Internal_ChangeState(S state, bool isRecall) { if (!IsInvalid) { S state2 = State; State = state; this.OnStateChanged?.Invoke(state2, state, isRecall); Holder?.OnStateChange(state2, state, isRecall); } } private void SendDropInState(SNet_Player target) { if (!IsInvalid) { if ((Object)(object)target == (Object)null) { Logger.Error("SendDropInState::Target was null??"); } else { _H_SetRecallStateEvent.Invoke(ID, State, target); } } } public void ClearAllRecallSnapshot() { if (!IsInvalid) { _RecallStateSnapshots.Clear(); } } private void SaveSnapshot(eBufferType type) { //IL_000f: Unknown result type (might be due to invalid IL or missing references) if (!IsInvalid) { _RecallStateSnapshots[type] = State; } } private void RestoreSnapshot(eBufferType type) { //IL_0017: Unknown result type (might be due to invalid IL or missing references) //IL_0040: Unknown result type (might be due to invalid IL or missing references) //IL_0046: Expected O, but got Unknown //IL_0060: Unknown result type (might be due to invalid IL or missing references) if (IsInvalid || !CanSendToClient) { return; } if (_RecallStateSnapshots.TryGetValue(type, out var value)) { _H_SetRecallStateEvent.Invoke(ID, value); Internal_ChangeState(value, isRecall: true); return; } bool flag = default(bool); BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(29, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("RestoreSnapshot"); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("::There was no snapshot for "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<eBufferType>(type); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("?"); } Logger.Error(val); } static StateReplicator() { _Replicators = new Dictionary<uint, StateReplicator<S>>(); Name = typeof(S).Name; StateSize = Marshal.SizeOf(typeof(S)); StateSizeType = StatePayloads.GetSizeType(StateSize); using MD5 mD = MD5.Create(); HashName = Convert.ToBase64String(mD.ComputeHash(Encoding.UTF8.GetBytes(typeof(S).FullName))); ClientRequestEventName = "SRs" + Name + "-" + HashName; HostSetStateEventName = "SRr" + Name + "-" + HashName; HostSetRecallStateEventName = "SRre" + Name + "-" + HashName; _C_RequestEvent = StatePayloads.CreateEvent<S>(StateSizeType, ClientRequestEventName, ClientRequestEventCallback); _H_SetStateEvent = StatePayloads.CreateEvent<S>(StateSizeType, HostSetStateEventName, HostSetStateEventCallback); _H_SetRecallStateEvent = StatePayloads.CreateEvent<S>(StateSizeType, HostSetRecallStateEventName, HostSetRecallStateEventCallback); _Handshake = ReplicatorHandshake.Create(Name + "-" + HashName); _Handshake.OnClientSyncRequested += ClientSyncRequested; Inject_SNet_Capture.OnBufferCapture += BufferStored; Inject_SNet_Capture.OnBufferRecalled += BufferRecalled; LevelEvents.OnLevelCleanup += LevelCleanedUp; } private static void ClientSyncRequested(SNet_Player requestedPlayer) { foreach (StateReplicator<S> value in _Replicators.Values) { if (value.IsValid) { value.SendDropInState(requestedPlayer); } } } private static void BufferStored(eBufferType type) { //IL_0023: Unknown result type (might be due to invalid IL or missing references) foreach (StateReplicator<S> value in _Replicators.Values) { if (value.IsValid) { value.SaveSnapshot(type); } } } private static void BufferRecalled(eBufferType type) { //IL_0023: Unknown result type (might be due to invalid IL or missing references) foreach (StateReplicator<S> value in _Replicators.Values) { if (value.IsValid) { value.RestoreSnapshot(type); } } } private static void LevelCleanedUp() { UnloadSessionReplicator(); } private StateReplicator() { } public static StateReplicator<S> Create(uint replicatorID, S startState, LifeTimeType lifeTime, IStateReplicatorHolder<S> holder = null) { //IL_006f: Unknown result type (might be due to invalid IL or missing references) //IL_0075: Expected O, but got Unknown if (replicatorID == 0) { Logger.Error("Replicator ID 0 is reserved for empty!"); return null; } if (_Replicators.ContainsKey(replicatorID)) { Logger.Error("Replicator ID has already assigned!"); return null; } StateReplicator<S> stateReplicator = new StateReplicator<S> { ID = replicatorID, LifeTime = lifeTime, Holder = holder, State = startState }; switch (lifeTime) { case LifeTimeType.Permanent: Logger.Debug("LifeTime is Permanent :: Handshaking is disabled!"); break; case LifeTimeType.Session: _Handshake.UpdateCreated(replicatorID); break; default: { bool flag = default(bool); BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(22, 1, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("LifeTime is invalid!: "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<LifeTimeType>(lifeTime); } Logger.Error(val); return null; } } _Replicators[replicatorID] = stateReplicator; return stateReplicator; } public static void UnloadSessionReplicator() { List<uint> list = new List<uint>(); foreach (StateReplicator<S> value in _Replicators.Values) { if (value.LifeTime == LifeTimeType.Session) { list.Add(value.ID); value.Unload(); } } foreach (uint item in list) { _Replicators.Remove(item); } _Handshake.Reset(); } private static void ClientRequestEventCallback(ulong sender, uint replicatorID, S newState) { if (SNet.IsMaster && _Replicators.TryGetValue(replicatorID, out StateReplicator<S> value)) { value.SetState(newState); } } private static void HostSetStateEventCallback(ulong sender, uint replicatorID, S newState) { if (SNet.HasMaster && SNet.Master.Lookup == sender && _Replicators.TryGetValue(replicatorID, out StateReplicator<S> value)) { value.Internal_ChangeState(newState, isRecall: false); } } private static void HostSetRecallStateEventCallback(ulong sender, uint replicatorID, S newState) { if (SNet.HasMaster && SNet.Master.Lookup == sender && _Replicators.TryGetValue(replicatorID, out StateReplicator<S> value)) { value.Internal_ChangeState(newState, isRecall: true); } } } } namespace AWO.Networking.CommonReplicator.Inject { [HarmonyPatch(typeof(WardenObjectiveManager), "CheckExpeditionFailed")] internal static class Inject_LevelFailCheck { public static bool LevelFailAllowed = true; public static bool LevelFailWhenAnyPlayerDown = false; private static void Postfix(ref bool __result) { if (!LevelFailAllowed) { __result = false; } else if (LevelFailWhenAnyPlayerDown && HasAnyDownedPlayer()) { __result = true; } } private static bool HasAnyDownedPlayer() { bool result = false; int count = PlayerManager.PlayerAgentsInLevel.Count; if (count <= 0) { return false; } for (int i = 0; i < count; i++) { if (!((Agent)PlayerManager.PlayerAgentsInLevel[i]).Alive) { result = true; } } return result; } } } namespace AWO.Networking.Inject { [HarmonyPatch(typeof(SNet_Capture))] internal static class Inject_SNet_Capture { public static event Action<eBufferType> OnBufferCapture; public static event Action<eBufferType> OnBufferRecalled; [HarmonyPatch("TriggerCapture")] [HarmonyPrefix] private static void Pre_TriggerCapture(SNet_Capture __instance) { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Unknown result type (might be due to invalid IL or missing references) //IL_0011: Unknown result type (might be due to invalid IL or missing references) eBufferType primedBufferType = __instance.PrimedBufferType; Inject_SNet_Capture.OnBufferCapture?.Invoke(primedBufferType); } [HarmonyPatch("RecallBuffer")] [HarmonyPostfix] [HarmonyWrapSafe] private static void Post_RecallBuffer(SNet_Capture __instance, eBufferType bufferType) { //IL_0013: Unknown result type (might be due to invalid IL or missing references) if (!__instance.IsRecalling) { Inject_SNet_Capture.OnBufferRecalled?.Invoke(bufferType); } } } } namespace AWO.Modules.WOE { public static class WardenObjectiveExt { private static readonly Dictionary<eWardenObjectiveType, Type> _DTOTypes; private static readonly List<WOE_ContextBase> _ActiveContexts; static WardenObjectiveExt() { //IL_0076: Unknown result type (might be due to invalid IL or missing references) //IL_0093: Unknown result type (might be due to invalid IL or missing references) //IL_009a: Expected O, but got Unknown //IL_016c: Unknown result type (might be due to invalid IL or missing references) //IL_0109: Unknown result type (might be due to invalid IL or missing references) //IL_0110: Expected O, but got Unknown _DTOTypes = new Dictionary<eWardenObjectiveType, Type>(); _ActiveContexts = new List<WOE_ContextBase>(); bool flag = default(bool); foreach (Type item in from x in typeof(WOE_ContextBase).Assembly.GetTypes() where !x.IsAbstract where x.IsAssignableTo(typeof(WOE_ContextBase)) select x) { WOE_ContextBase wOE_ContextBase = (WOE_ContextBase)Activator.CreateInstance(item); if (_DTOTypes.TryGetValue(wOE_ContextBase.TargetType, out Type _)) { Logger.Error("Duplicate TargetType Detected!"); BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(14, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("With '"); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(item.Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' and '"); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(wOE_ContextBase.GetType().Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'"); } Logger.Error(val); } else if (!wOE_ContextBase.DataType.IsAssignableTo(typeof(WOE_DataBase))) { BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(41, 3, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(item.Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" does not have valid "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("DataType"); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (not derived from "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("WOE_DataBase"); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")"); } Logger.Error(val); } else { _DTOTypes[wOE_ContextBase.TargetType] = item; } } WOEvents.OnSetup += ObjectiveSetup; LevelEvents.OnLevelCleanup += LevelCleanup; } internal static void Initialize() { } private static void ObjectiveSetup(LG_LayerType layer, int chainIndex) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_004b: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0016: Expected O, but got Unknown //IL_0067: Unknown result type (might be due to invalid IL or missing references) //IL_001b: Unknown result type (might be due to invalid IL or missing references) WardenObjectiveDataBlock val = default(WardenObjectiveDataBlock); Type value; if (!WardenObjectiveManager.TryGetWardenObjectiveDataForLayer(layer, chainIndex, ref val)) { bool flag = default(bool); BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(44, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<LG_LayerType>(layer); ((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" Layer (CI: "); ((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(chainIndex); ((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(") does not have ObjectiveData!!!"); } Logger.Error(val2); } else if (_DTOTypes.TryGetValue(val.Type, out value)) { WOE_ContextBase wOE_ContextBase = (WOE_ContextBase)Activator.CreateInstance(value); wOE_ContextBase.Setup(layer, chainIndex); _ActiveContexts.Add(wOE_ContextBase); } } private static void LevelCleanup() { foreach (WOE_ContextBase activeContext in _ActiveContexts) { activeContext.OnLevelCleanup(); } _ActiveContexts.Clear(); } } internal abstract class WOE_ContextBase { public abstract eWardenObjectiveType TargetType { get; } public abstract Type DataType { get; } protected WOE_DataBase Data { get; private set; } protected LG_LayerType Layer { get; private set; } protected int ChainIndex { get; private set; } public void Setup(LG_LayerType layer, int chainIndex) { //IL_0001: Unknown result type (might be due to invalid IL or missing references) Layer = layer; ChainIndex = chainIndex; } public virtual void OnSetup() { } public virtual void OnBuildDone() { } public virtual void OnBuildDoneLate() { } public virtual void OnLevelCleanup() { } } internal abstract class WOE_DataBase { public uint ObjectiveID { get; set; } public WardenObjectiveDataBlock GameData { get; set; } } } namespace AWO.Modules.WOE.Objectives.Uplinks { internal sealed class WOE_UplinkContext : WOE_ContextBase { public override eWardenObjectiveType TargetType => (eWardenObjectiveType)8; public override Type DataType => typeof(WOE_UplinkData); } internal sealed class WOE_UplinkData : WOE_DataBase { public UplinkCodeBehaviour[] CodeBehaviours { get; set; } = Array.Empty<UplinkCodeBehaviour>(); } internal sealed class UplinkCodeBehaviour { public bool ShowCodesOnTerminal { get; set; } public bool ShowCodesOnHUD { get; set; } = true; public bool ShowCodeToOtherTerminal { get; set; } = true; public TerminalZoneSelectionData TerminalZone { get; set; } = new TerminalZoneSelectionData(); public TerminalOutput[] StartOutputs { get; set; } = Array.Empty<TerminalOutput>(); public TerminalOutput[] EndOutputs { get; set; } = Array.Empty<TerminalOutput>(); public WardenObjectiveEventData[] EventsOnStart { get; set; } = Array.Empty<WardenObjectiveEventData>(); public WardenObjectiveEventData[] EventsOnEnd { get; set; } = Array.Empty<WardenObjectiveEventData>(); } } namespace AWO.Modules.WOE.Objectives.ReactorStartups { internal sealed class WOE_ReactorStartupContext : WOE_ContextBase { public override eWardenObjectiveType TargetType => (eWardenObjectiveType)1; public override Type DataType => typeof(WOE_ReactorStartupData); } internal enum ReactorWavePuzzleType { Default, CustomLock, UseCommand_OnMainTerminal, UseCommand_InZone, PowerGenerator_InZone } internal sealed class WOE_ReactorStartupData : WOE_DataBase { public bool RemoveMainStartupCommand { get; set; } public bool RemoveMainVerifyCommand { get; set; } public ScriptedWaveData[] WaveDatas { get; set; } = Array.Empty<ScriptedWaveData>(); public ReactorWavePuzzleData[] WavePuzzles { get; set; } = Array.Empty<ReactorWavePuzzleData>(); } internal enum SettingWarpMode { Clamped, Repeat, PingPong } internal sealed class ScriptedWaveData { public float[] IntroDuration { get; set; } = Array.Empty<float>(); public SettingWarpMode IntroDurationWarpMode { get; set; } public float[] WaveDuration { get; set; } = Array.Empty<float>(); public SettingWarpMode WaveDurationWarpMode { get; set; } public string[][] WaveInstructions { get; set; } = Array.Empty<string[]>(); public SettingWarpMode WaveInstructionsWarpMode { get; set; } } internal sealed class ReactorWavePuzzleData { public ReactorWavePuzzleType Type { get; set; } public bool ShowBeacon { get; set; } public string BeaconText { get; set; } = "Auxiliary Terminal"; public Color BeaconColor { get; set; } = Color.magenta; public string Command { get; set; } = "REACTOR_CONTINUE"; public string CommandDescription { get; set; } = "CONTINUE REACTOR STARTUP PROCESS"; public bool ForceJumpWaveWhenSolved { get; set; } = true; } } namespace AWO.Modules.WOE.Objectives.GenClusters { internal sealed class WOE_GenClusterContext : WOE_ContextBase { public override eWardenObjectiveType TargetType => (eWardenObjectiveType)9; public override Type DataType => typeof(int); } } namespace AWO.Modules.WOE.JsonInjects { internal class ObjectiveDataHandler : Il2CppJsonReferenceTypeHandler<WardenObjectiveDataBlock> { public override void OnRead(in Object result, in JToken jToken) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_0008: Invalid comparison between Unknown and I4 //IL_000d: Unknown result type (might be due to invalid IL or missing references) //IL_0022: Unknown result type (might be due to invalid IL or missing references) //IL_0029: Invalid comparison between Unknown and I4 JToken val = default(JToken); if ((int)jToken.Type == 1 && ((JObject)jToken).TryGetValue("woeEnabled", ref val) && (int)val.Type == 9 && (bool)val) { ((Il2CppObjectBase)result).Cast<WardenObjectiveDataBlock>(); } } } } namespace AWO.Modules.WEE { public static class WardenEventExt { internal static readonly Dictionary<WEE_Type, BaseEvent> _EventsToTrigger; static WardenEventExt() { //IL_0087: Unknown result type (might be due to invalid IL or missing references) //IL_008d: Expected O, but got Unknown _EventsToTrigger = new Dictionary<WEE_Type, BaseEvent>(); bool flag = default(bool); foreach (Type item in from x in typeof(BaseEvent).Assembly.GetTypes() where !x.IsAbstract where x.IsAssignableTo(typeof(BaseEvent)) select x) { BaseEvent baseEvent = (BaseEvent)Activator.CreateInstance(item); if (_EventsToTrigger.TryGetValue(baseEvent.EventType, out BaseEvent value)) { Logger.Error("Duplicate EventType Detected!"); BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(14, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("With '"); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(value.Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' and '"); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(baseEvent.Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'"); } Logger.Error(val); } else { baseEvent.Setup(); _EventsToTrigger[baseEvent.EventType] = baseEvent; } } } internal static void Initialize() { ClassInjector.RegisterTypeInIl2Cpp<ScanPositionReplicator>(); ClassInjector.RegisterTypeInIl2Cpp<ZoneLightReplicator>(); JsonInjector.SetConverter<eWardenObjectiveEventType>((Il2CppJsonUnmanagedTypeConverter<eWardenObjectiveEventType>)new EventTypeConverter()); JsonInjector.AddHandler<WardenObjectiveEventData>((Il2CppJsonReferenceTypeHandler<WardenObjectiveEventData>)(object)new EventDataHandler()); WEE_EnumInjector.Inject(); Detour_ExecuteEvent.Patch(); } internal static void HandleEvent(WEE_Type type, WardenObjectiveEventData e, float currentDuration) { //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_000b: Expected O, but got Unknown //IL_0055: Unknown result type (might be due to invalid IL or missing references) //IL_005b: Expected O, but got Unknown bool flag = default(bool); BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(36, 1, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("we got type "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<WEE_Type>(type); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" on WardenEventExt event"); } Logger.Debug(val); WEE_EventData wEEData = e.GetWEEData(); if (wEEData != null) { CoroutineManager.StartCoroutine(CollectionExtensions.WrapToIl2Cpp(Handle(type, wEEData, currentDuration)), (Action)null); return; } BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(71, 1, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("WardenEvent Type is Extension ("); ((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<WEE_Type>(type); ((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(") But it's not registered to dataholder!"); } Logger.Error(val2); } private static IEnumerator Handle(WEE_Type type, WEE_EventData e, float currentDuration) { float num = Mathf.Max(e.Delay - currentDuration, 0f); if (num > 0f) { yield return (object)new WaitForSeconds(num); } if (WorldEventManager.GetCondition(e.Condition.ConditionIndex) != e.Condition.IsTrue) { yield break; } WardenObjectiveManager.DisplayWardenIntel(e.Layer, e.WardenIntel.ToLocalizedText()); if (e.DialogueID != 0) { PlayerDialogManager.WantToStartDialog(e.DialogueID, -1, false, false); } if (e.SoundID != 0) { WardenObjectiveManager.Current.m_sound.Post(e.SoundID, true); string text = e.SoundSubtitle.ToString(); if (!string.IsNullOrWhiteSpace(text)) { GuiManager.PlayerLayer.ShowMultiLineSubtitle(text); } } if (e.SubObjective.DoUpdate) { WardenObjectiveManager.UpdateSyncCustomSubObjective(e.SubObjective.CustomSubObjectiveHeader.ToLocalizedText(), e.SubObjective.CustomSubObjective.ToLocalizedText()); } if (e.Fog.DoUpdate) { EnvironmentStateManager.AttemptStartFogTransition(e.Fog.FogSetting, e.Fog.FogTransitionDuration, e.DimensionIndex); } if (_EventsToTrigger.TryGetValue(type, out BaseEvent value)) { value.Trigger(e); yield break; } bool flag = default(bool); BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(26, 1, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<WEE_Type>(type); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" does not exist in lookup!"); } Logger.Error(val); } } internal static class WEE_EnumInjector { public const int ExtendedIndex = 10000; private static readonly Dictionary<string, object> _EventTypes; private static int _CurrentIndex; static WEE_EnumInjector() { //IL_0037: Unknown result type (might be due to invalid IL or missing references) //IL_003e: Expected O, but got Unknown _EventTypes = new Dictionary<string, object>(); _CurrentIndex = 0; WEE_Type[] values = Enum.GetValues<WEE_Type>(); bool flag = default(bool); for (int i = 0; i < values.Length; i++) { WEE_Type wEE_Type = values[i]; string text = wEE_Type.ToString(); AddEvent(text); BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(22, 1, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Injecting EWOEvent: '"); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'"); } Logger.Debug(val); } } private static void AddEvent(string name) { _EventTypes[name] = _CurrentIndex + 10000; _CurrentIndex++; } internal static void Inject() { EnumInjector.InjectEnumValues<eWardenObjectiveEventType>(_EventTypes); } } public sealed class WEE_EventData { public WEE_Type Type { get; set; } public WorldEventConditionPair Condition { get; set; } = new WorldEventConditionPair { ConditionIndex = -1, IsTrue = false }; public uint ChainPuzzle { get; set; } public bool UseStaticBioscanPoints { get; set; } public eWardenObjectiveEventTrigger Trigger { get; set; } public eDimensionIndex DimensionIndex { get; set; } public LG_LayerType Layer { get; set; } public eLocalZoneIndex LocalIndex { get; set; } public Vector3 Position { get; set; } = Vector3.zero; public float Delay { get; set; } public LocaleText WardenIntel { get; set; } = LocaleText.Empty; public uint SoundID { get; set; } public LocaleText SoundSubtitle { get; set; } = LocaleText.Empty; public uint DialogueID { get; set; } public bool Enabled { get; set; } = true; public WEE_SubObjectiveData SubObjective { get; set; } = new WEE_SubObjectiveData(); public WEE_UpdateFogData Fog { get; set; } = new WEE_UpdateFogData(); public WEE_ReactorEventData Reactor { get; set; } = new WEE_ReactorEventData(); public WEE_CountdownData Countdown { get; set; } = new WEE_CountdownData(); public WEE_CleanupEnemiesData CleanupEnemies { get; set; } = new WEE_CleanupEnemiesData(); public WEE_ZoneLightData SetZoneLight { get; set; } = new WEE_ZoneLightData(); public bool CleanUpEnemiesBehind { get; set; } = true; public WEE_SpawnHibernateData SpawnHibernates { get; set; } = new WEE_SpawnHibernateData(); public WEE_SpawnScoutData SpawnScouts { get; set; } = new WEE_SpawnScoutData(); public WEE_AddTerminalCommand AddTerminalCommand { get; set; } = new WEE_AddTerminalCommand(); public WEE_HideTerminalCommand HideTerminalCommand { get; set; } = new WEE_HideTerminalCommand(); public WEE_UnhideTerminalCommand UnhideTerminalCommand { get; set; } = new WEE_UnhideTerminalCommand(); public WEE_AddChainPuzzleToSecurityDoor AddChainPuzzleToSecurityDoor { get; set; } = new WEE_AddChainPuzzleToSecurityDoor(); public WardenObjectiveEventData CreateDummyEventData() { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0005: Unknown result type (might be due to invalid IL or missing references) //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_001d: Unknown result type (might be due to invalid IL or missing references) //IL_0029: Unknown result type (might be due to invalid IL or missing references) //IL_002b: Unknown result type (might be due to invalid IL or missing references) //IL_0035: Unknown result type (might be due to invalid IL or missing references) //IL_0042: Expected O, but got Unknown return new WardenObjectiveEventData { Type = (eWardenObjectiveEventType)Type, ChainPuzzle = ChainPuzzle, UseStaticBioscanPoints = UseStaticBioscanPoints, Trigger = Trigger, Condition = Condition }; } } public sealed class WEE_UpdateFogData { public bool DoUpdate { get; set; } public uint FogSetting { get; set; } public float FogTransitionDuration { get; set; } } public sealed class WEE_SubObjectiveData { public bool DoUpdate { get; set; } public LocaleText CustomSubObjectiveHeader { get; set; } = LocaleText.Empty; public LocaleText CustomSubObjective { get; set; } = LocaleText.Empty; } public sealed class WEE_ReactorEventData { public enum WaveState { Intro, Wave, Verify } public WaveState State { get; set; } public int Wave { get; set; } = 1; public float Progress { get; set; } } public sealed class WEE_DoorInteractionData { public bool LockdownState { get; set; } public string LockdownMessage { get; set; } } public sealed class WEE_CountdownData { public float Duration { get; set; } public LocaleText TimerText { get; set; } = LocaleText.Empty; public Color TimerColor { get; set; } = Color.red; public WardenObjectiveEventData[] EventsOnDone { get; set; } = Array.Empty<WardenObjectiveEventData>(); } public sealed class WEE_CleanupEnemiesData { public enum CleanUpType { Kill, Despawn } public CleanUpType Type { get; set; } = CleanUpType.Despawn; public bool IncludeHibernate { get; set; } = true; public bool IncludeAggressive { get; set; } = true; public bool IncludeScout { get; set; } = true; public uint[] ExcludeEnemyID { get; set; } = Array.Empty<uint>(); public void DoClear(AIG_CourseNode node) { //IL_0061: Unknown result type (might be due to invalid IL or missing references) //IL_0066: Unknown result type (might be due to invalid IL or missing references) //IL_0068: Unknown result type (might be due to invalid IL or missing references) //IL_006b: Unknown result type (might be due to invalid IL or missing references) //IL_0081: Expected I4, but got Unknown //IL_0101: Unknown result type (might be due to invalid IL or missing references) //IL_0107: Unknown result type (might be due to invalid IL or missing references) //IL_010b: Unknown result type (might be due to invalid IL or missing references) //IL_0111: Unknown result type (might be due to invalid IL or missing references) //IL_0115: Unknown result type (might be due to invalid IL or missing references) //IL_011b: Unknown result type (might be due to invalid IL or missing references) if (!SNet.IsMaster || node == null || node.m_enemiesInNode == null) { return; } List<EnemyAgent> list = new List<EnemyAgent>(); list.Clear(); Enumerator<EnemyAgent> enumerator = node.m_enemiesInNode.GetEnumerator(); while (enumerator.MoveNext()) { EnemyAgent current = enumerator.Current; list.Add(current); } foreach (EnemyAgent item in list) { AgentMode mode = ((AgentAI)item.AI).Mode; if ((mode - 1) switch { 0 => IncludeAggressive, 2 => IncludeScout, 3 => IncludeHibernate, _ => true, } && !ExcludeEnemyID.Contains(item.EnemyDataID)) { switch (Type) { case CleanUpType.Despawn: ((Agent)item).m_replicator.Despawn(); break; case CleanUpType.Kill: item.Damage.IsImortal = false; item.Damage.BulletDamage(((Dam_SyncedDamageBase)item.Damage).DamageMax, (Agent)null, default(Vector3), default(Vector3), default(Vector3), false, 0, 1f, 1f, 0u); break; } } } } } public sealed class WEE_ZoneLightData { public enum ModifierType : byte { RevertToOriginal, SetZoneLightData } public ModifierType Type { get; set; } public uint LightDataID { get; set; } public float TransitionDuration { get; set; } = 0.5f; public int Seed { get; set; } } public sealed class WEE_SpawnHibernateData { public int AreaIndex { get; set; } = -1; public uint EnemyID { get; set; } public uint Count { get; set; } = 1u; public Vector3 Position { get; set; } = Vector3.zero; public Vector3 Rotation { get; set; } = Vector3.zero; } public sealed class WEE_SpawnScoutData { public int AreaIndex { get; set; } = -1; public eEnemyGroupType GroupType { get; set; } public eEnemyRoleDifficulty Difficulty { get; set; } public uint Count { get; set; } = 1u; } public enum FilterMode { Exclude, Include } public sealed class WEE_AddTerminalCommand { public int TerminalIndex { get; set; } public int CommandNumber { get; set; } = 6; public string Command { get; set; } = ""; public string CommandDesc { get; set; } = ""; public TERM_CommandRule SpecialCommandRule { get; set; } public WardenObjectiveEventData[] CommandEvents { get; set; } = Array.Empty<WardenObjectiveEventData>(); public TerminalOutput[] PostCommandOutputs { get; set; } = Array.Empty<TerminalOutput>(); } public sealed class WEE_HideTerminalCommand { public int TerminalIndex { get; set; } public TERM_Command CommandEnum { get; set; } public int CommandNumber { get; set; } } public sealed class WEE_UnhideTerminalCommand { public int TerminalIndex { get; set; } public TERM_Command CommandEnum { get; set; } public int CommandNumber { get; set; } } public sealed class WEE_AddChainPuzzleToSecurityDoor { public uint ChainPuzzle { get; set; } } public enum WEE_Type { CloseSecurityDoor = 10000, LockSecurityDoor, SetDoorInteraction, TriggerSecurityDoorAlarm, SolveSecurityDoorAlarm, StartReactor, ModifyReactorWaveState, ForceCompleteReactor, ForceCompleteLevel, ForceFailLevel, Countdown, SetLevelFailCheckEnabled, SetLevelFailWhenAnyPlayerDowned, KillAllPlayers, KillPlayersInZone, SolveSingleObjectiveItem, SetLightDataInZone, AlertEnemiesInZone, CleanupEnemiesInZone, SpawnHibernateInZone, SpawnScoutInZone, SaveCheckpoint, MoveExtractionWorldPosition, SetBlackoutEnabled, AddTerminalCommand, HideTerminalCommand, UnhideTerminalCommand, AddChainPuzzleToSecurityDoor } } namespace AWO.Modules.WEE.Events.World { internal sealed class KillPlayersInZoneEvent : BaseEvent { public override WEE_Type EventType => WEE_Type.KillPlayersInZone; protected override void TriggerMaster(WEE_EventData e) { //IL_006f: Unknown result type (might be due to invalid IL or missing references) //IL_0075: Unknown result type (might be due to invalid IL or missing references) //IL_0079: Unknown result type (might be due to invalid IL or missing references) //IL_007f: Unknown result type (might be due to invalid IL or missing references) if (!TryGetZone(e, out LG_Zone zone)) { LogError("Cannot find zone!"); return; } int iD = zone.ID; Enumerator<PlayerAgent> enumerator = PlayerManager.PlayerAgentsInLevel.GetEnumerator(); while (enumerator.MoveNext()) { PlayerAgent current = enumerator.Current; AIG_CourseNode courseNode = ((Agent)current).CourseNode; if (courseNode != null && !((Object)(object)courseNode.m_zone == (Object)null) && courseNode.m_zone.ID == iD) { ((Dam_SyncedDamageBase)current.Damage).ExplosionDamage(((Dam_SyncedDamageBase)current.Damage).DamageMax, default(Vector3), default(Vector3), 0u); } } } } internal sealed class SetLevelFailWhenAnyPlayerDownEvent : BaseEvent { public override WEE_Type EventType => WEE_Type.SetLevelFailWhenAnyPlayerDowned; protected override void TriggerMaster(WEE_EventData e) { LevelFailUpdateState.SetFailWhenAnyPlayerDown(e.Enabled); } } } namespace AWO.Modules.WEE.Events.Enemy { internal class SpawnHibernateInZoneEvent : BaseEvent { private const float TimeToCompleteSpawn = 2f; public override WEE_Type EventType => WEE_Type.SpawnHibernateInZone; protected override void TriggerMaster(WEE_EventData e) { //IL_0026: Unknown result type (might be due to invalid IL or missing references) //IL_002b: Unknown result type (might be due to invalid IL or missing references) //IL_0069: Unknown result type (might be due to invalid IL or missing references) //IL_006f: Unknown result type (might be due to invalid IL or missing references) //IL_0074: Unknown result type (might be due to invalid IL or missing references) if (!TryGetZone(e, out LG_Zone zone) || (Object)(object)zone == (Object)null) { return; } WEE_SpawnHibernateData spawnHibernates = e.SpawnHibernates; if (spawnHibernates.Count == 1 && spawnHibernates.Position != Vector3.zero) { if (IsValidAreaIndex(spawnHibernates.AreaIndex, zone)) { EnemyAllocator.Current.SpawnEnemy(spawnHibernates.EnemyID, zone.m_areas[spawnHibernates.AreaIndex].m_courseNode, (AgentMode)4, spawnHibernates.Position, Quaternion.Euler(spawnHibernates.Rotation), (EnemyGroup)null, -1); } } else if (spawnHibernates.AreaIndex == -1 || IsValidAreaIndex(spawnHibernates.AreaIndex, zone)) { CoroutineDispatcher.StartCoroutine(DoSpawn(spawnHibernates, zone)); } } private static IEnumerator DoSpawn(WEE_SpawnHibernateData e, LG_Zone zone) { AgentMode mode = (AgentMode)4; float SpawnInterval = 2f / (float)e.Count; Random rand = new Random(); List<LG_Area> areas = zone.m_areas; Vector3 randomPositionInside = default(Vector3); for (int SpawnCount = 0; SpawnCount < e.Count; SpawnCount++) { AIG_CourseNode val = ((e.AreaIndex != -1) ? areas[e.AreaIndex].m_courseNode : areas[rand.Next(0, areas.Count)].m_courseNode); bool flag = false; ((Vector3)(ref randomPositionInside))..ctor(0f, 0f, 0f); while (!flag) { bool flag2 = false; randomPositionInside = val.GetRandomPositionInside(); Enumerator<PlayerAgent> enumerator = PlayerManager.PlayerAgentsInLevel.GetEnumerator(); while (enumerator.MoveNext()) { if (Vector3.Distance(((Agent)enumerator.Current).Position, randomPositionInside) < 2f) { flag2 = true; } } if (!flag2) { flag = true; } } Quaternion val2 = Quaternion.Euler(0f, (float)Random.Range(0, 360), 0f); EnemyAllocator.Current.SpawnEnemy(e.EnemyID, val, mode, randomPositionInside, val2, (EnemyGroup)null, -1); yield return (object)new WaitForSeconds(SpawnInterval); } } private static bool IsValidAreaIndex(int areaIndex, LG_Zone zone) { //IL_0019: Unknown result type (might be due to invalid IL or missing references) //IL_001f: Expected O, but got Unknown List<LG_Area> areas = zone.m_areas; if (areaIndex < 0 || areaIndex >= areas.Count) { bool flag = default(bool); BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(19, 1, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Invalid area index "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(areaIndex); } Logger.Error(val); return false; } return true; } } internal class SpawnScoutInZoneEvent : BaseEvent { private const float TimeToCompleteSpawn = 2f; public override WEE_Type EventType => WEE_Type.SpawnScoutInZone; protected override void TriggerMaster(WEE_EventData e) { //IL_0046: Unknown result type (might be due to invalid IL or missing references) //IL_004c: Expected O, but got Unknown if (!TryGetZone(e, out LG_Zone zone) || (Object)(object)zone == (Object)null) { return; } WEE_SpawnScoutData spawnScouts = e.SpawnScouts; if (spawnScouts.AreaIndex != -1 && (spawnScouts.AreaIndex < 0 || spawnScouts.AreaIndex >= zone.m_areas.Count)) { bool flag = default(bool); BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(28, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Invalid AreaIndex "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(spawnScouts.AreaIndex); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" for ZONE_"); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(zone.Alias); } Logger.Error(val); } else { CoroutineDispatcher.StartInLevelCoroutine(DoSpawn(e, zone)); } } private static IEnumerator DoSpawn(WEE_EventData e, LG_Zone zone) { WEE_SpawnScoutData ss = e.SpawnScouts; float SpawnInterval = 2f / (float)ss.Count; bool flag = default(bool); for (int SpawnCount = 0; SpawnCount < ss.Count; SpawnCount++) { EnemyGroupRandomizer val = null; if (!EnemySpawnManager.TryCreateEnemyGroupRandomizer(ss.GroupType, ss.Difficulty, ref val) || val == null) { BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(48, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Invalid scout group: (GroupType: "); ((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<eEnemyGroupType>(ss.GroupType); ((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", Difficulty: "); ((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<eEnemyRoleDifficulty>(ss.Difficulty); ((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(")"); } Logger.Error(val2); break; } EnemyGroupDataBlock randomGroup = val.GetRandomGroup(Builder.SessionSeedRandom.Value("NO_TAG")); float num = randomGroup.MaxScore * Builder.SessionSeedRandom.Range(1f, 1.2f, "NO_TAG"); AIG_CourseNode val3 = ((ss.AreaIndex == -1) ? zone.m_areas[RNG.Int0Positive % zone.m_areas.Count].m_courseNode : zone.m_areas[ss.AreaIndex].m_courseNode); pEnemyGroupSpawnData spawnData = EnemyGroup.GetSpawnData(val3.GetRandomPositionInside(), val3, (EnemyGroupType)0, (eEnemyGroupSpawnType)0, ((GameDataBlockBase<EnemyGroupDataBlock>)(object)randomGroup).persistentID, num, (IReplicator)null, (SurvivalWave)null, 0u, (AgentMode)4); spawnData.respawn = false; EnemyGroup.Spawn(spawnData); yield return (object)new WaitForSeconds(SpawnInterval); } } } } namespace AWO.WEE.Replicators { internal struct ScanPositionState { public Vector3 position; public int nodeID; } internal sealed class ScanPositionReplicator : MonoBehaviour, IStateReplicatorHolder<ScanPositionState> { public Il2CppReferenceField<NavMarker> Marker; public Il2CppReferenceField<CP_Bioscan_Core> TrackingScan; public Il2CppValueField<bool> IsExitScan; [HideFromIl2Cpp] public StateReplicator<ScanPositionState> Replicator { get; private set; } public void Setup(uint id) { //IL_001c: Unknown result type (might be due to invalid IL or missing references) //IL_0021: Unknown result type (might be due to invalid IL or missing references) CP_Bioscan_Core value = TrackingScan.Value; ScanPositionState scanPositionState = default(ScanPositionState); scanPositionState.position = ((Component)value).transform.position; scanPositionState.nodeID = value.CourseNode.NodeID; ScanPositionState startState = scanPositionState; Replicator = StateReplicator<ScanPositionState>.Create(id, startState, LifeTimeType.Session, this); } public void TryUpdatePosition(Vector3 position) { //IL_0017: Unknown result type (might be due to invalid IL or missing references) //IL_001d: Unknown result type (might be due to invalid IL or missing references) //IL_0022: Unknown result type (might be due to invalid IL or missing references) //IL_0041: Unknown result type (might be due to invalid IL or missing references) //IL_0042: Unknown result type (might be due to invalid IL or missing references) AIG_CourseNode val = default(AIG_CourseNode); if (Replicator != null && !Replicator.IsInvalid && AIG_CourseNode.TryGetCourseNode(GameObjectDimensionExtensions.GetDimension(position).DimensionIndex, position, 6f, ref val)) { Replicator.SetState(new ScanPositionState { position = position, nodeID = val.NodeID }); } } [HideFromIl2Cpp] void IStateReplicatorHolder<ScanPositionState>.OnStateChange(ScanPositionState oldState, ScanPositionState state, bool isRecall) { //IL_0013: Unknown result type (might be due to invalid IL or missing references) //IL_001e: Unknown result type (might be due to invalid IL or missing references) //IL_0023: Unknown result type (might be due to invalid IL or missing references) CP_Bioscan_Core value = TrackingScan.Value; ((Component)value).transform.position = state.position; if ((int)value.State.status != 0) { value.PlayerScanner.StopScan(); value.PlayerScanner.StartScan(); } Marker.Value.SetTrackingObject(((Component)value).gameObject); AIG_CourseNode val = default(AIG_CourseNode); if (AIG_CourseNode.GetCourseNode(state.nodeID, ref val)) { value.CourseNode.UnregisterBioscan(value); value.m_courseNode = val; val.RegisterBioscan(value); } if (IsExitScan.Value) { string formattedText = value.m_courseNode.m_zone.NavInfo.GetFormattedText((LG_NavInfoFormat)6); WardenObjectiveManager.SetObjectiveTextFragment((LG_LayerType)0, 0, (eWardenTextFragment)6, formattedText); WardenObjectiveManager.SetObjectiveTextFragment((LG_LayerType)1, 0, (eWardenTextFragment)6, formattedText); WardenObjectiveManager.SetObjectiveTextFragment((LG_LayerType)2, 0, (eWardenTextFragment)6, formattedText); WardenObjectiveManager.UpdateObjectiveGUIWithCurrentState((LG_LayerType)0, false, false, false); WardenObjectiveManager.UpdateObjectiveGUIWithCurrentState((LG_LayerType)1, false, false, false); WardenObjectiveManager.UpdateObjectiveGUIWithCurrentState((LG_LayerType)2, false, false, false); } } } internal struct ZoneLightState { public uint lightData; public int lightSeed; public float duration; } internal struct LightTransitionData { public enum Mode { Enabled, Disabled, Flickering } public float startIntensity; public float endIntensity; public Color startColor; public Color endColor; public Mode endMode; public int endModeSeed; } internal class LightWorker { public LG_Zone OwnerZone; public LG_Light Light; public Color OrigColor; public bool OrigEnabled; public float PrefabIntensity; public float OrigIntensity; public Coroutine LightAnimationRoutine; public void ApplyLightSetting(LightSettingsDataBlock lightDB, float duration, int seed, int subseed) { //IL_0020: Unknown result type (might be due to invalid IL or missing references) //IL_0025: Unknown result type (might be due to invalid IL or missing references) //IL_002c: Unknown result type (might be due to invalid IL or missing references) //IL_006a: Unknown result type (might be due to invalid IL or missing references) //IL_006f: Unknown result type (might be due to invalid IL or missing references) //IL_0076: Unknown result type (might be due to invalid IL or missing references) //IL_007b: Unknown result type (might be due to invalid IL or missing references) //IL_00df: Unknown result type (might be due to invalid IL or missing references) //IL_00e4: Unknown result type (might be due to invalid IL or missing references) //IL_00ec: Unknown result type (might be due to invalid IL or missing references) //IL_00f1: Unknown result type (might be due to invalid IL or missing references) Random random = new Random(seed); for (int i = 0; i < Mathf.Abs(subseed); i++) { random.Next(); } LightSettingSelector val = new LightSettingSelector(); val.Setup(Light.m_category, lightDB); LightCategorySetting val2 = default(LightCategorySetting); if (val.TryGetRandomSetting((uint)subseed, ref val2)) { if (!random.MeetProbability(val2.Chance)) { MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)OwnerZone, LightTransition(new LightTransitionData { startColor = Light.m_color, endColor = Color.black, startIntensity = Light.m_intensity, endIntensity = 0f, endMode = LightTransitionData.Mode.Disabled }, duration)); } else { LightTransitionData.Mode endMode = (random.MeetProbability(val2.ChanceBroken) ? LightTransitionData.Mode.Flickering : LightTransitionData.Mode.Enabled); MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)OwnerZone, LightTransition(new LightTransitionData { startColor = Light.m_color, endColor = val2.Color, startIntensity = Light.m_intensity, endIntensity = PrefabIntensity * val2.IntensityMul, endMode = endMode, endModeSeed = random.Next() }, duration)); } } } private IEnumerator LightTransition(LightTransitionData data, float duration) { float time = 0f; WaitForFixedUpdate yielder = new WaitForFixedUpdate(); while (time <= duration) { time += Time.fixedDeltaTime; float num = time / duration; Light.ChangeColor(Color.Lerp(data.startColor, data.endColor, num)); Light.ChangeIntensity(Mathf.Lerp(data.startIntensity, data.endIntensity, num)); yield return yielder; } StopAnimation(); switch (data.endMode) { case LightTransitionData.Mode.Enabled: Light.SetEnabled(true); break; case LightTransitionData.Mode.Disabled: Light.SetEnabled(false); break; case LightTransitionData.Mode.Flickering: Light.SetEnabled(true); LightAnimationRoutine = MonoBehaviourExtensions.StartCoroutine((MonoBehaviour)(object)OwnerZone, LightAnimation(data.endModeSeed)); break; } } private IEnumerator LightAnimation(int seed) { Random rand = new Random(seed); WaitForFixedUpdate yielder = new WaitForFixedUpdate(); while (true) { float time2 = 0f; float duration = rand.NextRange(1f, 3.5f); float speed = rand.NextRange(1.5f, 4f); int num = rand.Next(0, 2); if (num != 0) { if (num == 1) { while (time2 <= duration) { float offDuration = rand.NextFloat01() * 0.5f; float onDuration = rand.NextFloat01() * 0.5f; Light.SetEnabled(false); yield return (object)new WaitForSeconds(offDuration); time2 += offDuration; Light.SetEnabled(true); yield return (object)new WaitForSeconds(onDuration); time2 += onDuration; } } } else { while (time2 <= duration) { time2 += Time.fixedDeltaTime; float num2 = Mathf.PerlinNoise(Time.time * speed, 0f); Light.ChangeIntensity(OrigIntensity * num2); yield return yielder; } } } } private void StopAnimation() { if (LightAnimationRoutine != null) { ((MonoBehaviour)OwnerZone).StopCoroutine(LightAnimationRoutine); } } public void Revert() { //IL_0007: Unknown result type (might be due to invalid IL or missing references) Light.ChangeColor(OrigColor); Light.ChangeIntensity(OrigIntensity); Light.SetEnabled(OrigEnabled); } } internal sealed class ZoneLightReplicator : MonoBehaviour, IStateReplicatorHolder<ZoneLightState> { public LightWorker[] LightsInZone; public StateReplicator<ZoneLightState> Replicator { get; private set; } public void Setup(LG_Zone zone) { Replicator = StateReplicator<ZoneLightState>.Create((uint)(zone.ID + 1), new ZoneLightState { lightData = 0u }, LifeTimeType.Session, this); List<LightWorker> list = new List<LightWorker>(); Enumerator<AIG_CourseNode> enumerator = zone.m_courseNodes.GetEnumerator(); while (enumerator.MoveNext()) { foreach (LG_Light componentsInChild in ((Component)enumerator.Current.m_area).GetComponentsInChildren<LG_Light>(false)) { list.Add(new LightWorker { OwnerZone = zone, Light = componentsInChild, PrefabIntensity = componentsInChild.m_intensity }); } } LightsInZone = list.ToArray(); } public void Setup_UpdateLightSetting() { //IL_0015: Unknown result type (might be due to invalid IL or missing references) //IL_001a: Unknown result type (might be due to invalid IL or missing references) LightWorker[] lightsInZone = LightsInZone; foreach (LightWorker obj in lightsInZone) { obj.OrigColor = obj.Light.m_color; obj.OrigIntensity = obj.Light.m_intensity; obj.OrigEnabled = ((Component)obj.Light).gameObject.active; } } private void OnDestroy() { Replicator?.Unload(); } public void SetLightSetting(WEE_ZoneLightData data) { if (Replicator != null && !Replicator.IsInvalid) { int num = data.Seed; if (num == 0) { num = RNG.Int; } Replicator.SetState(new ZoneLightState { lightData = data.LightDataID, lightSeed = num, duration = data.TransitionDuration }); } } public void RevertLightData() { if (Replicator != null && !Replicator.IsInvalid) { Replicator.SetState(new ZoneLightState { lightData = 0u }); } } public void OnStateChange(ZoneLightState oldState, ZoneLightState state, bool isRecall) { if (state.lightData == 0) { for (int i = 0; i < LightsInZone.Length; i++) { LightsInZone[i].Revert(); } return; } LightSettingsDataBlock block = GameDataBlockBase<LightSettingsDataBlock>.GetBlock(state.lightData); if (block != null) { for (int j = 0; j < LightsInZone.Length; j++) { LightsInZone[j].ApplyLightSetting(block, isRecall ? 0f : state.duration, state.lightSeed, j); } } } } } namespace AWO.WEE.JsonInjects { internal class EventDataHandler : Il2CppJsonReferenceTypeHandler<WardenObjectiveEventData> { public override void OnRead(in Object result, in JToken jToken) { //IL_0009: Unknown result type (might be due to invalid IL or missing references) //IL_0013: Expected I4, but got Unknown WardenObjectiveEventData val = ((Il2CppObjectBase)result).Cast<WardenObjectiveEventData>(); if (Enum.IsDefined((WEE_Type)val.Type)) { WEE_EventData data = InjectLibJSON.Deserialize<WEE_EventData>(((Object)jToken).ToString(), Array.Empty<JsonConverter>()); val.SetWEEData(data); } } } internal class EventTypeConverter : Il2CppJsonUnmanagedTypeConverter<eWardenObjectiveEventType> { protected override eWardenObjectiveEventType Read(JToken jToken, eWardenObjectiveEventType existingValue, JsonSerializer serializer) { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0006: Unknown result type (might be due to invalid IL or missing references) //IL_0007: Unknown result type (might be due to invalid IL or missing references) //IL_0009: Invalid comparison between Unknown and I4 //IL_000b: Unknown result type (might be due to invalid IL or missing references) //IL_000d: Invalid comparison between Unknown and I4 //IL_003b: Unknown result type (might be due to invalid IL or missing references) //IL_003e: Expected I4, but got Unknown JTokenType type = jToken.Type; int num; if ((int)type != 6) { if ((int)type != 8) { return (eWardenObjectiveEventType)0; } string value = (string)jToken; if (Enum.TryParse<WEE_Type>(value, ignoreCase: true, out var result)) { num = (int)result; } else { if (!Enum.TryParse<eWardenObjectiveEventType>(value, ignoreCase: true, out eWardenObjectiveEventType result2)) { return (eWardenObjectiveEventType)0; } num = (int)result2; } } else { num = (int)jToken; } return (eWardenObjectiveEventType)num; } protected override void Write(JsonWriter writer, eWardenObjectiveEventType value, JsonSerializer serializer) { //IL_0001: Unknown result type (might be due to invalid IL or missing references) //IL_0007: Expected I4, but got Unknown writer.WriteValue((int)value); } protected override Object ToIl2CppObject(eWardenObjectiveEventType value) { //IL_0002: Unknown result type (might be due to invalid IL or missing references) //IL_000a: Unknown result type (might be due to invalid IL or missing references) //IL_0010: Expected I4, but got Unknown Int32 val = default(Int32); val.m_value = (int)value; return ((Int32)(ref val)).BoxIl2CppObject(); } } } namespace AWO.WEE.Inject { [HarmonyPatch(typeof(LG_BuildZoneLightsJob), "Build")] internal static class Inject_ZoneLightJob { private static void Prefix(LG_BuildZoneLightsJob __instance) { LG_Zone zone = __instance.m_zone; if (!((Object)(object)zone == (Object)null) && (Object)(object)((Component)zone).gameObject.GetComponent<ZoneLightReplicator>() == (Object)null) { ((Component)zone).gameObject.AddComponent<ZoneLightReplicator>().Setup(zone); } } private static void Postfix(bool __result, LG_BuildZoneLightsJob __instance) { if (!__result) { return; } LG_Zone zone = __instance.m_zone; if (!((Object)(object)zone == (Object)null)) { ZoneLightReplicator component = ((Component)zone).gameObject.GetComponent<ZoneLightReplicator>(); if ((Object)(object)component != (Object)null) { component.Setup_UpdateLightSetting(); } } } } } namespace AWO.WEE.Events { internal abstract class BaseEvent { public string Name { get; private set; } = string.Empty; protected PlayerAgent LocalPlayer { get; private set; } protected static bool IsMaster => SNet.IsMaster; protected static bool HasMaster => SNet.HasMaster; public abstract WEE_Type EventType { get; } public void Setup() { Name = GetType().Name; OnSetup(); } public void Trigger(WEE_EventData e) { //IL_000c: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Expected O, but got Unknown if (!PlayerManager.HasLocalPlayerAgent()) { bool flag = default(bool); BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(47, 1, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Doesn't have LocalPlayer while triggering "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" wtf?"); } Logger.Error(val); } else { LocalPlayer = PlayerManager.GetLocalPlayerAgent(); TriggerCommon(e); if (SNet.IsMaster) { TriggerMaster(e); } else { TriggerClient(e); } } } protected virtual void OnSetup() { } protected virtual void TriggerCommon(WEE_EventData e) { } protected virtual void TriggerClient(WEE_EventData e) { } protected virtual void TriggerMaster(WEE_EventData e) { } protected void LogInfo(string msg) { //IL_0004: Unknown result type (might be due to invalid IL or missing references) //IL_000a: Expected O, but got Unknown bool flag = default(bool); BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(3, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("["); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(msg); } Logger.Info(val); } protected void LogInfo(BepInExInfoLogInterpolatedStringHandler handler) { //IL_000c: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Expected O, but got Unknown if (((BepInExLogInterpolatedStringHandler)handler).Enabled) { bool flag = default(bool); BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(3, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("["); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<BepInExInfoLogInterpolatedStringHandler>(handler); } Logger.Info(val); } } protected void LogDebug(string msg) { //IL_0004: Unknown result type (might be due to invalid IL or missing references) //IL_000a: Expected O, but got Unknown bool flag = default(bool); BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(3, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("["); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(msg); } Logger.Debug(val); } protected void LogDebug(BepInExDebugLogInterpolatedStringHandler handler) { //IL_000c: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Expected O, but got Unknown if (((BepInExLogInterpolatedStringHandler)handler).Enabled) { bool flag = default(bool); BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(3, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("["); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<BepInExDebugLogInterpolatedStringHandler>(handler); } Logger.Debug(val); } } protected void LogWarning(string msg) { //IL_0004: Unknown result type (might be due to invalid IL or missing references) //IL_000a: Expected O, but got Unknown bool flag = default(bool); BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(3, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("["); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(msg); } Logger.Warn(val); } protected void LogWarning(BepInExWarningLogInterpolatedStringHandler handler) { //IL_000c: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Expected O, but got Unknown if (((BepInExLogInterpolatedStringHandler)handler).Enabled) { bool flag = default(bool); BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(3, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("["); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<BepInExWarningLogInterpolatedStringHandler>(handler); } Logger.Warn(val); } } protected void LogError(string msg) { //IL_0004: Unknown result type (might be due to invalid IL or missing references) //IL_000a: Expected O, but got Unknown bool flag = default(bool); BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(3, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("["); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] "); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(msg); } Logger.Error(val); } protected void LogError(BepInExErrorLogInterpolatedStringHandler handler) { //IL_000c: Unknown result type (might be due to invalid IL or missing references) //IL_0012: Expected O, but got Unknown if (((BepInExLogInterpolatedStringHandler)handler).Enabled) { bool flag = default(bool); BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(3, 2, ref flag); if (flag) { ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("["); ((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Name); ((BepInExLogInterpolatedStringHandler)val).AppendLiteral("] "); ((BepInEx