alexandria_p-Keep_Camera_After_Death Source

Communities

Content WarningKeep_Camera_After_Death

Install

Last Updated

First Uploaded

Downloads

74K

Likes

Size

807KB

Dependency string

alexandria_p-Keep_Camera_After_Death-1.3.0

Dependants

18 other mods

Mods Tools Misc Camera Mods BepInEx All Clients

Download

Details Required (3)Wiki Changelog Versions Analysis

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using KeepCameraAfterDeath.Patches;
using Microsoft.CodeAnalysis;
using MonoMod.RuntimeDetour.HookGen;
using MyceliumNetworking;
using On;
using Photon.Pun;
using Unity.Mathematics;
using UnityEngine;
using Zorro.Settings;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("alexandria-p.KeepCameraAfterDeath")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.3.0.0")]
[assembly: AssemblyInformationalVersion("1.3.0+809bc897adf7dc5fd4cf17919321e62fc10a4cc0")]
[assembly: AssemblyProduct("KeepCameraAfterDeath")]
[assembly: AssemblyTitle("alexandria-p.KeepCameraAfterDeath")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.3.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
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;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace KeepCameraAfterDeath
{
	[ContentWarningPlugin("alexandria-p.KeepCameraAfterDeath", "1.3.0", false)]
	[BepInPlugin("alexandria-p.KeepCameraAfterDeath", "KeepCameraAfterDeath", "1.3.0")]
	public class FixR2Modman : BaseUnityPlugin
	{
		internal static ManualLogSource Logger { get; private set; }

		private void Awake()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			GameObject val = new GameObject("KeepCameraAfterDeathPluginR2ModMan")
			{
				hideFlags = (HideFlags)61
			};
			val.AddComponent<KeepCameraAfterDeath>();
			KeepCameraAfterDeath.Instance.SetLogger(((BaseUnityPlugin)this).Logger);
			Object.DontDestroyOnLoad((Object)(object)val);
		}
	}
	public class KeepCameraAfterDeath : MonoBehaviour
	{
		[ContentWarningSetting]
		public class EnableRewardForCameraReturnSetting : BoolSetting, IExposedSetting
		{
			public SettingCategory GetSettingCategory()
			{
				return (SettingCategory)4;
			}

			public override void ApplyValue()
			{
				Instance.SetPlayerSettingEnableRewardForCameraReturn(((BoolSetting)this).Value);
			}

			public string GetDisplayName()
			{
				return "KeepCameraAfterDeath: Turn on incentives for bringing the camera back to the surface (uses the host's game settings)";
			}

			protected override bool GetDefaultValue()
			{
				return true;
			}
		}

		[ContentWarningSetting]
		public class SetMetaCoinRewardForCameraReturnSetting : FloatSetting, IExposedSetting
		{
			public SettingCategory GetSettingCategory()
			{
				return (SettingCategory)4;
			}

			public override void ApplyValue()
			{
				Instance.SetPlayerSettingMetaCoinReward(((FloatSetting)this).Value);
			}

			public string GetDisplayName()
			{
				return "KeepCameraAfterDeath: Meta Coin (MC) reward for camera return (uses the host's game settings)";
			}

			protected override float GetDefaultValue()
			{
				return 10f;
			}

			protected override float2 GetMinMaxValue()
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				return new float2(0f, 100f);
			}
		}

		[ContentWarningSetting]
		public class SetCashRewardForCameraReturnSetting : FloatSetting, IExposedSetting
		{
			public SettingCategory GetSettingCategory()
			{
				return (SettingCategory)4;
			}

			public override void ApplyValue()
			{
				Instance.SetPlayerSettingCashReward(((FloatSetting)this).Value);
			}

			public string GetDisplayName()
			{
				return "KeepCameraAfterDeath: Cash reward for camera return (uses the host's game settings)";
			}

			protected override float GetDefaultValue()
			{
				return 0f;
			}

			protected override float2 GetMinMaxValue()
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				return new float2(0f, 1000f);
			}
		}

		private const uint myceliumNetworkModId = 61812u;

		public static KeepCameraAfterDeath Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		public bool PlayerSettingEnableRewardForCameraReturn { get; private set; }

		public float PlayerSettingMetaCoinReward { get; private set; }

		public float PlayerSettingCashReward { get; private set; }

		public ItemInstanceData? PreservedCameraInstanceDataForHost { get; private set; }

		public (float cash, float mc)? PendingRewardForCameraReturn { get; private set; }

		public void SetLogger(ManualLogSource logger)
		{
			Logger = logger;
			Logger.LogInfo((object)"KeepCameraAfterDeath v1.3.0 has loaded!");
		}

		private void Awake()
		{
			Instance = this;
			HookAll();
		}

		private void Start()
		{
			MyceliumNetwork.RegisterNetworkObject((object)Instance, 61812u, 0);
		}

		private void OnDestroy()
		{
			MyceliumNetwork.DeregisterNetworkObject((object)Instance, 61812u, 0);
		}

		internal static void HookAll()
		{
			SurfaceNetworkHandlerPatch.Init();
			VideoCameraPatch.Init();
			PersistentObjectsHolderPatch.Init();
			PlayerPatch.Init();
		}

		internal static void UnhookAll()
		{
			HookEndpointManager.RemoveAllOwnedBy((object)Assembly.GetExecutingAssembly());
		}

		public void SetPlayerSettingEnableRewardForCameraReturn(bool rewardEnabled)
		{
			PlayerSettingEnableRewardForCameraReturn = rewardEnabled;
		}

		public void SetPlayerSettingMetaCoinReward(float mcReward)
		{
			PlayerSettingMetaCoinReward = mcReward;
		}

		public void SetPlayerSettingCashReward(float cashReward)
		{
			PlayerSettingCashReward = cashReward;
		}

		public void SetPreservedCameraInstanceDataForHost(ItemInstanceData data)
		{
			if (MyceliumNetwork.IsHost)
			{
				PreservedCameraInstanceDataForHost = data;
			}
		}

		public void SetPendingRewardForAllPlayers()
		{
			if (MyceliumNetwork.IsHost)
			{
				MyceliumNetwork.RPC(61812u, "RPC_SetPendingRewardForCameraReturn", (ReliableType)1, new object[2] { PlayerSettingCashReward, PlayerSettingMetaCoinReward });
			}
		}

		[CustomRPC]
		public void RPC_SetPendingRewardForCameraReturn(float cash, float mc)
		{
			PendingRewardForCameraReturn = (cash, mc);
		}

		public void Command_ResetDataforDay()
		{
			if (MyceliumNetwork.IsHost)
			{
				Logger.LogInfo((object)"KeepCameraAfterDeath v1.3.0 reset data for day");
				MyceliumNetwork.RPC(61812u, "RPC_ResetDataforDay", (ReliableType)1, Array.Empty<object>());
			}
		}

		[CustomRPC]
		public void RPC_ResetDataforDay()
		{
			Instance.ClearData();
		}

		public void ClearData()
		{
			Instance.ClearPreservedCameraInstanceDataForHost();
			Instance.ClearPendingRewardForCameraReturn();
		}

		public void ClearPreservedCameraInstanceDataForHost()
		{
			if (MyceliumNetwork.IsHost)
			{
				PreservedCameraInstanceDataForHost = null;
			}
		}

		public void ClearPendingRewardForCameraReturn()
		{
			PendingRewardForCameraReturn = null;
		}

		public bool IsFinalDayAndQuotaNotMet()
		{
			if (SurfaceNetworkHandler.RoomStats != null && SurfaceNetworkHandler.RoomStats.IsQuotaDay)
			{
				return !SurfaceNetworkHandler.RoomStats.CalculateIfReachedQuota();
			}
			return false;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "alexandria-p.KeepCameraAfterDeath";

		public const string PLUGIN_NAME = "KeepCameraAfterDeath";

		public const string PLUGIN_VERSION = "1.3.0";
	}
}
namespace KeepCameraAfterDeath.Patches
{
	public class PersistentObjectsHolderPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_FindPersistantObjects <0>__PersistentObjectsHolder_FindPersistantObjects;
		}

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__PersistentObjectsHolder_FindPersistantObjects;
			if (obj == null)
			{
				hook_FindPersistantObjects val = PersistentObjectsHolder_FindPersistantObjects;
				<>O.<0>__PersistentObjectsHolder_FindPersistantObjects = val;
				obj = (object)val;
			}
			PersistentObjectsHolder.FindPersistantObjects += (hook_FindPersistantObjects)obj;
		}

		private static void PersistentObjectsHolder_FindPersistantObjects(orig_FindPersistantObjects orig, PersistentObjectsHolder self)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			List<VideoCamera> list = FindVideoCamerasInSet(self.m_PersistentObjects);
			orig.Invoke(self);
			if (!MyceliumNetwork.IsHost)
			{
				return;
			}
			int count = self.m_PersistentObjects.Count;
			VideoCamera item2 = default(VideoCamera);
			for (int num = count - 1; num >= 0; num--)
			{
				PersistentObjectInfo item = self.m_PersistentObjects[num];
				ItemInstanceData instanceData = ((PersistentObjectInfo)(ref item)).InstanceData;
				Guid guid = instanceData.m_guid;
				if (CameraHandler.TryGetCamera(guid, ref item2) && !list.Contains(item2))
				{
					KeepCameraAfterDeath.Instance.SetPreservedCameraInstanceDataForHost(instanceData);
					if (self.m_PersistentObjectDic.ContainsKey(((PersistentObjectInfo)(ref item)).Pickup))
					{
						self.m_PersistentObjectDic.Remove(((PersistentObjectInfo)(ref item)).Pickup);
					}
					self.m_PersistentObjects.Remove(item);
					break;
				}
			}
		}

		private static List<VideoCamera> FindVideoCamerasInSet(List<PersistentObjectInfo> persistantObjects)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			List<VideoCamera> list = new List<VideoCamera>();
			VideoCamera item = default(VideoCamera);
			foreach (PersistentObjectInfo persistantObject in persistantObjects)
			{
				PersistentObjectInfo current = persistantObject;
				ItemInstanceData instanceData = ((PersistentObjectInfo)(ref current)).InstanceData;
				Guid guid = instanceData.m_guid;
				if (CameraHandler.TryGetCamera(guid, ref item))
				{
					list.Add(item);
				}
			}
			return list;
		}
	}
	public class PlayerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Update <0>__Player_Update;
		}

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__Player_Update;
			if (obj == null)
			{
				hook_Update val = Player_Update;
				<>O.<0>__Player_Update = val;
				obj = (object)val;
			}
			Player.Update += (hook_Update)obj;
		}

		private static void Player_Update(orig_Update orig, Player self)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Invalid comparison between Unknown and I4
			if (KeepCameraAfterDeath.Instance.PendingRewardForCameraReturn.HasValue && self.IsLocal && self.data.playerSetUpAndReady && SurfaceNetworkHandler.RoomStats != null && (int)TimeOfDayHandler.TimeOfDay == 10)
			{
				AddCashToRoom();
				AddMCToPlayers();
				KeepCameraAfterDeath.Instance.ClearPendingRewardForCameraReturn();
			}
			orig.Invoke(self);
			static void AddCashToRoom()
			{
				float item2 = KeepCameraAfterDeath.Instance.PendingRewardForCameraReturn.Value.cash;
				if (!(item2 <= 0f))
				{
					UserInterface.ShowMoneyNotification("Cash Received", $"${(int)item2}", (MoneyCellType)1);
					if (MyceliumNetwork.IsHost)
					{
						SurfaceNetworkHandler.RoomStats.AddMoney((int)item2);
					}
				}
			}
			static void AddMCToPlayers()
			{
				float item = KeepCameraAfterDeath.Instance.PendingRewardForCameraReturn.Value.mc;
				if (!(item <= 0f))
				{
					MetaProgressionHandler.AddMetaCoins((int)item);
				}
			}
		}
	}
	public class SurfaceNetworkHandlerPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_InitSurface <0>__SurfaceNetworkHandler_InitSurface;

			public static hook_NextDay <1>__SurfaceNetworkHandler_NextDay;
		}

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0030: 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_003b: Expected O, but got Unknown
			object obj = <>O.<0>__SurfaceNetworkHandler_InitSurface;
			if (obj == null)
			{
				hook_InitSurface val = SurfaceNetworkHandler_InitSurface;
				<>O.<0>__SurfaceNetworkHandler_InitSurface = val;
				obj = (object)val;
			}
			SurfaceNetworkHandler.InitSurface += (hook_InitSurface)obj;
			object obj2 = <>O.<1>__SurfaceNetworkHandler_NextDay;
			if (obj2 == null)
			{
				hook_NextDay val2 = SurfaceNetworkHandler_NextDay;
				<>O.<1>__SurfaceNetworkHandler_NextDay = val2;
				obj2 = (object)val2;
			}
			SurfaceNetworkHandler.NextDay += (hook_NextDay)obj2;
		}

		private static void SurfaceNetworkHandler_InitSurface(orig_InitSurface orig, SurfaceNetworkHandler self)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			if (SurfaceNetworkHandler.RoomStats == null)
			{
				KeepCameraAfterDeath.Instance.ClearData();
			}
			if (MyceliumNetwork.IsHost && (int)TimeOfDayHandler.TimeOfDay == 10)
			{
				if (KeepCameraAfterDeath.Instance.PreservedCameraInstanceDataForHost != null)
				{
					KeepCameraAfterDeath.Logger.LogInfo((object)"KeepCameraAfterDeath: Found backed-up camera footage");
					self.m_VideoCameraSpawner.SpawnMe(true);
				}
				else
				{
					KeepCameraAfterDeath.Logger.LogInfo((object)"KeepCameraAfterDeath: Could not find camera footage to restore");
					if (KeepCameraAfterDeath.Instance.PlayerSettingEnableRewardForCameraReturn)
					{
						KeepCameraAfterDeath.Instance.SetPendingRewardForAllPlayers();
					}
				}
			}
			orig.Invoke(self);
		}

		private static void SurfaceNetworkHandler_NextDay(orig_NextDay orig, SurfaceNetworkHandler self)
		{
			orig.Invoke(self);
			KeepCameraAfterDeath.Logger.LogInfo((object)"KeepCameraAfterDeath v1.3.0 Surface network handler patch NEXT DAY: reset data for day");
			KeepCameraAfterDeath.Instance.Command_ResetDataforDay();
		}
	}
	public class VideoCameraPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_ConfigItem <0>__VideoCamera_ConfigItem;
		}

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			object obj = <>O.<0>__VideoCamera_ConfigItem;
			if (obj == null)
			{
				hook_ConfigItem val = VideoCamera_ConfigItem;
				<>O.<0>__VideoCamera_ConfigItem = val;
				obj = (object)val;
			}
			VideoCamera.ConfigItem += (hook_ConfigItem)obj;
		}

		private static void VideoCamera_ConfigItem(orig_ConfigItem orig, VideoCamera self, ItemInstanceData data, PhotonView playerView)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			bool flag = (int)TimeOfDayHandler.TimeOfDay == 10;
			VideoInfoEntry val = default(VideoInfoEntry);
			bool flag2 = !data.TryGetEntry<VideoInfoEntry>(ref val) || val.videoID.id == Guid.Empty;
			bool flag3 = KeepCameraAfterDeath.Instance.PreservedCameraInstanceDataForHost != null;
			VideoInfoEntry val2 = default(VideoInfoEntry);
			if (MyceliumNetwork.IsHost && flag3 && flag && flag2 && KeepCameraAfterDeath.Instance.PreservedCameraInstanceDataForHost.TryGetEntry<VideoInfoEntry>(ref val2) && val2.videoID.id != Guid.Empty)
			{
				ManualLogSource logger = KeepCameraAfterDeath.Logger;
				Guid id = val2.videoID.id;
				logger.LogInfo((object)("KeepCameraAfterDeath: Restore camera footage: " + id));
				data.AddDataEntry((ItemDataEntry)(object)val2);
				KeepCameraAfterDeath.Instance.ClearPreservedCameraInstanceDataForHost();
			}
			orig.Invoke(self, data, playerView);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}

The result has been truncated due to the large size, download it to view the full contents!

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Threading.Tasks;
using CurvedUI;
using DefaultNamespace;
using DefaultNamespace.Artifacts;
using DefaultNamespace.ContentEvents;
using DefaultNamespace.ContentProviders;
using DefaultNamespace.Petter.TitleCard;
using DefaultNamespace._10._SCRIPTS;
using ExitGames.Client.Photon;
using LimitlessDev.RetroLookPro;
using MonoMod.Cil;
using MonoMod.RuntimeDetour.HookGen;
using On;
using On.CurvedUI;
using On.DefaultNamespace;
using On.DefaultNamespace.Artifacts;
using On.DefaultNamespace.ContentEvents;
using On.DefaultNamespace.ContentProviders;
using On.DefaultNamespace.Petter.TitleCard;
using On.DefaultNamespace._10._SCRIPTS;
using On.LimitlessDev.RetroLookPro;
using On.Photon.Chat.Demo;
using On.Photon.Chat.UtilityScripts;
using On.Photon.Realtime.Demo;
using On.UnityEditor.Localization.Samples;
using On.UnityEngine.Localization.Samples;
using On.UnityEngine.Localization.Settings;
using On.UnityEngine.UI.ProceduralImage;
using On._02Scripts.Charts.Computes;
using Photon.Chat;
using Photon.Chat.Demo;
using Photon.Chat.UtilityScripts;
using Photon.Pun;
using Photon.Realtime;
using Photon.Realtime.Demo;
using Steamworks;
using TMPro;
using Unity.Collections;
using Unity.Mathematics;
using UnityEditor.Localization.Samples;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.Localization;
using UnityEngine.Localization.Samples;
using UnityEngine.Localization.Settings;
using UnityEngine.Localization.Tables;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.UI;
using UnityEngine.UI.ProceduralImage;
using UnityEngine.UIElements;
using Zorro.Core;
using Zorro.Core.CLI;
using Zorro.Core.Serizalization;
using Zorro.Recorder;
using Zorro.Settings;
using Zorro.Settings.DebugUI;
using Zorro.UI;
using _02Scripts.Charts.Computes;

[assembly: AssemblyVersion("0.0.0.0")]
namespace On
{
	public static class ArtifactBigSlapPainting
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(ArtifactBigSlapPainting self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, ArtifactBigSlapPainting self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactBigSlapPainting self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactBigSlapPainting self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_RPCA_SpawnSlap(ArtifactBigSlapPainting self, BinaryDeserializer deserializer);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_RPCA_SpawnSlap(orig_RPCA_SpawnSlap orig, ArtifactBigSlapPainting self, BinaryDeserializer deserializer);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactBigSlapPainting self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactBigSlapPainting self);

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_RPCA_SpawnSlap RPCA_SpawnSlap
		{
			add
			{
				HookEndpointManager.Add<hook_RPCA_SpawnSlap>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_RPCA_SpawnSlap>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactBigSlapPainting
	{
		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactBigSlapPainting.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactBigSlapPainting.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactBigSlapPainting.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactBigSlapPainting.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator RPCA_SpawnSlap
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactBigSlapPainting.hook_RPCA_SpawnSlap>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactBigSlapPainting.hook_RPCA_SpawnSlap>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactBigSlapPainting.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactBigSlapPainting.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactBudget
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactBudget self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactBudget self);

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactBudget
	{
		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactBudget.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactBudget.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactGeneric
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactGeneric self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactGeneric self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactGeneric self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactGeneric self);

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactGeneric
	{
		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGeneric.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGeneric.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGeneric.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGeneric.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactGravityFlipperOff
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactGravityFlipperOff self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactGravityFlipperOff self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(ArtifactGravityFlipperOff self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, ArtifactGravityFlipperOff self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactGravityFlipperOff self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactGravityFlipperOff self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_<Update>b__3_0(ArtifactGravityFlipperOff self, CurseOfGravityFlip curse);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_<Update>b__3_0(orig_<Update>b__3_0 orig, ArtifactGravityFlipperOff self, CurseOfGravityFlip curse);

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_<Update>b__3_0 <Update>b__3_0
		{
			add
			{
				HookEndpointManager.Add<hook_<Update>b__3_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_<Update>b__3_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactGravityFlipperOff
	{
		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOff.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOff.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOff.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOff.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOff.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOff.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator <Update>b__3_0
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOff.hook_<Update>b__3_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOff.hook_<Update>b__3_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactGravityFlipperOn
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactGravityFlipperOn self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactGravityFlipperOn self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(ArtifactGravityFlipperOn self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, ArtifactGravityFlipperOn self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnFinishSpawning(ArtifactGravityFlipperOn self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnFinishSpawning(orig_OnFinishSpawning orig, ArtifactGravityFlipperOn self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactGravityFlipperOn self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactGravityFlipperOn self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_<Update>b__6_0(ArtifactGravityFlipperOn self, CurseOfGravityFlip curse);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_<Update>b__6_0(orig_<Update>b__6_0 orig, ArtifactGravityFlipperOn self, CurseOfGravityFlip curse);

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_OnFinishSpawning OnFinishSpawning
		{
			add
			{
				HookEndpointManager.Add<hook_OnFinishSpawning>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_OnFinishSpawning>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_<Update>b__6_0 <Update>b__6_0
		{
			add
			{
				HookEndpointManager.Add<hook_<Update>b__6_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_<Update>b__6_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactGravityFlipperOn
	{
		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator OnFinishSpawning
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_OnFinishSpawning>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_OnFinishSpawning>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator <Update>b__6_0
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_<Update>b__6_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_<Update>b__6_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactRadio
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(ArtifactRadio self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, ArtifactRadio self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactRadio self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactRadio self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactRadio self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactRadio self);

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactRadio
	{
		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactRadio.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactRadio.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactRadio.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactRadio.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactRadio.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactRadio.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactSpawner
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Start(ArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, ArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(ArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, ArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactSpawner self);

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactSpawner
	{
		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactSpawner.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactSpawner.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactSpawner.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactSpawner.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactSpawner.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactSpawner.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactWithCurse
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactWithCurse self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactWithCurse self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnItemEquipped(ArtifactWithCurse self, Player player);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnItemEquipped(orig_OnItemEquipped orig, ArtifactWithCurse self, Player player);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnDestroy(ArtifactWithCurse self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnDestroy(orig_OnDestroy orig, ArtifactWithCurse self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactWithCurse self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactWithCurse self);

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_OnItemEquipped OnItemEquipped
		{
			add
			{
				HookEndpointManager.Add<hook_OnItemEquipped>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_OnItemEquipped>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_OnDestroy OnDestroy
		{
			add
			{
				HookEndpointManager.Add<hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactWithCurse
	{
		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactWithCurse.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactWithCurse.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator OnItemEquipped
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactWithCurse.hook_OnItemEquipped>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactWithCurse.hook_OnItemEquipped>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator OnDestroy
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactWithCurse.hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactWithCurse.hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactWithCurse.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactWithCurse.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class ArtifactZombieBook
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(ArtifactZombieBook self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, ArtifactZombieBook self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(ArtifactZombieBook self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactZombieBook self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(ArtifactZombieBook self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, ArtifactZombieBook self);

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class ArtifactZombieBook
	{
		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactZombieBook.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactZombieBook.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactZombieBook.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactZombieBook.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.ArtifactZombieBook.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.ArtifactZombieBook.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class CurseDataBase
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Start(CurseDataBase self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, CurseDataBase self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(CurseDataBase self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, CurseDataBase self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(CurseDataBase self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, CurseDataBase self);

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class CurseDataBase
	{
		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.CurseDataBase.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CurseDataBase.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.CurseDataBase.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CurseDataBase.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.CurseDataBase.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CurseDataBase.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class CursedPlayerBoss
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SpawnCurse(CursedPlayerBoss self, ItemInstanceBehaviour artifact, GameObject cursePrefab);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SpawnCurse(orig_SpawnCurse orig, CursedPlayerBoss self, ItemInstanceBehaviour artifact, GameObject cursePrefab);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Awake(CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Awake(orig_Awake orig, CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Start(CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(CursedPlayerBoss self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, CursedPlayerBoss self);

		public static event hook_SpawnCurse SpawnCurse
		{
			add
			{
				HookEndpointManager.Add<hook_SpawnCurse>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SpawnCurse>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Awake Awake
		{
			add
			{
				HookEndpointManager.Add<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class CursedPlayerBoss
	{
		public static event Manipulator SpawnCurse
		{
			add
			{
				HookEndpointManager.Modify<On.CursedPlayerBoss.hook_SpawnCurse>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_SpawnCurse>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Awake
		{
			add
			{
				HookEndpointManager.Modify<On.CursedPlayerBoss.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.CursedPlayerBoss.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.CursedPlayerBoss.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.CursedPlayerBoss.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class PersistantRadio
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(PersistantRadio self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Update(orig_Update orig, PersistantRadio self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ConfigItem(PersistantRadio self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ConfigItem(orig_ConfigItem orig, PersistantRadio self, ItemInstanceData data, PhotonView playerView);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(PersistantRadio self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, PersistantRadio self);

		public static event hook_Update Update
		{
			add
			{
				HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ConfigItem ConfigItem
		{
			add
			{
				HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class PersistantRadio
	{
		public static event Manipulator Update
		{
			add
			{
				HookEndpointManager.Modify<On.PersistantRadio.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.PersistantRadio.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ConfigItem
		{
			add
			{
				HookEndpointManager.Modify<On.PersistantRadio.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.PersistantRadio.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.PersistantRadio.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.PersistantRadio.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class RoundArtifactSpawner
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Awake(RoundArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Awake(orig_Awake orig, RoundArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Start(RoundArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Start(orig_Start orig, RoundArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SpawnRound(RoundArtifactSpawner self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SpawnRound(orig_SpawnRound orig, RoundArtifactSpawner self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_PrintArtifactsPerDay(RoundArtifactSpawner self, int day, int times);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_PrintArtifactsPerDay(orig_PrintArtifactsPerDay orig, RoundArtifactSpawner self, int day, int times);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<Item> orig_GetArtifactsToSpawn(RoundArtifactSpawner self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<Item> hook_GetArtifactsToSpawn(orig_GetArtifactsToSpawn orig, RoundArtifactSpawner self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_CreateArtifactSpawners(RoundArtifactSpawner self, List<Item> artifacts);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_CreateArtifactSpawners(orig_CreateArtifactSpawners orig, RoundArtifactSpawner self, List<Item> artifacts);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Vector3 orig_GetRandPointWithWeight();

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Vector3 hook_GetRandPointWithWeight(orig_GetRandPointWithWeight orig);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item orig_GetArtifact(ref int budget, Item[] possibleSpawns, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item hook_GetArtifact(orig_GetArtifact orig, ref int budget, Item[] possibleSpawns, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item orig_GetRandomArtifactByRarity(Item[] possibleSpawns);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item hook_GetRandomArtifactByRarity(orig_GetRandomArtifactByRarity orig, Item[] possibleSpawns);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(RoundArtifactSpawner self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, RoundArtifactSpawner self);

		public static class ArtifactWithWeight
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(ArtifactWithWeight self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, ArtifactWithWeight self);

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
			}
		}

		public static event hook_Awake Awake
		{
			add
			{
				HookEndpointManager.Add<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_SpawnRound SpawnRound
		{
			add
			{
				HookEndpointManager.Add<hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_PrintArtifactsPerDay PrintArtifactsPerDay
		{
			add
			{
				HookEndpointManager.Add<hook_PrintArtifactsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_PrintArtifactsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetArtifactsToSpawn GetArtifactsToSpawn
		{
			add
			{
				HookEndpointManager.Add<hook_GetArtifactsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetArtifactsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_CreateArtifactSpawners CreateArtifactSpawners
		{
			add
			{
				HookEndpointManager.Add<hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetRandPointWithWeight GetRandPointWithWeight
		{
			add
			{
				HookEndpointManager.Add<hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetArtifact GetArtifact
		{
			add
			{
				HookEndpointManager.Add<hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetRandomArtifactByRarity GetRandomArtifactByRarity
		{
			add
			{
				HookEndpointManager.Add<hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class RoundArtifactSpawner
	{
		public static class ArtifactWithWeight
		{
			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.RoundArtifactSpawner.ArtifactWithWeight.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.RoundArtifactSpawner.ArtifactWithWeight.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
			}
		}

		public static event Manipulator Awake
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator SpawnRound
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator PrintArtifactsPerDay
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_PrintArtifactsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_PrintArtifactsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetArtifactsToSpawn
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_GetArtifactsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_GetArtifactsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator CreateArtifactSpawners
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetRandPointWithWeight
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetArtifact
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetRandomArtifactByRarity
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class RoundSpawnerTools
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Awake(RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Awake(orig_Awake orig, RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Populate(RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Populate(orig_Populate orig, RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator orig_Start(RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate IEnumerator hook_Start(orig_Start orig, RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SpawnRound(RoundSpawnerTools self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SpawnRound(orig_SpawnRound orig, RoundSpawnerTools self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_PrintToolsPerDay(RoundSpawnerTools self, int day, int times);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_PrintToolsPerDay(orig_PrintToolsPerDay orig, RoundSpawnerTools self, int day, int times);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<Item> orig_GetToolsToSpawn(RoundSpawnerTools self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate List<Item> hook_GetToolsToSpawn(orig_GetToolsToSpawn orig, RoundSpawnerTools self, int budget, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_CreateArtifactSpawners(RoundSpawnerTools self, List<Item> artifacts);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_CreateArtifactSpawners(orig_CreateArtifactSpawners orig, RoundSpawnerTools self, List<Item> artifacts);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Vector3 orig_GetRandPointWithWeight();

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Vector3 hook_GetRandPointWithWeight(orig_GetRandPointWithWeight orig);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item orig_GetArtifact(ref int budget, List<Item> possibleSpawns, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item hook_GetArtifact(orig_GetArtifact orig, ref int budget, List<Item> possibleSpawns, float rarestPurchase);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item orig_GetRandomArtifactByRarity(Item[] possibleSpawns);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate Item hook_GetRandomArtifactByRarity(orig_GetRandomArtifactByRarity orig, Item[] possibleSpawns);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(RoundSpawnerTools self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, RoundSpawnerTools self);

		public static class ToolWithWeight
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(ToolWithWeight self);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, ToolWithWeight self);

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
			}
		}

		public static event hook_Awake Awake
		{
			add
			{
				HookEndpointManager.Add<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Populate Populate
		{
			add
			{
				HookEndpointManager.Add<hook_Populate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Populate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_SpawnRound SpawnRound
		{
			add
			{
				HookEndpointManager.Add<hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_PrintToolsPerDay PrintToolsPerDay
		{
			add
			{
				HookEndpointManager.Add<hook_PrintToolsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_PrintToolsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetToolsToSpawn GetToolsToSpawn
		{
			add
			{
				HookEndpointManager.Add<hook_GetToolsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetToolsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_CreateArtifactSpawners CreateArtifactSpawners
		{
			add
			{
				HookEndpointManager.Add<hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetRandPointWithWeight GetRandPointWithWeight
		{
			add
			{
				HookEndpointManager.Add<hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetArtifact GetArtifact
		{
			add
			{
				HookEndpointManager.Add<hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_GetRandomArtifactByRarity GetRandomArtifactByRarity
		{
			add
			{
				HookEndpointManager.Add<hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class RoundSpawnerTools
	{
		public static class ToolWithWeight
		{
			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.RoundSpawnerTools.ToolWithWeight.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.RoundSpawnerTools.ToolWithWeight.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
			}
		}

		public static event Manipulator Awake
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Populate
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_Populate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_Populate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator SpawnRound
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator PrintToolsPerDay
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_PrintToolsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_PrintToolsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetToolsToSpawn
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_GetToolsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_GetToolsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator CreateArtifactSpawners
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetRandPointWithWeight
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetArtifact
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator GetRandomArtifactByRarity
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.RoundSpawnerTools.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class AspectRatioUISetter
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SetDefault(AspectRatioUISetter self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SetDefault(orig_SetDefault orig, AspectRatioUISetter self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SetAspectPosition(AspectRatioUISetter self, AspectRatio aspectRatio);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SetAspectPosition(orig_SetAspectPosition orig, AspectRatioUISetter self, AspectRatio aspectRatio);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_LoadAspectPosition(AspectRatioUISetter self, AspectRatio aspectRatio);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_LoadAspectPosition(orig_LoadAspectPosition orig, AspectRatioUISetter self, AspectRatio aspectRatio);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(AspectRatioUISetter self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, AspectRatioUISetter self);

		public static class AspectPosition
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(AspectPosition self, RectTransform rectTransform);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, AspectPosition self, RectTransform rectTransform);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_Load(AspectPosition self, RectTransform rectTransform);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_Load(orig_Load orig, AspectPosition self, RectTransform rectTransform);

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
			}

			public static event hook_Load Load
			{
				add
				{
					HookEndpointManager.Add<hook_Load>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_Load>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
			}
		}

		public static class SavedAspectPosition
		{
			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void orig_ctor(SavedAspectPosition self, AspectRatio aspectRatio, AspectPosition aspectPosition);

			[EditorBrowsable(EditorBrowsableState.Never)]
			public delegate void hook_ctor(orig_ctor orig, SavedAspectPosition self, AspectRatio aspectRatio, AspectPosition aspectPosition);

			public static event hook_ctor ctor
			{
				add
				{
					HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
				remove
				{
					HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
				}
			}
		}

		public static event hook_SetDefault SetDefault
		{
			add
			{
				HookEndpointManager.Add<hook_SetDefault>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SetDefault>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_SetAspectPosition SetAspectPosition
		{
			add
			{
				HookEndpointManager.Add<hook_SetAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SetAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_LoadAspectPosition LoadAspectPosition
		{
			add
			{
				HookEndpointManager.Add<hook_LoadAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_LoadAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class AspectRatioUISetter
	{
		public static class AspectPosition
		{
			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.AspectRatioUISetter.AspectPosition.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.AspectRatioUISetter.AspectPosition.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
			}

			public static event Manipulator Load
			{
				add
				{
					HookEndpointManager.Modify<On.AspectRatioUISetter.AspectPosition.hook_Load>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.AspectRatioUISetter.AspectPosition.hook_Load>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
			}
		}

		public static class SavedAspectPosition
		{
			public static event Manipulator ctor
			{
				add
				{
					HookEndpointManager.Modify<On.AspectRatioUISetter.SavedAspectPosition.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
				remove
				{
					HookEndpointManager.Unmodify<On.AspectRatioUISetter.SavedAspectPosition.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
				}
			}
		}

		public static event Manipulator SetDefault
		{
			add
			{
				HookEndpointManager.Modify<On.AspectRatioUISetter.hook_SetDefault>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AspectRatioUISetter.hook_SetDefault>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator SetAspectPosition
		{
			add
			{
				HookEndpointManager.Modify<On.AspectRatioUISetter.hook_SetAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AspectRatioUISetter.hook_SetAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator LoadAspectPosition
		{
			add
			{
				HookEndpointManager.Modify<On.AspectRatioUISetter.hook_LoadAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AspectRatioUISetter.hook_LoadAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.AspectRatioUISetter.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AspectRatioUISetter.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class AudioLoop
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Start(AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnEnable(AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnEnable(orig_OnEnable orig, AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_OnDisable(AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_OnDisable(orig_OnDisable orig, AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_SetTime(AudioLoop self, float timeInSong);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_SetTime(orig_SetTime orig, AudioLoop self, float timeInSong);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_TryGetOverrideTime(AudioLoop self, out float f);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_TryGetOverrideTime(orig_TryGetOverrideTime orig, AudioLoop self, out float f);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool orig_CheckBoost(AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate bool hook_CheckBoost(orig_CheckBoost orig, AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(AudioLoop self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, AudioLoop self);

		public static event hook_Start Start
		{
			add
			{
				HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_OnEnable OnEnable
		{
			add
			{
				HookEndpointManager.Add<hook_OnEnable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_OnEnable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_OnDisable OnDisable
		{
			add
			{
				HookEndpointManager.Add<hook_OnDisable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_OnDisable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_SetTime SetTime
		{
			add
			{
				HookEndpointManager.Add<hook_SetTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_SetTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_TryGetOverrideTime TryGetOverrideTime
		{
			add
			{
				HookEndpointManager.Add<hook_TryGetOverrideTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_TryGetOverrideTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_CheckBoost CheckBoost
		{
			add
			{
				HookEndpointManager.Add<hook_CheckBoost>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_CheckBoost>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class AudioLoop
	{
		public static event Manipulator Start
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator OnEnable
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_OnEnable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_OnEnable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator OnDisable
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_OnDisable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_OnDisable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator SetTime
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_SetTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_SetTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator TryGetOverrideTime
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_TryGetOverrideTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_TryGetOverrideTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator CheckBoost
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_CheckBoost>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_CheckBoost>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoop.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoop.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class AudioLoopHandler
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_RegisterAudioLoop(AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_RegisterAudioLoop(orig_RegisterAudioLoop orig, AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_UnregisterAudioLoop(AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_UnregisterAudioLoop(orig_UnregisterAudioLoop orig, AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_LateUpdate(AudioLoopHandler self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_LateUpdate(orig_LateUpdate orig, AudioLoopHandler self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_RemoveSource(AudioLoopHandler self, AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_RemoveSource(orig_RemoveSource orig, AudioLoopHandler self, AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_AssignSource(AudioLoopHandler self, AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_AssignSource(orig_AssignSource orig, AudioLoopHandler self, AudioLoop audioLoop);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_ctor(AudioLoopHandler self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_ctor(orig_ctor orig, AudioLoopHandler self);

		public static event hook_RegisterAudioLoop RegisterAudioLoop
		{
			add
			{
				HookEndpointManager.Add<hook_RegisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_RegisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_UnregisterAudioLoop UnregisterAudioLoop
		{
			add
			{
				HookEndpointManager.Add<hook_UnregisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_UnregisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_LateUpdate LateUpdate
		{
			add
			{
				HookEndpointManager.Add<hook_LateUpdate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_LateUpdate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_RemoveSource RemoveSource
		{
			add
			{
				HookEndpointManager.Add<hook_RemoveSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_RemoveSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_AssignSource AssignSource
		{
			add
			{
				HookEndpointManager.Add<hook_AssignSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_AssignSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}

		public static event hook_ctor ctor
		{
			add
			{
				HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class AudioLoopHandler
	{
		public static event Manipulator RegisterAudioLoop
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoopHandler.hook_RegisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_RegisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator UnregisterAudioLoop
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoopHandler.hook_UnregisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_UnregisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator LateUpdate
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoopHandler.hook_LateUpdate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_LateUpdate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator RemoveSource
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoopHandler.hook_RemoveSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_RemoveSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator AssignSource
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoopHandler.hook_AssignSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_AssignSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}

		public static event Manipulator ctor
		{
			add
			{
				HookEndpointManager.Modify<On.AudioLoopHandler.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class AudioObstructability
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate float orig_GetObstructionValue(Vector3 position, float obstructability, out float rangeFactor);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate float hook_GetObstructionValue(orig_GetObstructionValue orig, Vector3 position, float obstructability, out float rangeFactor);

		public static event hook_GetObstructionValue GetObstructionValue
		{
			add
			{
				HookEndpointManager.Add<hook_GetObstructionValue>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
			remove
			{
				HookEndpointManager.Remove<hook_GetObstructionValue>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value);
			}
		}
	}
}
namespace IL
{
	public static class AudioObstructability
	{
		public static event Manipulator GetObstructionValue
		{
			add
			{
				HookEndpointManager.Modify<On.AudioObstructability.hook_GetObstructionValue>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
			remove
			{
				HookEndpointManager.Unmodify<On.AudioObstructability.hook_GetObstructionValue>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value);
			}
		}
	}
}
namespace On
{
	public static class AudioToggler
	{
		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Start(AudioToggler self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook_Start(orig_Start orig, AudioToggler self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void orig_Update(AudioToggler self);

		[EditorBrowsable(EditorBrowsableState.Never)]
		public delegate void hook

using System; using System.Collections.Generic; using System.Diagnostics; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using BepInEx; using BepInEx.Logging; using KeepCameraAfterDeath.Patches; using Microsoft.CodeAnalysis; using MonoMod.RuntimeDetour.HookGen; using MyceliumNetworking; using On; using Photon.Pun; using Unity.Mathematics; using UnityEngine; using Zorro.Settings; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: IgnoresAccessChecksTo("Assembly-CSharp")] [assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")] [assembly: AssemblyCompany("alexandria-p.KeepCameraAfterDeath")] [assembly: AssemblyConfiguration("Release")] [assembly: AssemblyFileVersion("1.3.0.0")] [assembly: AssemblyInformationalVersion("1.3.0+809bc897adf7dc5fd4cf17919321e62fc10a4cc0")] [assembly: AssemblyProduct("KeepCameraAfterDeath")] [assembly: AssemblyTitle("alexandria-p.KeepCameraAfterDeath")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("1.3.0.0")] [module: UnverifiableCode] [module: RefSafetyRules(11)] 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; } } [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)] internal sealed class RefSafetyRulesAttribute : Attribute { public readonly int Version; public RefSafetyRulesAttribute(int P_0) { Version = P_0; } } } namespace KeepCameraAfterDeath { [ContentWarningPlugin("alexandria-p.KeepCameraAfterDeath", "1.3.0", false)] [BepInPlugin("alexandria-p.KeepCameraAfterDeath", "KeepCameraAfterDeath", "1.3.0")] public class FixR2Modman : BaseUnityPlugin { internal static ManualLogSource Logger { get; private set; } private void Awake() { //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0015: Unknown result type (might be due to invalid IL or missing references) //IL_001e: Expected O, but got Unknown Logger = ((BaseUnityPlugin)this).Logger; GameObject val = new GameObject("KeepCameraAfterDeathPluginR2ModMan") { hideFlags = (HideFlags)61 }; val.AddComponent<KeepCameraAfterDeath>(); KeepCameraAfterDeath.Instance.SetLogger(((BaseUnityPlugin)this).Logger); Object.DontDestroyOnLoad((Object)(object)val); } } public class KeepCameraAfterDeath : MonoBehaviour { [ContentWarningSetting] public class EnableRewardForCameraReturnSetting : BoolSetting, IExposedSetting { public SettingCategory GetSettingCategory() { return (SettingCategory)4; } public override void ApplyValue() { Instance.SetPlayerSettingEnableRewardForCameraReturn(((BoolSetting)this).Value); } public string GetDisplayName() { return "KeepCameraAfterDeath: Turn on incentives for bringing the camera back to the surface (uses the host's game settings)"; } protected override bool GetDefaultValue() { return true; } } [ContentWarningSetting] public class SetMetaCoinRewardForCameraReturnSetting : FloatSetting, IExposedSetting { public SettingCategory GetSettingCategory() { return (SettingCategory)4; } public override void ApplyValue() { Instance.SetPlayerSettingMetaCoinReward(((FloatSetting)this).Value); } public string GetDisplayName() { return "KeepCameraAfterDeath: Meta Coin (MC) reward for camera return (uses the host's game settings)"; } protected override float GetDefaultValue() { return 10f; } protected override float2 GetMinMaxValue() { //IL_000a: Unknown result type (might be due to invalid IL or missing references) return new float2(0f, 100f); } } [ContentWarningSetting] public class SetCashRewardForCameraReturnSetting : FloatSetting, IExposedSetting { public SettingCategory GetSettingCategory() { return (SettingCategory)4; } public override void ApplyValue() { Instance.SetPlayerSettingCashReward(((FloatSetting)this).Value); } public string GetDisplayName() { return "KeepCameraAfterDeath: Cash reward for camera return (uses the host's game settings)"; } protected override float GetDefaultValue() { return 0f; } protected override float2 GetMinMaxValue() { //IL_000a: Unknown result type (might be due to invalid IL or missing references) return new float2(0f, 1000f); } } private const uint myceliumNetworkModId = 61812u; public static KeepCameraAfterDeath Instance { get; private set; } internal static ManualLogSource Logger { get; private set; } public bool PlayerSettingEnableRewardForCameraReturn { get; private set; } public float PlayerSettingMetaCoinReward { get; private set; } public float PlayerSettingCashReward { get; private set; } public ItemInstanceData? PreservedCameraInstanceDataForHost { get; private set; } public (float cash, float mc)? PendingRewardForCameraReturn { get; private set; } public void SetLogger(ManualLogSource logger) { Logger = logger; Logger.LogInfo((object)"KeepCameraAfterDeath v1.3.0 has loaded!"); } private void Awake() { Instance = this; HookAll(); } private void Start() { MyceliumNetwork.RegisterNetworkObject((object)Instance, 61812u, 0); } private void OnDestroy() { MyceliumNetwork.DeregisterNetworkObject((object)Instance, 61812u, 0); } internal static void HookAll() { SurfaceNetworkHandlerPatch.Init(); VideoCameraPatch.Init(); PersistentObjectsHolderPatch.Init(); PlayerPatch.Init(); } internal static void UnhookAll() { HookEndpointManager.RemoveAllOwnedBy((object)Assembly.GetExecutingAssembly()); } public void SetPlayerSettingEnableRewardForCameraReturn(bool rewardEnabled) { PlayerSettingEnableRewardForCameraReturn = rewardEnabled; } public void SetPlayerSettingMetaCoinReward(float mcReward) { PlayerSettingMetaCoinReward = mcReward; } public void SetPlayerSettingCashReward(float cashReward) { PlayerSettingCashReward = cashReward; } public void SetPreservedCameraInstanceDataForHost(ItemInstanceData data) { if (MyceliumNetwork.IsHost) { PreservedCameraInstanceDataForHost = data; } } public void SetPendingRewardForAllPlayers() { if (MyceliumNetwork.IsHost) { MyceliumNetwork.RPC(61812u, "RPC_SetPendingRewardForCameraReturn", (ReliableType)1, new object[2] { PlayerSettingCashReward, PlayerSettingMetaCoinReward }); } } [CustomRPC] public void RPC_SetPendingRewardForCameraReturn(float cash, float mc) { PendingRewardForCameraReturn = (cash, mc); } public void Command_ResetDataforDay() { if (MyceliumNetwork.IsHost) { Logger.LogInfo((object)"KeepCameraAfterDeath v1.3.0 reset data for day"); MyceliumNetwork.RPC(61812u, "RPC_ResetDataforDay", (ReliableType)1, Array.Empty<object>()); } } [CustomRPC] public void RPC_ResetDataforDay() { Instance.ClearData(); } public void ClearData() { Instance.ClearPreservedCameraInstanceDataForHost(); Instance.ClearPendingRewardForCameraReturn(); } public void ClearPreservedCameraInstanceDataForHost() { if (MyceliumNetwork.IsHost) { PreservedCameraInstanceDataForHost = null; } } public void ClearPendingRewardForCameraReturn() { PendingRewardForCameraReturn = null; } public bool IsFinalDayAndQuotaNotMet() { if (SurfaceNetworkHandler.RoomStats != null && SurfaceNetworkHandler.RoomStats.IsQuotaDay) { return !SurfaceNetworkHandler.RoomStats.CalculateIfReachedQuota(); } return false; } } public static class MyPluginInfo { public const string PLUGIN_GUID = "alexandria-p.KeepCameraAfterDeath"; public const string PLUGIN_NAME = "KeepCameraAfterDeath"; public const string PLUGIN_VERSION = "1.3.0"; } } namespace KeepCameraAfterDeath.Patches { public class PersistentObjectsHolderPatch { [CompilerGenerated] private static class <>O { public static hook_FindPersistantObjects <0>__PersistentObjectsHolder_FindPersistantObjects; } internal static void Init() { //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0015: Unknown result type (might be due to invalid IL or missing references) //IL_001b: Expected O, but got Unknown object obj = <>O.<0>__PersistentObjectsHolder_FindPersistantObjects; if (obj == null) { hook_FindPersistantObjects val = PersistentObjectsHolder_FindPersistantObjects; <>O.<0>__PersistentObjectsHolder_FindPersistantObjects = val; obj = (object)val; } PersistentObjectsHolder.FindPersistantObjects += (hook_FindPersistantObjects)obj; } private static void PersistentObjectsHolder_FindPersistantObjects(orig_FindPersistantObjects orig, PersistentObjectsHolder self) { //IL_0034: Unknown result type (might be due to invalid IL or missing references) //IL_0039: Unknown result type (might be due to invalid IL or missing references) //IL_009a: Unknown result type (might be due to invalid IL or missing references) List<VideoCamera> list = FindVideoCamerasInSet(self.m_PersistentObjects); orig.Invoke(self); if (!MyceliumNetwork.IsHost) { return; } int count = self.m_PersistentObjects.Count; VideoCamera item2 = default(VideoCamera); for (int num = count - 1; num >= 0; num--) { PersistentObjectInfo item = self.m_PersistentObjects[num]; ItemInstanceData instanceData = ((PersistentObjectInfo)(ref item)).InstanceData; Guid guid = instanceData.m_guid; if (CameraHandler.TryGetCamera(guid, ref item2) && !list.Contains(item2)) { KeepCameraAfterDeath.Instance.SetPreservedCameraInstanceDataForHost(instanceData); if (self.m_PersistentObjectDic.ContainsKey(((PersistentObjectInfo)(ref item)).Pickup)) { self.m_PersistentObjectDic.Remove(((PersistentObjectInfo)(ref item)).Pickup); } self.m_PersistentObjects.Remove(item); break; } } } private static List<VideoCamera> FindVideoCamerasInSet(List<PersistentObjectInfo> persistantObjects) { //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_0016: Unknown result type (might be due to invalid IL or missing references) List<VideoCamera> list = new List<VideoCamera>(); VideoCamera item = default(VideoCamera); foreach (PersistentObjectInfo persistantObject in persistantObjects) { PersistentObjectInfo current = persistantObject; ItemInstanceData instanceData = ((PersistentObjectInfo)(ref current)).InstanceData; Guid guid = instanceData.m_guid; if (CameraHandler.TryGetCamera(guid, ref item)) { list.Add(item); } } return list; } } public class PlayerPatch { [CompilerGenerated] private static class <>O { public static hook_Update <0>__Player_Update; } internal static void Init() { //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0015: Unknown result type (might be due to invalid IL or missing references) //IL_001b: Expected O, but got Unknown object obj = <>O.<0>__Player_Update; if (obj == null) { hook_Update val = Player_Update; <>O.<0>__Player_Update = val; obj = (object)val; } Player.Update += (hook_Update)obj; } private static void Player_Update(orig_Update orig, Player self) { //IL_0030: Unknown result type (might be due to invalid IL or missing references) //IL_0037: Invalid comparison between Unknown and I4 if (KeepCameraAfterDeath.Instance.PendingRewardForCameraReturn.HasValue && self.IsLocal && self.data.playerSetUpAndReady && SurfaceNetworkHandler.RoomStats != null && (int)TimeOfDayHandler.TimeOfDay == 10) { AddCashToRoom(); AddMCToPlayers(); KeepCameraAfterDeath.Instance.ClearPendingRewardForCameraReturn(); } orig.Invoke(self); static void AddCashToRoom() { float item2 = KeepCameraAfterDeath.Instance.PendingRewardForCameraReturn.Value.cash; if (!(item2 <= 0f)) { UserInterface.ShowMoneyNotification("Cash Received", $"${(int)item2}", (MoneyCellType)1); if (MyceliumNetwork.IsHost) { SurfaceNetworkHandler.RoomStats.AddMoney((int)item2); } } } static void AddMCToPlayers() { float item = KeepCameraAfterDeath.Instance.PendingRewardForCameraReturn.Value.mc; if (!(item <= 0f)) { MetaProgressionHandler.AddMetaCoins((int)item); } } } } public class SurfaceNetworkHandlerPatch { [CompilerGenerated] private static class <>O { public static hook_InitSurface <0>__SurfaceNetworkHandler_InitSurface; public static hook_NextDay <1>__SurfaceNetworkHandler_NextDay; } internal static void Init() { //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0015: Unknown result type (might be due to invalid IL or missing references) //IL_001b: Expected O, but got Unknown //IL_0030: 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_003b: Expected O, but got Unknown object obj = <>O.<0>__SurfaceNetworkHandler_InitSurface; if (obj == null) { hook_InitSurface val = SurfaceNetworkHandler_InitSurface; <>O.<0>__SurfaceNetworkHandler_InitSurface = val; obj = (object)val; } SurfaceNetworkHandler.InitSurface += (hook_InitSurface)obj; object obj2 = <>O.<1>__SurfaceNetworkHandler_NextDay; if (obj2 == null) { hook_NextDay val2 = SurfaceNetworkHandler_NextDay; <>O.<1>__SurfaceNetworkHandler_NextDay = val2; obj2 = (object)val2; } SurfaceNetworkHandler.NextDay += (hook_NextDay)obj2; } private static void SurfaceNetworkHandler_InitSurface(orig_InitSurface orig, SurfaceNetworkHandler self) { //IL_0018: Unknown result type (might be due to invalid IL or missing references) //IL_001f: Invalid comparison between Unknown and I4 if (SurfaceNetworkHandler.RoomStats == null) { KeepCameraAfterDeath.Instance.ClearData(); } if (MyceliumNetwork.IsHost && (int)TimeOfDayHandler.TimeOfDay == 10) { if (KeepCameraAfterDeath.Instance.PreservedCameraInstanceDataForHost != null) { KeepCameraAfterDeath.Logger.LogInfo((object)"KeepCameraAfterDeath: Found backed-up camera footage"); self.m_VideoCameraSpawner.SpawnMe(true); } else { KeepCameraAfterDeath.Logger.LogInfo((object)"KeepCameraAfterDeath: Could not find camera footage to restore"); if (KeepCameraAfterDeath.Instance.PlayerSettingEnableRewardForCameraReturn) { KeepCameraAfterDeath.Instance.SetPendingRewardForAllPlayers(); } } } orig.Invoke(self); } private static void SurfaceNetworkHandler_NextDay(orig_NextDay orig, SurfaceNetworkHandler self) { orig.Invoke(self); KeepCameraAfterDeath.Logger.LogInfo((object)"KeepCameraAfterDeath v1.3.0 Surface network handler patch NEXT DAY: reset data for day"); KeepCameraAfterDeath.Instance.Command_ResetDataforDay(); } } public class VideoCameraPatch { [CompilerGenerated] private static class <>O { public static hook_ConfigItem <0>__VideoCamera_ConfigItem; } internal static void Init() { //IL_0010: Unknown result type (might be due to invalid IL or missing references) //IL_0015: Unknown result type (might be due to invalid IL or missing references) //IL_001b: Expected O, but got Unknown object obj = <>O.<0>__VideoCamera_ConfigItem; if (obj == null) { hook_ConfigItem val = VideoCamera_ConfigItem; <>O.<0>__VideoCamera_ConfigItem = val; obj = (object)val; } VideoCamera.ConfigItem += (hook_ConfigItem)obj; } private static void VideoCamera_ConfigItem(orig_ConfigItem orig, VideoCamera self, ItemInstanceData data, PhotonView playerView) { //IL_0000: Unknown result type (might be due to invalid IL or missing references) //IL_0007: Invalid comparison between Unknown and I4 bool flag = (int)TimeOfDayHandler.TimeOfDay == 10; VideoInfoEntry val = default(VideoInfoEntry); bool flag2 = !data.TryGetEntry<VideoInfoEntry>(ref val) || val.videoID.id == Guid.Empty; bool flag3 = KeepCameraAfterDeath.Instance.PreservedCameraInstanceDataForHost != null; VideoInfoEntry val2 = default(VideoInfoEntry); if (MyceliumNetwork.IsHost && flag3 && flag && flag2 && KeepCameraAfterDeath.Instance.PreservedCameraInstanceDataForHost.TryGetEntry<VideoInfoEntry>(ref val2) && val2.videoID.id != Guid.Empty) { ManualLogSource logger = KeepCameraAfterDeath.Logger; Guid id = val2.videoID.id; logger.LogInfo((object)("KeepCameraAfterDeath: Restore camera footage: " + id)); data.AddDataEntry((ItemDataEntry)(object)val2); KeepCameraAfterDeath.Instance.ClearPreservedCameraInstanceDataForHost(); } orig.Invoke(self, data, playerView); } } } namespace System.Runtime.CompilerServices { [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] internal sealed class IgnoresAccessChecksToAttribute : Attribute { public IgnoresAccessChecksToAttribute(string assemblyName) { } } }

using System; using System.Collections; using System.Collections.Generic; using System.ComponentModel; using System.IO; using System.Reflection; using System.Runtime.InteropServices; using System.Runtime.Serialization; using System.Threading.Tasks; using CurvedUI; using DefaultNamespace; using DefaultNamespace.Artifacts; using DefaultNamespace.ContentEvents; using DefaultNamespace.ContentProviders; using DefaultNamespace.Petter.TitleCard; using DefaultNamespace._10._SCRIPTS; using ExitGames.Client.Photon; using LimitlessDev.RetroLookPro; using MonoMod.Cil; using MonoMod.RuntimeDetour.HookGen; using On; using On.CurvedUI; using On.DefaultNamespace; using On.DefaultNamespace.Artifacts; using On.DefaultNamespace.ContentEvents; using On.DefaultNamespace.ContentProviders; using On.DefaultNamespace.Petter.TitleCard; using On.DefaultNamespace._10._SCRIPTS; using On.LimitlessDev.RetroLookPro; using On.Photon.Chat.Demo; using On.Photon.Chat.UtilityScripts; using On.Photon.Realtime.Demo; using On.UnityEditor.Localization.Samples; using On.UnityEngine.Localization.Samples; using On.UnityEngine.Localization.Settings; using On.UnityEngine.UI.ProceduralImage; using On._02Scripts.Charts.Computes; using Photon.Chat; using Photon.Chat.Demo; using Photon.Chat.UtilityScripts; using Photon.Pun; using Photon.Realtime; using Photon.Realtime.Demo; using Steamworks; using TMPro; using Unity.Collections; using Unity.Mathematics; using UnityEditor.Localization.Samples; using UnityEngine; using UnityEngine.Audio; using UnityEngine.EventSystems; using UnityEngine.Events; using UnityEngine.InputSystem; using UnityEngine.Localization; using UnityEngine.Localization.Samples; using UnityEngine.Localization.Settings; using UnityEngine.Localization.Tables; using UnityEngine.Rendering; using UnityEngine.Rendering.Universal; using UnityEngine.ResourceManagement.AsyncOperations; using UnityEngine.UI; using UnityEngine.UI.ProceduralImage; using UnityEngine.UIElements; using Zorro.Core; using Zorro.Core.CLI; using Zorro.Core.Serizalization; using Zorro.Recorder; using Zorro.Settings; using Zorro.Settings.DebugUI; using Zorro.UI; using _02Scripts.Charts.Computes; [assembly: AssemblyVersion("0.0.0.0")] namespace On { public static class ArtifactBigSlapPainting { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Update(ArtifactBigSlapPainting self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Update(orig_Update orig, ArtifactBigSlapPainting self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ConfigItem(ArtifactBigSlapPainting self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactBigSlapPainting self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_RPCA_SpawnSlap(ArtifactBigSlapPainting self, BinaryDeserializer deserializer); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_RPCA_SpawnSlap(orig_RPCA_SpawnSlap orig, ArtifactBigSlapPainting self, BinaryDeserializer deserializer); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(ArtifactBigSlapPainting self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, ArtifactBigSlapPainting self); public static event hook_Update Update { add { HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ConfigItem ConfigItem { add { HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_RPCA_SpawnSlap RPCA_SpawnSlap { add { HookEndpointManager.Add<hook_RPCA_SpawnSlap>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_RPCA_SpawnSlap>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class ArtifactBigSlapPainting { public static event Manipulator Update { add { HookEndpointManager.Modify<On.ArtifactBigSlapPainting.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactBigSlapPainting.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ConfigItem { add { HookEndpointManager.Modify<On.ArtifactBigSlapPainting.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactBigSlapPainting.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator RPCA_SpawnSlap { add { HookEndpointManager.Modify<On.ArtifactBigSlapPainting.hook_RPCA_SpawnSlap>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactBigSlapPainting.hook_RPCA_SpawnSlap>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.ArtifactBigSlapPainting.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactBigSlapPainting.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class ArtifactBudget { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(ArtifactBudget self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, ArtifactBudget self); public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class ArtifactBudget { public static event Manipulator ctor { add { HookEndpointManager.Modify<On.ArtifactBudget.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactBudget.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class ArtifactGeneric { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ConfigItem(ArtifactGeneric self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactGeneric self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(ArtifactGeneric self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, ArtifactGeneric self); public static event hook_ConfigItem ConfigItem { add { HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class ArtifactGeneric { public static event Manipulator ConfigItem { add { HookEndpointManager.Modify<On.ArtifactGeneric.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactGeneric.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.ArtifactGeneric.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactGeneric.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class ArtifactGravityFlipperOff { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ConfigItem(ArtifactGravityFlipperOff self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactGravityFlipperOff self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Update(ArtifactGravityFlipperOff self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Update(orig_Update orig, ArtifactGravityFlipperOff self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(ArtifactGravityFlipperOff self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, ArtifactGravityFlipperOff self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate bool orig_<Update>b__3_0(ArtifactGravityFlipperOff self, CurseOfGravityFlip curse); [EditorBrowsable(EditorBrowsableState.Never)] public delegate bool hook_<Update>b__3_0(orig_<Update>b__3_0 orig, ArtifactGravityFlipperOff self, CurseOfGravityFlip curse); public static event hook_ConfigItem ConfigItem { add { HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_Update Update { add { HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_<Update>b__3_0 <Update>b__3_0 { add { HookEndpointManager.Add<hook_<Update>b__3_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_<Update>b__3_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class ArtifactGravityFlipperOff { public static event Manipulator ConfigItem { add { HookEndpointManager.Modify<On.ArtifactGravityFlipperOff.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOff.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator Update { add { HookEndpointManager.Modify<On.ArtifactGravityFlipperOff.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOff.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.ArtifactGravityFlipperOff.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOff.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator <Update>b__3_0 { add { HookEndpointManager.Modify<On.ArtifactGravityFlipperOff.hook_<Update>b__3_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOff.hook_<Update>b__3_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class ArtifactGravityFlipperOn { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ConfigItem(ArtifactGravityFlipperOn self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactGravityFlipperOn self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Update(ArtifactGravityFlipperOn self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Update(orig_Update orig, ArtifactGravityFlipperOn self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_OnFinishSpawning(ArtifactGravityFlipperOn self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_OnFinishSpawning(orig_OnFinishSpawning orig, ArtifactGravityFlipperOn self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(ArtifactGravityFlipperOn self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, ArtifactGravityFlipperOn self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate bool orig_<Update>b__6_0(ArtifactGravityFlipperOn self, CurseOfGravityFlip curse); [EditorBrowsable(EditorBrowsableState.Never)] public delegate bool hook_<Update>b__6_0(orig_<Update>b__6_0 orig, ArtifactGravityFlipperOn self, CurseOfGravityFlip curse); public static event hook_ConfigItem ConfigItem { add { HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_Update Update { add { HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_OnFinishSpawning OnFinishSpawning { add { HookEndpointManager.Add<hook_OnFinishSpawning>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_OnFinishSpawning>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_<Update>b__6_0 <Update>b__6_0 { add { HookEndpointManager.Add<hook_<Update>b__6_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_<Update>b__6_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class ArtifactGravityFlipperOn { public static event Manipulator ConfigItem { add { HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator Update { add { HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator OnFinishSpawning { add { HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_OnFinishSpawning>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_OnFinishSpawning>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator <Update>b__6_0 { add { HookEndpointManager.Modify<On.ArtifactGravityFlipperOn.hook_<Update>b__6_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactGravityFlipperOn.hook_<Update>b__6_0>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class ArtifactRadio { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Update(ArtifactRadio self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Update(orig_Update orig, ArtifactRadio self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ConfigItem(ArtifactRadio self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactRadio self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(ArtifactRadio self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, ArtifactRadio self); public static event hook_Update Update { add { HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ConfigItem ConfigItem { add { HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class ArtifactRadio { public static event Manipulator Update { add { HookEndpointManager.Modify<On.ArtifactRadio.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactRadio.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ConfigItem { add { HookEndpointManager.Modify<On.ArtifactRadio.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactRadio.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.ArtifactRadio.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactRadio.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class ArtifactSpawner { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Start(ArtifactSpawner self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Start(orig_Start orig, ArtifactSpawner self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Update(ArtifactSpawner self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Update(orig_Update orig, ArtifactSpawner self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(ArtifactSpawner self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, ArtifactSpawner self); public static event hook_Start Start { add { HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_Update Update { add { HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class ArtifactSpawner { public static event Manipulator Start { add { HookEndpointManager.Modify<On.ArtifactSpawner.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactSpawner.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator Update { add { HookEndpointManager.Modify<On.ArtifactSpawner.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactSpawner.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.ArtifactSpawner.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactSpawner.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class ArtifactWithCurse { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ConfigItem(ArtifactWithCurse self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactWithCurse self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_OnItemEquipped(ArtifactWithCurse self, Player player); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_OnItemEquipped(orig_OnItemEquipped orig, ArtifactWithCurse self, Player player); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_OnDestroy(ArtifactWithCurse self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_OnDestroy(orig_OnDestroy orig, ArtifactWithCurse self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(ArtifactWithCurse self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, ArtifactWithCurse self); public static event hook_ConfigItem ConfigItem { add { HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_OnItemEquipped OnItemEquipped { add { HookEndpointManager.Add<hook_OnItemEquipped>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_OnItemEquipped>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_OnDestroy OnDestroy { add { HookEndpointManager.Add<hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class ArtifactWithCurse { public static event Manipulator ConfigItem { add { HookEndpointManager.Modify<On.ArtifactWithCurse.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactWithCurse.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator OnItemEquipped { add { HookEndpointManager.Modify<On.ArtifactWithCurse.hook_OnItemEquipped>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactWithCurse.hook_OnItemEquipped>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator OnDestroy { add { HookEndpointManager.Modify<On.ArtifactWithCurse.hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactWithCurse.hook_OnDestroy>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.ArtifactWithCurse.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactWithCurse.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class ArtifactZombieBook { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Update(ArtifactZombieBook self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Update(orig_Update orig, ArtifactZombieBook self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ConfigItem(ArtifactZombieBook self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ConfigItem(orig_ConfigItem orig, ArtifactZombieBook self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(ArtifactZombieBook self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, ArtifactZombieBook self); public static event hook_Update Update { add { HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ConfigItem ConfigItem { add { HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class ArtifactZombieBook { public static event Manipulator Update { add { HookEndpointManager.Modify<On.ArtifactZombieBook.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactZombieBook.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ConfigItem { add { HookEndpointManager.Modify<On.ArtifactZombieBook.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactZombieBook.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.ArtifactZombieBook.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.ArtifactZombieBook.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class CurseDataBase { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Start(CurseDataBase self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Start(orig_Start orig, CurseDataBase self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Update(CurseDataBase self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Update(orig_Update orig, CurseDataBase self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(CurseDataBase self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, CurseDataBase self); public static event hook_Start Start { add { HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_Update Update { add { HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class CurseDataBase { public static event Manipulator Start { add { HookEndpointManager.Modify<On.CurseDataBase.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.CurseDataBase.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator Update { add { HookEndpointManager.Modify<On.CurseDataBase.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.CurseDataBase.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.CurseDataBase.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.CurseDataBase.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class CursedPlayerBoss { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_SpawnCurse(CursedPlayerBoss self, ItemInstanceBehaviour artifact, GameObject cursePrefab); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_SpawnCurse(orig_SpawnCurse orig, CursedPlayerBoss self, ItemInstanceBehaviour artifact, GameObject cursePrefab); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Awake(CursedPlayerBoss self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Awake(orig_Awake orig, CursedPlayerBoss self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Start(CursedPlayerBoss self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Start(orig_Start orig, CursedPlayerBoss self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Update(CursedPlayerBoss self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Update(orig_Update orig, CursedPlayerBoss self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(CursedPlayerBoss self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, CursedPlayerBoss self); public static event hook_SpawnCurse SpawnCurse { add { HookEndpointManager.Add<hook_SpawnCurse>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_SpawnCurse>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_Awake Awake { add { HookEndpointManager.Add<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_Start Start { add { HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_Update Update { add { HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class CursedPlayerBoss { public static event Manipulator SpawnCurse { add { HookEndpointManager.Modify<On.CursedPlayerBoss.hook_SpawnCurse>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_SpawnCurse>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator Awake { add { HookEndpointManager.Modify<On.CursedPlayerBoss.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator Start { add { HookEndpointManager.Modify<On.CursedPlayerBoss.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator Update { add { HookEndpointManager.Modify<On.CursedPlayerBoss.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.CursedPlayerBoss.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.CursedPlayerBoss.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class PersistantRadio { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Update(PersistantRadio self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Update(orig_Update orig, PersistantRadio self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ConfigItem(PersistantRadio self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ConfigItem(orig_ConfigItem orig, PersistantRadio self, ItemInstanceData data, PhotonView playerView); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(PersistantRadio self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, PersistantRadio self); public static event hook_Update Update { add { HookEndpointManager.Add<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ConfigItem ConfigItem { add { HookEndpointManager.Add<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class PersistantRadio { public static event Manipulator Update { add { HookEndpointManager.Modify<On.PersistantRadio.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.PersistantRadio.hook_Update>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ConfigItem { add { HookEndpointManager.Modify<On.PersistantRadio.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.PersistantRadio.hook_ConfigItem>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.PersistantRadio.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.PersistantRadio.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class RoundArtifactSpawner { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Awake(RoundArtifactSpawner self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Awake(orig_Awake orig, RoundArtifactSpawner self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate IEnumerator orig_Start(RoundArtifactSpawner self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate IEnumerator hook_Start(orig_Start orig, RoundArtifactSpawner self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_SpawnRound(RoundArtifactSpawner self, int budget, float rarestPurchase); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_SpawnRound(orig_SpawnRound orig, RoundArtifactSpawner self, int budget, float rarestPurchase); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_PrintArtifactsPerDay(RoundArtifactSpawner self, int day, int times); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_PrintArtifactsPerDay(orig_PrintArtifactsPerDay orig, RoundArtifactSpawner self, int day, int times); [EditorBrowsable(EditorBrowsableState.Never)] public delegate List<Item> orig_GetArtifactsToSpawn(RoundArtifactSpawner self, int budget, float rarestPurchase); [EditorBrowsable(EditorBrowsableState.Never)] public delegate List<Item> hook_GetArtifactsToSpawn(orig_GetArtifactsToSpawn orig, RoundArtifactSpawner self, int budget, float rarestPurchase); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_CreateArtifactSpawners(RoundArtifactSpawner self, List<Item> artifacts); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_CreateArtifactSpawners(orig_CreateArtifactSpawners orig, RoundArtifactSpawner self, List<Item> artifacts); [EditorBrowsable(EditorBrowsableState.Never)] public delegate Vector3 orig_GetRandPointWithWeight(); [EditorBrowsable(EditorBrowsableState.Never)] public delegate Vector3 hook_GetRandPointWithWeight(orig_GetRandPointWithWeight orig); [EditorBrowsable(EditorBrowsableState.Never)] public delegate Item orig_GetArtifact(ref int budget, Item[] possibleSpawns, float rarestPurchase); [EditorBrowsable(EditorBrowsableState.Never)] public delegate Item hook_GetArtifact(orig_GetArtifact orig, ref int budget, Item[] possibleSpawns, float rarestPurchase); [EditorBrowsable(EditorBrowsableState.Never)] public delegate Item orig_GetRandomArtifactByRarity(Item[] possibleSpawns); [EditorBrowsable(EditorBrowsableState.Never)] public delegate Item hook_GetRandomArtifactByRarity(orig_GetRandomArtifactByRarity orig, Item[] possibleSpawns); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(RoundArtifactSpawner self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, RoundArtifactSpawner self); public static class ArtifactWithWeight { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(ArtifactWithWeight self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, ArtifactWithWeight self); public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } public static event hook_Awake Awake { add { HookEndpointManager.Add<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_Start Start { add { HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_SpawnRound SpawnRound { add { HookEndpointManager.Add<hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_PrintArtifactsPerDay PrintArtifactsPerDay { add { HookEndpointManager.Add<hook_PrintArtifactsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_PrintArtifactsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_GetArtifactsToSpawn GetArtifactsToSpawn { add { HookEndpointManager.Add<hook_GetArtifactsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_GetArtifactsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_CreateArtifactSpawners CreateArtifactSpawners { add { HookEndpointManager.Add<hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_GetRandPointWithWeight GetRandPointWithWeight { add { HookEndpointManager.Add<hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_GetArtifact GetArtifact { add { HookEndpointManager.Add<hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_GetRandomArtifactByRarity GetRandomArtifactByRarity { add { HookEndpointManager.Add<hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class RoundArtifactSpawner { public static class ArtifactWithWeight { public static event Manipulator ctor { add { HookEndpointManager.Modify<On.RoundArtifactSpawner.ArtifactWithWeight.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundArtifactSpawner.ArtifactWithWeight.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } public static event Manipulator Awake { add { HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator Start { add { HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator SpawnRound { add { HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator PrintArtifactsPerDay { add { HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_PrintArtifactsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_PrintArtifactsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator GetArtifactsToSpawn { add { HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_GetArtifactsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_GetArtifactsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator CreateArtifactSpawners { add { HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator GetRandPointWithWeight { add { HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator GetArtifact { add { HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator GetRandomArtifactByRarity { add { HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.RoundArtifactSpawner.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundArtifactSpawner.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class RoundSpawnerTools { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Awake(RoundSpawnerTools self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Awake(orig_Awake orig, RoundSpawnerTools self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Populate(RoundSpawnerTools self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Populate(orig_Populate orig, RoundSpawnerTools self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate IEnumerator orig_Start(RoundSpawnerTools self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate IEnumerator hook_Start(orig_Start orig, RoundSpawnerTools self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_SpawnRound(RoundSpawnerTools self, int budget, float rarestPurchase); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_SpawnRound(orig_SpawnRound orig, RoundSpawnerTools self, int budget, float rarestPurchase); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_PrintToolsPerDay(RoundSpawnerTools self, int day, int times); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_PrintToolsPerDay(orig_PrintToolsPerDay orig, RoundSpawnerTools self, int day, int times); [EditorBrowsable(EditorBrowsableState.Never)] public delegate List<Item> orig_GetToolsToSpawn(RoundSpawnerTools self, int budget, float rarestPurchase); [EditorBrowsable(EditorBrowsableState.Never)] public delegate List<Item> hook_GetToolsToSpawn(orig_GetToolsToSpawn orig, RoundSpawnerTools self, int budget, float rarestPurchase); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_CreateArtifactSpawners(RoundSpawnerTools self, List<Item> artifacts); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_CreateArtifactSpawners(orig_CreateArtifactSpawners orig, RoundSpawnerTools self, List<Item> artifacts); [EditorBrowsable(EditorBrowsableState.Never)] public delegate Vector3 orig_GetRandPointWithWeight(); [EditorBrowsable(EditorBrowsableState.Never)] public delegate Vector3 hook_GetRandPointWithWeight(orig_GetRandPointWithWeight orig); [EditorBrowsable(EditorBrowsableState.Never)] public delegate Item orig_GetArtifact(ref int budget, List<Item> possibleSpawns, float rarestPurchase); [EditorBrowsable(EditorBrowsableState.Never)] public delegate Item hook_GetArtifact(orig_GetArtifact orig, ref int budget, List<Item> possibleSpawns, float rarestPurchase); [EditorBrowsable(EditorBrowsableState.Never)] public delegate Item orig_GetRandomArtifactByRarity(Item[] possibleSpawns); [EditorBrowsable(EditorBrowsableState.Never)] public delegate Item hook_GetRandomArtifactByRarity(orig_GetRandomArtifactByRarity orig, Item[] possibleSpawns); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(RoundSpawnerTools self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, RoundSpawnerTools self); public static class ToolWithWeight { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(ToolWithWeight self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, ToolWithWeight self); public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } public static event hook_Awake Awake { add { HookEndpointManager.Add<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_Populate Populate { add { HookEndpointManager.Add<hook_Populate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Populate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_Start Start { add { HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_SpawnRound SpawnRound { add { HookEndpointManager.Add<hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_PrintToolsPerDay PrintToolsPerDay { add { HookEndpointManager.Add<hook_PrintToolsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_PrintToolsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_GetToolsToSpawn GetToolsToSpawn { add { HookEndpointManager.Add<hook_GetToolsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_GetToolsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_CreateArtifactSpawners CreateArtifactSpawners { add { HookEndpointManager.Add<hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_GetRandPointWithWeight GetRandPointWithWeight { add { HookEndpointManager.Add<hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_GetArtifact GetArtifact { add { HookEndpointManager.Add<hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_GetRandomArtifactByRarity GetRandomArtifactByRarity { add { HookEndpointManager.Add<hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class RoundSpawnerTools { public static class ToolWithWeight { public static event Manipulator ctor { add { HookEndpointManager.Modify<On.RoundSpawnerTools.ToolWithWeight.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundSpawnerTools.ToolWithWeight.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } public static event Manipulator Awake { add { HookEndpointManager.Modify<On.RoundSpawnerTools.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_Awake>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator Populate { add { HookEndpointManager.Modify<On.RoundSpawnerTools.hook_Populate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_Populate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator Start { add { HookEndpointManager.Modify<On.RoundSpawnerTools.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator SpawnRound { add { HookEndpointManager.Modify<On.RoundSpawnerTools.hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_SpawnRound>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator PrintToolsPerDay { add { HookEndpointManager.Modify<On.RoundSpawnerTools.hook_PrintToolsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_PrintToolsPerDay>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator GetToolsToSpawn { add { HookEndpointManager.Modify<On.RoundSpawnerTools.hook_GetToolsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_GetToolsToSpawn>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator CreateArtifactSpawners { add { HookEndpointManager.Modify<On.RoundSpawnerTools.hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_CreateArtifactSpawners>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator GetRandPointWithWeight { add { HookEndpointManager.Modify<On.RoundSpawnerTools.hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_GetRandPointWithWeight>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator GetArtifact { add { HookEndpointManager.Modify<On.RoundSpawnerTools.hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_GetArtifact>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator GetRandomArtifactByRarity { add { HookEndpointManager.Modify<On.RoundSpawnerTools.hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_GetRandomArtifactByRarity>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.RoundSpawnerTools.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.RoundSpawnerTools.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class AspectRatioUISetter { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_SetDefault(AspectRatioUISetter self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_SetDefault(orig_SetDefault orig, AspectRatioUISetter self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_SetAspectPosition(AspectRatioUISetter self, AspectRatio aspectRatio); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_SetAspectPosition(orig_SetAspectPosition orig, AspectRatioUISetter self, AspectRatio aspectRatio); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_LoadAspectPosition(AspectRatioUISetter self, AspectRatio aspectRatio); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_LoadAspectPosition(orig_LoadAspectPosition orig, AspectRatioUISetter self, AspectRatio aspectRatio); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(AspectRatioUISetter self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, AspectRatioUISetter self); public static class AspectPosition { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(AspectPosition self, RectTransform rectTransform); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, AspectPosition self, RectTransform rectTransform); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Load(AspectPosition self, RectTransform rectTransform); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Load(orig_Load orig, AspectPosition self, RectTransform rectTransform); public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_Load Load { add { HookEndpointManager.Add<hook_Load>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Load>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } public static class SavedAspectPosition { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(SavedAspectPosition self, AspectRatio aspectRatio, AspectPosition aspectPosition); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, SavedAspectPosition self, AspectRatio aspectRatio, AspectPosition aspectPosition); public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } public static event hook_SetDefault SetDefault { add { HookEndpointManager.Add<hook_SetDefault>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_SetDefault>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_SetAspectPosition SetAspectPosition { add { HookEndpointManager.Add<hook_SetAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_SetAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_LoadAspectPosition LoadAspectPosition { add { HookEndpointManager.Add<hook_LoadAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_LoadAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class AspectRatioUISetter { public static class AspectPosition { public static event Manipulator ctor { add { HookEndpointManager.Modify<On.AspectRatioUISetter.AspectPosition.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AspectRatioUISetter.AspectPosition.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator Load { add { HookEndpointManager.Modify<On.AspectRatioUISetter.AspectPosition.hook_Load>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AspectRatioUISetter.AspectPosition.hook_Load>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } public static class SavedAspectPosition { public static event Manipulator ctor { add { HookEndpointManager.Modify<On.AspectRatioUISetter.SavedAspectPosition.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AspectRatioUISetter.SavedAspectPosition.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } public static event Manipulator SetDefault { add { HookEndpointManager.Modify<On.AspectRatioUISetter.hook_SetDefault>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AspectRatioUISetter.hook_SetDefault>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator SetAspectPosition { add { HookEndpointManager.Modify<On.AspectRatioUISetter.hook_SetAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AspectRatioUISetter.hook_SetAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator LoadAspectPosition { add { HookEndpointManager.Modify<On.AspectRatioUISetter.hook_LoadAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AspectRatioUISetter.hook_LoadAspectPosition>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.AspectRatioUISetter.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AspectRatioUISetter.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class AudioLoop { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Start(AudioLoop self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Start(orig_Start orig, AudioLoop self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_OnEnable(AudioLoop self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_OnEnable(orig_OnEnable orig, AudioLoop self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_OnDisable(AudioLoop self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_OnDisable(orig_OnDisable orig, AudioLoop self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_SetTime(AudioLoop self, float timeInSong); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_SetTime(orig_SetTime orig, AudioLoop self, float timeInSong); [EditorBrowsable(EditorBrowsableState.Never)] public delegate bool orig_TryGetOverrideTime(AudioLoop self, out float f); [EditorBrowsable(EditorBrowsableState.Never)] public delegate bool hook_TryGetOverrideTime(orig_TryGetOverrideTime orig, AudioLoop self, out float f); [EditorBrowsable(EditorBrowsableState.Never)] public delegate bool orig_CheckBoost(AudioLoop self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate bool hook_CheckBoost(orig_CheckBoost orig, AudioLoop self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(AudioLoop self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, AudioLoop self); public static event hook_Start Start { add { HookEndpointManager.Add<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_OnEnable OnEnable { add { HookEndpointManager.Add<hook_OnEnable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_OnEnable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_OnDisable OnDisable { add { HookEndpointManager.Add<hook_OnDisable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_OnDisable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_SetTime SetTime { add { HookEndpointManager.Add<hook_SetTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_SetTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_TryGetOverrideTime TryGetOverrideTime { add { HookEndpointManager.Add<hook_TryGetOverrideTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_TryGetOverrideTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_CheckBoost CheckBoost { add { HookEndpointManager.Add<hook_CheckBoost>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_CheckBoost>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class AudioLoop { public static event Manipulator Start { add { HookEndpointManager.Modify<On.AudioLoop.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoop.hook_Start>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator OnEnable { add { HookEndpointManager.Modify<On.AudioLoop.hook_OnEnable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoop.hook_OnEnable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator OnDisable { add { HookEndpointManager.Modify<On.AudioLoop.hook_OnDisable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoop.hook_OnDisable>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator SetTime { add { HookEndpointManager.Modify<On.AudioLoop.hook_SetTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoop.hook_SetTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator TryGetOverrideTime { add { HookEndpointManager.Modify<On.AudioLoop.hook_TryGetOverrideTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoop.hook_TryGetOverrideTime>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator CheckBoost { add { HookEndpointManager.Modify<On.AudioLoop.hook_CheckBoost>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoop.hook_CheckBoost>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.AudioLoop.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoop.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class AudioLoopHandler { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_RegisterAudioLoop(AudioLoop audioLoop); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_RegisterAudioLoop(orig_RegisterAudioLoop orig, AudioLoop audioLoop); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_UnregisterAudioLoop(AudioLoop audioLoop); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_UnregisterAudioLoop(orig_UnregisterAudioLoop orig, AudioLoop audioLoop); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_LateUpdate(AudioLoopHandler self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_LateUpdate(orig_LateUpdate orig, AudioLoopHandler self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_RemoveSource(AudioLoopHandler self, AudioLoop audioLoop); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_RemoveSource(orig_RemoveSource orig, AudioLoopHandler self, AudioLoop audioLoop); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_AssignSource(AudioLoopHandler self, AudioLoop audioLoop); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_AssignSource(orig_AssignSource orig, AudioLoopHandler self, AudioLoop audioLoop); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_ctor(AudioLoopHandler self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_ctor(orig_ctor orig, AudioLoopHandler self); public static event hook_RegisterAudioLoop RegisterAudioLoop { add { HookEndpointManager.Add<hook_RegisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_RegisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_UnregisterAudioLoop UnregisterAudioLoop { add { HookEndpointManager.Add<hook_UnregisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_UnregisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_LateUpdate LateUpdate { add { HookEndpointManager.Add<hook_LateUpdate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_LateUpdate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_RemoveSource RemoveSource { add { HookEndpointManager.Add<hook_RemoveSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_RemoveSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_AssignSource AssignSource { add { HookEndpointManager.Add<hook_AssignSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_AssignSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } public static event hook_ctor ctor { add { HookEndpointManager.Add<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class AudioLoopHandler { public static event Manipulator RegisterAudioLoop { add { HookEndpointManager.Modify<On.AudioLoopHandler.hook_RegisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_RegisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator UnregisterAudioLoop { add { HookEndpointManager.Modify<On.AudioLoopHandler.hook_UnregisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_UnregisterAudioLoop>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator LateUpdate { add { HookEndpointManager.Modify<On.AudioLoopHandler.hook_LateUpdate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_LateUpdate>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator RemoveSource { add { HookEndpointManager.Modify<On.AudioLoopHandler.hook_RemoveSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_RemoveSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator AssignSource { add { HookEndpointManager.Modify<On.AudioLoopHandler.hook_AssignSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_AssignSource>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } public static event Manipulator ctor { add { HookEndpointManager.Modify<On.AudioLoopHandler.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioLoopHandler.hook_ctor>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class AudioObstructability { [EditorBrowsable(EditorBrowsableState.Never)] public delegate float orig_GetObstructionValue(Vector3 position, float obstructability, out float rangeFactor); [EditorBrowsable(EditorBrowsableState.Never)] public delegate float hook_GetObstructionValue(orig_GetObstructionValue orig, Vector3 position, float obstructability, out float rangeFactor); public static event hook_GetObstructionValue GetObstructionValue { add { HookEndpointManager.Add<hook_GetObstructionValue>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } remove { HookEndpointManager.Remove<hook_GetObstructionValue>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)value); } } } } namespace IL { public static class AudioObstructability { public static event Manipulator GetObstructionValue { add { HookEndpointManager.Modify<On.AudioObstructability.hook_GetObstructionValue>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } remove { HookEndpointManager.Unmodify<On.AudioObstructability.hook_GetObstructionValue>(MethodBase.GetMethodFromHandle((RuntimeMethodHandle)/*OpCode not supported: LdMemberToken*/), (Delegate)(object)value); } } } } namespace On { public static class AudioToggler { [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Start(AudioToggler self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook_Start(orig_Start orig, AudioToggler self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void orig_Update(AudioToggler self); [EditorBrowsable(EditorBrowsableState.Never)] public delegate void hook

Content Warning

Keep Camera After Death

Details

Categories

alexandria-p.KeepCameraAfterDeath.dll

Dependencies/MMHOOK_Assembly-CSharp.dll

Categories

alexandria-p.KeepCameraAfterDeath.dll

Dependencies/MMHOOK_Assembly-CSharp.dll

Categories